CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-astropy

Astronomy and astrophysics core library providing comprehensive tools for astronomical computations and data handling

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview
Eval results
Files

configuration.mddocs/

Configuration

Package configuration system and structured logging for astronomical applications with persistent settings and runtime control.

Capabilities

Configuration Classes

Configuration system for managing package settings with validation, persistence, and hierarchical organization.

class ConfigNamespace:
    """
    Base class for configuration namespaces containing ConfigItem members.
    
    Provides hierarchical organization of configuration parameters
    with automatic file persistence and runtime modification.
    """
    def __init__(self): ...
    
    def reload(self, attr=None):
        """Reload configuration from file."""
    
    def reset(self, attr=None):  
        """Reset configuration to defaults."""
    
    def set_temp(self, attr, value):
        """Temporarily set configuration value."""

class ConfigItem:
    """
    Individual configuration parameter with validation and persistence.
    
    Parameters:
    - defaultvalue: default parameter value
    - description: parameter description
    - cfgtype: configuration type specification
    - module: module this item belongs to
    - aliases: alternative names for this parameter
    """
    def __init__(self, defaultvalue='', description='', cfgtype=None, 
                 module=None, aliases=None): ...
    
    def set(self, value):
        """Set configuration value with validation."""
    
    def reload(self):
        """Reload value from configuration file."""
    
    def reset(self):
        """Reset to default value."""
    
    @property
    def description(self):
        """Parameter description."""
    
    @property
    def cfgtype(self):
        """Configuration type."""
    
    @property
    def module(self):
        """Associated module."""
    
    @property
    def aliases(self):
        """Parameter aliases."""

Configuration Management Functions

Functions for managing configuration files, directories, and global settings.

def get_config(packageormod=None, reload=False, rootname='astropy'):
    """
    Get configuration object for package or module.
    
    Parameters:
    - packageormod: package/module or name
    - reload: reload from file
    - rootname: root configuration name
    
    Returns:
    ConfigNamespace: configuration object
    """

def reload_config(packageormod=None, rootname='astropy'):
    """
    Reload configuration from file.
    
    Parameters:
    - packageormod: package/module to reload
    - rootname: root configuration name
    """

def generate_config(pkgname='astropy', filename=None, verbose=False):
    """
    Generate configuration file from ConfigItems.
    
    Parameters:
    - pkgname: package name
    - filename: output filename (default: auto-generated)
    - verbose: print verbose output
    
    Returns:
    str: generated configuration content
    """

def create_config_file(pkg, rootname='astropy', overwrite=False):
    """
    Create configuration file for package.
    
    Parameters:
    - pkg: package object
    - rootname: root configuration name
    - overwrite: overwrite existing file
    """

def get_config_dir(rootname='astropy'):
    """
    Get configuration directory path.
    
    Parameters:
    - rootname: root name for configuration
    
    Returns:
    str: configuration directory path
    """

def get_cache_dir(rootname='astropy'):
    """
    Get cache directory path.
    
    Parameters:
    - rootname: root name for cache
    
    Returns:
    str: cache directory path
    """

def set_temp_config(path=None, delete=False):
    """
    Context manager for temporary configuration directory.
    
    Parameters:
    - path: temporary directory path
    - delete: delete directory on exit
    
    Returns:
    context manager
    """

def set_temp_cache(path=None, delete=False):
    """
    Context manager for temporary cache directory.
    
    Parameters:
    - path: temporary directory path  
    - delete: delete directory on exit
    
    Returns:
    context manager
    """

Logging System

Structured logging system for astronomical applications with configurable output and filtering.

# Access main logger
from astropy import log

# Logger configuration
log.setLevel('INFO')     # Set logging level
log.addHandler(handler)  # Add custom handler
log.removeHandler(handler)  # Remove handler

# Logging methods
log.debug("Debug message")
log.info("Info message") 
log.warning("Warning message")
log.error("Error message")
log.critical("Critical message")

# Exception logging
try:
    # Some operation
    pass
except Exception as e:
    log.exception("Operation failed")

# Logging with context
with log.log_to_file('output.log'):
    log.info("This goes to file")

# Disable/enable logging
log.disable_warnings_logging()
log.enable_warnings_logging()

Configuration Examples

Built-in configuration parameters for common astropy settings.

# Main astropy configuration
from astropy import conf

# Display and output settings
conf.unicode_output: ConfigItem      # Use Unicode characters in output
conf.use_color: ConfigItem          # Use ANSI color codes
conf.max_lines: ConfigItem          # Maximum display lines
conf.max_width: ConfigItem          # Maximum display width

# Download and caching
conf.download_cache_timeout: ConfigItem    # Download timeout
conf.delete_temporary_downloads_at_exit: ConfigItem  # Cleanup temp files
conf.compute_hash_block_size: ConfigItem   # Hash computation block size

# Example usage
conf.unicode_output = True
conf.max_lines = 50

Usage Examples

Basic Configuration Management

from astropy import config
from astropy.config import ConfigItem, ConfigNamespace

# Create custom configuration namespace
class MyConfig(ConfigNamespace):
    # Define configuration items
    data_dir = ConfigItem(
        '/tmp/data',
        'Directory for data files',
        cfgtype='string'
    )
    
    max_files = ConfigItem(
        100,
        'Maximum number of files to process',
        cfgtype='integer'
    )
    
    verbose = ConfigItem(
        False,
        'Enable verbose output',
        cfgtype='boolean'
    )

# Use configuration
my_conf = MyConfig()
print(f"Data directory: {my_conf.data_dir}")
print(f"Max files: {my_conf.max_files}")

# Modify configuration
my_conf.verbose = True
my_conf.max_files = 200

Configuration Files

from astropy.config import generate_config, get_config_dir
import os

# Get configuration directory
config_dir = get_config_dir()
print(f"Configuration directory: {config_dir}")

# Generate configuration file content
config_content = generate_config('astropy', verbose=True)
print("Generated configuration:")
print(config_content[:500] + "...")

# Write custom configuration
config_file = os.path.join(config_dir, 'astropy.cfg')
with open(config_file, 'w') as f:
    f.write("""
[astropy]
unicode_output = True
use_color = True
max_lines = 100

[coordinates]  
auto_download_sites = True
""")

# Reload configuration
from astropy import conf
conf.reload()

Temporary Configuration Changes

from astropy import conf
from astropy.config import set_temp_config
import tempfile

# Temporary configuration values
print(f"Original max_lines: {conf.max_lines}")

with conf.set_temp('max_lines', 25):
    print(f"Temporary max_lines: {conf.max_lines}")
    # Configuration change is active here

print(f"Restored max_lines: {conf.max_lines}")

# Temporary configuration directory
with set_temp_config() as temp_dir:
    print(f"Using temporary config dir: {temp_dir}")
    # Custom configuration active in this block

Logging Configuration

from astropy import log
import logging

# Set logging level
log.setLevel('DEBUG')

# Log messages at different levels
log.debug("Detailed debugging information")
log.info("General information")
log.warning("Something might be wrong")
log.error("An error occurred")

# Configure log format
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)

# Log to file
with log.log_to_file('astropy.log', filter_level='INFO'):
    log.info("This message goes to file")
    log.debug("This debug message is filtered out")

# Capture warnings
import warnings
with log.enable_warnings_logging():
    warnings.warn("This warning will be logged")

Advanced Configuration Patterns

from astropy.config import ConfigItem, ConfigNamespace
from astropy import units as u

# Configuration with units and validation
class ObservatoryConfig(ConfigNamespace):
    latitude = ConfigItem(
        0.0 * u.degree,
        'Observatory latitude',
        cfgtype='angle'
    )
    
    longitude = ConfigItem( 
        0.0 * u.degree,
        'Observatory longitude',
        cfgtype='angle'
    )
    
    elevation = ConfigItem(
        0.0 * u.meter,
        'Observatory elevation',
        cfgtype='length'
    )
    
    def validate_coordinates(self):
        \"\"\"Validate observatory coordinates.\"\"\"
        if abs(self.latitude) > 90 * u.degree:
            raise ValueError("Invalid latitude")
        if abs(self.longitude) > 180 * u.degree:
            raise ValueError("Invalid longitude")

# Use with validation
obs_conf = ObservatoryConfig()
obs_conf.latitude = 37.2431 * u.degree  # Lick Observatory
obs_conf.longitude = -121.6369 * u.degree
obs_conf.elevation = 1283 * u.meter
obs_conf.validate_coordinates()

Package-Specific Configuration

# Access configuration for specific astropy subpackages
from astropy.table import conf as table_conf
from astropy.coordinates import conf as coord_conf
from astropy.units import conf as units_conf

# Table configuration
print(f"Table max lines: {table_conf.max_lines}")
print(f"Table max width: {table_conf.max_width}")

# Coordinates configuration  
print(f"Auto download sites: {coord_conf.auto_download_sites}")

# Units configuration
print(f"Enabled equivalencies: {units_conf.enable_equivalencies}")

# Modify subpackage configuration
table_conf.max_lines = 25
coord_conf.auto_download_sites = False

Configuration in Scripts and Applications

#!/usr/bin/env python
\"\"\"
Example script using astropy configuration system.
\"\"\"

from astropy.config import ConfigNamespace, ConfigItem
from astropy import log
import sys

class ScriptConfig(ConfigNamespace):
    input_file = ConfigItem(
        'data.fits',
        'Input FITS file to process'
    )
    
    output_dir = ConfigItem(
        './output',
        'Output directory for results'
    )
    
    debug = ConfigItem(
        False,
        'Enable debug output'
    )

def main():
    # Initialize configuration
    conf = ScriptConfig()
    
    # Set logging level based on configuration
    if conf.debug:
        log.setLevel('DEBUG')
    else:
        log.setLevel('INFO')
    
    log.info(f"Processing file: {conf.input_file}")
    log.info(f"Output directory: {conf.output_dir}")
    
    # Process data using configuration values
    # ...
    
if __name__ == '__main__':
    main()

Install with Tessl CLI

npx tessl i tessl/pypi-astropy

docs

configuration.md

constants.md

convolution.md

coordinates.md

cosmology.md

fits-io.md

index.md

modeling.md

nddata.md

samp.md

statistics.md

tables.md

time.md

timeseries.md

uncertainty.md

units-quantities.md

utils.md

visualization.md

wcs.md

tile.json