emcd-appcore¶
🏗️ A Python library package which provides application foundation components - streamlined async initialization, configuration management, platform directories, logging setup, and environment handling for Python applications.
Key Features ⭐¶
🚀 Async Application Initialization: Single
prepare()function that sets up your entire application foundation with sensible defaults.📁 Platform Directory Management: Automatic discovery and creation of platform-specific directories for configuration, data, and cache.
⚙️ TOML Configuration System: Hierarchical configuration loading with includes, template variables, and overrides. Can bring your own configuration system too.
🎯 Distribution Detection: Automatic detection of development vs production deployment modes with package introspection.
📝 Logging Configuration: Logging setup with plain and rich modes and environment variable overrides.
🔄 Resource Management: Integration with
AsyncExitStackfor proper cleanup of async resources.🏷️ Safety: Full type annotations with immutable data structures for thread safety.
Installation 📦¶
Method: Install Python Package¶
Install via uv pip
command:
uv pip install emcd-appcore
Or, install via pip:
pip install emcd-appcore
Examples 💡¶
Quick Start 🚀¶
The simplest way to initialize your application:
>>> import asyncio
>>> import contextlib
>>> import appcore
>>> async def main( ):
... async with contextlib.AsyncExitStack( ) as exits:
... # Initialize application core with auto-detection
... auxdata = await appcore.prepare( exits )
... print( f"App: {auxdata.application.name}" )
... print( f"Mode: {'dev' if auxdata.distribution.editable else 'prod'}" )
... return auxdata.configuration
>>> # asyncio.run( main( ) ) # Returns configuration dictionary
Configuration Access ⚙️¶
Access your application’s TOML configuration:
>>> async def show_config( ):
... async with contextlib.AsyncExitStack( ) as exits:
... auxdata = await appcore.prepare( exits )
... config = auxdata.configuration
... # Configuration loaded from general.toml in user config directory
... print( f"Available sections: {list( config.keys( ) )}" )
... # Access nested configuration values
... if 'app' in config:
... print( f"App name: {config[ 'app' ].get( 'name', 'Unknown' )}" )
... return config
>>> # asyncio.run( show_config( ) )
Platform Directories 📁¶
Access platform-specific directories for your application:
>>> async def show_directories( ):
... async with contextlib.AsyncExitStack( ) as exits:
... app_info = appcore.ApplicationInformation(
... name = 'my-app', publisher = 'MyCompany' )
... auxdata = await appcore.prepare( exits, application = app_info )
... dirs = auxdata.directories
... print( f"Config: {dirs.user_config_path}" )
... print( f"Data: {dirs.user_data_path}" )
... print( f"Cache: {dirs.user_cache_path}" )
>>> # asyncio.run( show_directories( ) )
Logging Configuration 📝¶
Configure logging with Rich support and environment overrides:
>>> import appcore
>>> async def setup_logging( ):
... async with contextlib.AsyncExitStack( ) as exits:
... # Rich logging with environment variable support
... inscription = appcore.inscription.Control(
... mode = appcore.inscription.Modes.Rich, level = 'debug' )
... auxdata = await appcore.prepare( exits, inscription = inscription )
... # Logging level can be overridden via MY_APP_INSCRIPTION_LEVEL
... return "Logging configured"
>>> # asyncio.run( setup_logging( ) )
Dependencies & Architecture 🏛️¶
Appcore is built on a foundation of proven, lightweight dependencies:
Configuration: Uses standard library
tomlifor TOML parsing with accretive data structures that can grow but never shrink.Platform Integration: Leverages
platformdirsfor cross-platform directory discovery andaiofilesfor async file operations.Logging Enhancement: Optional integration with Rich for enhanced console output with graceful fallbacks.
Distribution Management: Uses
importlib-metadataandimportlib-resourcesfor package introspection and resource handling.
The architecture emphasizes:
Immutability: All configuration and state objects are immutable after creation, preventing accidental modifications.
Async-First: Built from the ground up for async/await patterns with proper resource management.
Dependency Injection: Configurable components that can be replaced or extended without modifying core functionality.
Type Safety: Comprehensive type annotations for excellent IDE support and static analysis.
Contribution 🤝¶
Contribution to this project is welcome! However, it must follow the code of conduct for the project.
Please file bug reports and feature requests in the issue tracker or submit pull requests to improve the source code or documentation.
For development guidance and standards, please see the development guide.
More Flair¶
