pydantic-settings-manager 0.1.2__py3-none-any.whl → 0.2.2__py3-none-any.whl

pydantic_settings_manager/__init__.py

@@ -21,17 +21,17 @@ from .base import BaseSettingsManager
 from .mapped import MappedSettingsManager, SettingsMap
 from .single import SingleSettingsManager
 
-__version__ = "0.1.0"
+__version__ = "0.2.2"
 
 __all__ = [
     # Re-exports from pydantic_settings
     "BaseSettings",
-    "SettingsConfigDict",
     # Base manager
     "BaseSettingsManager",
-    # Single settings manager
-    "SingleSettingsManager",
     # Mapped settings manager
     "MappedSettingsManager",
+    "SettingsConfigDict",
     "SettingsMap",
+    # Single settings manager
+    "SingleSettingsManager",
 ]

pydantic_settings_manager/base.py

@@ -2,7 +2,7 @@
 Base classes for settings managers.
 """
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Generic, Type, TypeVar
+from typing import Any, Generic, TypeVar
 
 from pydantic_settings import BaseSettings
 
@@ -21,7 +21,7 @@ class BaseSettingsManager(ABC, Generic[T]):
     """
 
     @abstractmethod
-    def __init__(self, settings_cls: Type[T]):
+    def __init__(self, settings_cls: type[T]):
         """
         Initialize the settings manager.
 
@@ -31,7 +31,7 @@ class BaseSettingsManager(ABC, Generic[T]):
         self.settings_cls = settings_cls
         """The settings class being managed"""
 
-        self.user_config: Dict[str, Any] = {}
+        self.user_config: dict[str, Any] = {}
         """User configuration dictionary"""
 
     @property

pydantic_settings_manager/mapped.py

@@ -3,7 +3,7 @@ Mapped settings manager implementation.
 """
 from __future__ import annotations
 
-from typing import Any, Dict, Generic, Type
+from typing import Any, Generic
 
 from pydantic import BaseModel, Field
 from pydantic.main import create_model
@@ -30,7 +30,7 @@ class SettingsMap(BaseModel, Generic[T]):
     key: str = ""
     """The key of the currently active settings"""
 
-    map: Dict[str, T] = Field(default_factory=dict)
+    map: dict[str, T] = Field(default_factory=dict)
     """A dictionary mapping keys to settings objects"""
 
 
@@ -80,20 +80,20 @@ class MappedSettingsManager(BaseSettingsManager[T]):
         ```
     """
 
-    def __init__(self, settings_cls: Type[T]):
+    def __init__(self, settings_cls: type[T]):
         """
         Initialize the settings manager.
 
         Args:
             settings_cls: The settings class to manage
         """
-        self.settings_cls: Type[T] = settings_cls
+        self.settings_cls: type[T] = settings_cls
         """The settings class being managed"""
 
         self.cli_args: SettingsMap[T] = SettingsMap[T]()
         """Command line arguments"""
 
-        self.user_config: Dict[str, Any] = {}
+        self.user_config: dict[str, Any] = {}
         """User configuration"""
 
         self.system_settings: T = settings_cls()
@@ -128,7 +128,7 @@ class MappedSettingsManager(BaseSettingsManager[T]):
         self.clear()
 
     @property
-    def _cli_args_config(self) -> Dict[str, Any]:
+    def _cli_args_config(self) -> dict[str, Any]:
         """
         Get the command line arguments as a dictionary.
 
@@ -146,7 +146,7 @@ class MappedSettingsManager(BaseSettingsManager[T]):
         return diff_dict(base, target)
 
     @property
-    def _system_settings_config(self) -> Dict[str, Any]:
+    def _system_settings_config(self) -> dict[str, Any]:
         """
         Get the system settings as a dictionary.
 
@@ -180,7 +180,7 @@ class MappedSettingsManager(BaseSettingsManager[T]):
         DynamicMapSettings = create_model(
             "DynamicMapSettings",
             key=(str, ""),
-            map=(Dict[str, self.settings_cls], {}),  # type: ignore[name-defined]
+            map=(dict[str, self.settings_cls], {}),  # type: ignore[name-defined]
             __base__=SettingsMap[T],
         )
 
@@ -215,7 +215,7 @@ class MappedSettingsManager(BaseSettingsManager[T]):
             if not self.map_settings.map:
                 settings = self.settings_cls(**self.system_settings.model_dump())
             else:
-                key = list(self.map_settings.map.keys())[0]
+                key = next(iter(self.map_settings.map.keys()))
                 settings = self.map_settings.map[key]
         else:
             if self.map_settings.key not in self.map_settings.map:
@@ -272,7 +272,7 @@ class MappedSettingsManager(BaseSettingsManager[T]):
         return self.map_settings.key
 
     @property
-    def all_settings(self) -> Dict[str, T]:
+    def all_settings(self) -> dict[str, T]:
         """
         Get all settings.
 

pydantic_settings_manager/single.py

@@ -1,7 +1,7 @@
 """
 Single settings manager implementation.
 """
-from typing import Any, Dict, Type, Union
+from typing import Any, Union
 
 from .base import BaseSettingsManager, T
 from .utils import NestedDict, nested_dict, update_dict
@@ -42,20 +42,20 @@ class SingleSettingsManager(BaseSettingsManager[T]):
         ```
     """
 
-    def __init__(self, settings_cls: Type[T]):
+    def __init__(self, settings_cls: type[T]):
         """
         Initialize the settings manager.
 
         Args:
             settings_cls: The settings class to manage
         """
-        self.settings_cls: Type[T] = settings_cls
+        self.settings_cls: type[T] = settings_cls
         """The settings class being managed"""
 
         self.cli_args: NestedDict = nested_dict()
         """Command line arguments"""
 
-        self.user_config: Dict[str, Any] = {}
+        self.user_config: dict[str, Any] = {}
         """User configuration"""
 
         self._settings: Union[T, None] = None

pydantic_settings_manager/types.py

@@ -1,6 +1,7 @@
-from typing import Any, DefaultDict, Union
+from collections import defaultdict
+from typing import Any, Union
 
-NestedDict = DefaultDict[str, Union["NestedDict", Any]]
+NestedDict = defaultdict[str, Union["NestedDict", Any]]
 """
 ネストした辞書型
 """

pydantic_settings_manager/utils.py

@@ -2,12 +2,12 @@
 Utility functions for dictionary operations.
 """
 from collections import defaultdict
-from typing import Any, Dict
+from typing import Any
 
 from .types import NestedDict
 
 
-def diff_dict(base: Dict[str, Any], target: Dict[str, Any]) -> Dict[str, Any]:
+def diff_dict(base: dict[str, Any], target: dict[str, Any]) -> dict[str, Any]:
     """
     Get the difference between two dictionaries.
     Only includes keys where the values are different.
@@ -27,7 +27,7 @@ def diff_dict(base: Dict[str, Any], target: Dict[str, Any]) -> Dict[str, Any]:
     return result
 
 
-def update_dict(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
+def update_dict(base: dict[str, Any], update: dict[str, Any]) -> dict[str, Any]:
     """
     Update a dictionary with another dictionary.
     Performs a deep update.

pydantic_settings_manager-0.2.2.dist-info/METADATA

@@ -0,0 +1,372 @@
+Metadata-Version: 2.4
+Name: pydantic-settings-manager
+Version: 0.2.2
+Summary: A library for managing Pydantic settings objects
+Project-URL: homepage, https://github.com/kiarina/pydantic-settings-manager
+Project-URL: repository, https://github.com/kiarina/pydantic-settings-manager
+Project-URL: documentation, https://github.com/kiarina/pydantic-settings-manager
+Author-email: kiarina <kiarinadawa@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: configuration,pydantic,settings
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# pydantic-settings-manager
+
+A library for managing Pydantic settings objects.
+
+## Features
+
+- Two types of settings managers:
+  - `SingleSettingsManager`: For managing a single settings object
+  - `MappedSettingsManager`: For managing multiple settings objects mapped to keys
+- Support for loading settings from multiple sources
+- Command line argument overrides
+- Settings validation through Pydantic
+- Type hints and documentation
+
+## Installation
+
+```bash
+pip install pydantic-settings-manager
+```
+
+## Quick Start
+
+### Basic Usage
+
+Let's start with a simple example you can try immediately:
+
+```python
+from pydantic_settings import BaseSettings
+from pydantic_settings_manager import SingleSettingsManager
+
+# 1. Define your settings
+class AppSettings(BaseSettings):
+    app_name: str = "MyApp"
+    debug: bool = False
+    max_connections: int = 100
+
+# 2. Create a settings manager
+settings_manager = SingleSettingsManager(AppSettings)
+
+# 3. Use your settings
+settings = settings_manager.settings
+print(f"App: {settings.app_name}, Debug: {settings.debug}")
+```
+
+### Loading from Configuration Files
+
+You can load settings from external sources:
+
+```python
+# Load from a dictionary (could be from JSON, YAML, etc.)
+settings_manager.user_config = {
+    "app_name": "ProductionApp",
+    "debug": False,
+    "max_connections": 500
+}
+
+settings = settings_manager.settings
+print(f"App: {settings.app_name}")  # Output: App: ProductionApp
+```
+
+### Command Line Overrides
+
+Override specific settings at runtime:
+
+```python
+# Simulate command line arguments
+settings_manager.cli_args["debug"] = True
+settings_manager.cli_args["max_connections"] = 50
+
+# Clear cache to apply changes
+settings_manager.clear()
+
+settings = settings_manager.settings
+print(f"Debug: {settings.debug}")  # Output: Debug: True
+print(f"Connections: {settings.max_connections}")  # Output: Connections: 50
+```
+
+### Multiple Configurations (Mapped Settings)
+
+For managing multiple environments or configurations:
+
+```python
+from pydantic_settings_manager import MappedSettingsManager
+
+# Create a mapped settings manager
+mapped_manager = MappedSettingsManager(AppSettings)
+
+# Configure multiple environments
+mapped_manager.user_config = {
+    "map": {
+        "development": {
+            "app_name": "MyApp-Dev",
+            "debug": True,
+            "max_connections": 10
+        },
+        "production": {
+            "app_name": "MyApp-Prod", 
+            "debug": False,
+            "max_connections": 1000
+        }
+    }
+}
+
+# Switch between configurations
+mapped_manager.set_cli_args("development")
+dev_settings = mapped_manager.settings
+print(f"Dev: {dev_settings.app_name}, Debug: {dev_settings.debug}")
+
+mapped_manager.set_cli_args("production")
+prod_settings = mapped_manager.settings
+print(f"Prod: {prod_settings.app_name}, Debug: {prod_settings.debug}")
+```
+
+## Advanced Usage
+
+### Project Structure for Large Applications
+
+For complex applications with multiple modules, you can organize your settings like this:
+
+```
+your_project/
+├── hoge/
+│   ├── __init__.py
+│   ├── settings.py
+│   ├── client.py
+│   └── registry.py
+├── fuga/
+│   ├── __init__.py
+│   ├── settings.py
+│   ├── client.py
+│   └── registry.py
+├── bootstrap.py
+├── __main__.py
+└── config.yaml
+```
+
+### Module-based Settings Management
+
+```python
+# fuga/__init__.py
+from .settings import settings_manager
+
+__all__ = ["settings_manager"]
+```
+
+```python
+# fuga/settings.py
+from pydantic_settings import BaseSettings
+from pydantic_settings_manager import MappedSettingsManager
+
+class FugaSettings(BaseSettings):
+    name: str = "default"
+    api_key: str = "***"
+
+settings_manager = MappedSettingsManager(FugaSettings)
+```
+
+```python
+# fuga/client.py
+from .settings import FugaSettings
+
+class FugaClient:
+    def __init__(self, settings: FugaSettings):
+        self.settings = settings
+```
+
+```python
+# fuga/registry.py
+from .settings import settings_manager
+
+def create_fuga_client(config_key: str = ""):
+    settings = settings_manager.get_settings_by_key(config_key)
+    return FugaClient(settings)
+```
+
+### Bootstrap
+
+The bootstrap process loads configuration from external sources (like YAML files) and applies them to your settings managers. This allows you to centralize configuration management and easily switch between different environments.
+
+```yaml
+# config.yaml
+hoge:
+  name: "star"
+  value: 7
+fuga:
+  key: first
+  map:
+    first:
+      name: "first"
+      api_key: "***"
+    second:
+      name: "second"
+      api_key: "***"
+```
+
+```python
+# bootstrap.py
+import importlib
+import yaml
+
+from pydantic_settings_manager import BaseSettingsManager
+
+def bootstrap():
+    config = yaml.safe_load(open("/path/to/config.yaml"))
+
+    for module_name, user_config in config.items():
+        try:
+            module = importlib.import_module(module_name)
+            settings_manager = getattr(module, 'settings_manager', None)
+
+            if isinstance(settings_manager, BaseSettingsManager):
+                settings_manager.user_config = user_config
+                settings_manager.clear()
+```
+
+### CLI Integration
+
+You can integrate command-line arguments to override specific settings at runtime. This is useful for debugging, testing different configurations, or providing runtime flexibility without modifying configuration files.
+
+```python
+# __main__.py
+import click
+
+from .bootstrap import bootstrap
+from .hoge import settings_manager as hoge_settings_manager
+from .fuga import settings_manager as fuga_settings_manager
+
+@click.command
+@click.option("--name", type=str, default="", help="Name of the Hoge")
+@click.option("--key", type=str, default="", help="Key for Fuga settings")
+def main(name: str, key: str):
+    bootstrap()
+
+    if name:
+        hoge_settings_manager.cli_args["name"] = name
+        hoge_settings_manager.clear()
+
+    if key:
+        fuga_settings_manager.cli_args["key"] = key
+        fuga_settings_manager.clear()
+
+    # ...
+```
+
+## Related Tools
+
+### pydantic-config-builder
+
+For complex projects with multiple configuration files, you might want to use [`pydantic-config-builder`](https://github.com/kiarina/pydantic-config-builder) to merge and build your YAML configuration files:
+
+```bash
+pip install pydantic-config-builder
+```
+
+This tool allows you to:
+- Merge multiple YAML files into a single configuration
+- Use base configurations with overlay files
+- Build different configurations for different environments
+- Support glob patterns and recursive merging
+
+Example workflow:
+```yaml
+# pydantic_config_builder.yml
+development:
+  input:
+    - base/*.yaml
+    - dev-overrides.yaml
+  output:
+    - config/dev.yaml
+
+production:
+  input:
+    - base/*.yaml
+    - prod-overrides.yaml
+  output:
+    - config/prod.yaml
+```
+
+Then use the generated configurations with your settings manager:
+```python
+import yaml
+from your_app import settings_manager
+
+# Load the built configuration
+with open("config/dev.yaml") as f:
+    config = yaml.safe_load(f)
+
+settings_manager.user_config = config
+```
+
+## Development
+
+This project uses modern Python development tools with flexible dependency groups:
+
+- **ruff**: Fast linter and formatter (replaces black, isort, and flake8)
+- **mypy**: Static type checking
+- **pytest**: Testing framework with coverage reporting
+- **uv**: Fast Python package manager with PEP 735 dependency groups support
+
+### Setup
+
+```bash
+# Install all development dependencies
+uv sync --group dev
+
+# Or install specific dependency groups
+uv sync --group test    # Testing tools only
+uv sync --group lint    # Linting tools only
+
+# Format code
+uv run ruff check --fix .
+
+# Run linting
+uv run ruff check .
+uv run mypy .
+
+# Run tests
+uv run pytest --cov=pydantic_settings_manager tests/
+
+# Build and test everything
+make build
+```
+
+### Development Workflow
+
+```bash
+# Quick setup for testing
+uv sync --group test
+make test
+
+# Quick setup for linting
+uv sync --group lint
+make lint
+
+# Full development environment
+uv sync --group dev
+make build
+```
+
+## Documentation
+
+For more detailed documentation, please see the [GitHub repository](https://github.com/kiarina/pydantic-settings-manager).
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

pydantic_settings_manager-0.2.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+pydantic_settings_manager/__init__.py,sha256=eqe0IVD6o9FuoVR1xKqE0jyyhzd1u3yd77rnOe_9zQs,955
+pydantic_settings_manager/base.py,sha256=k141GoasYGd-AoEo2qN86xWjW6StOuE1QhDqmEDP9XI,1258
+pydantic_settings_manager/mapped.py,sha256=8O9tmh72_KgEWF5aIyXRsqiwsm2yUFfhxEmTkz9MfDM,7706
+pydantic_settings_manager/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydantic_settings_manager/single.py,sha256=cuGzkLafDaTS_598148qKFTwVgNZjdhihgV7wiKiuBI,2759
+pydantic_settings_manager/types.py,sha256=-LUZIr6g14nensFLgIs3CL4bxkcG7i7GlW3BmWHyub4,156
+pydantic_settings_manager/utils.py,sha256=_DaEPdQjHFka_xlcC5E6e1QT0OAIymt6BL8RYIM_8Dg,1316
+pydantic_settings_manager-0.2.2.dist-info/METADATA,sha256=A8vfiGLrV422FvqhwhLcHEgf7eVeudyhH8H_ZT_SVes,9410
+pydantic_settings_manager-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_settings_manager-0.2.2.dist-info/licenses/LICENSE,sha256=GtwfENGLMnpE6iSmuiVTC1AhFCLGvBYycR--RKNSs80,1060
+pydantic_settings_manager-0.2.2.dist-info/RECORD,,

{pydantic_settings_manager-0.1.2.dist-info → pydantic_settings_manager-0.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pydantic_settings_manager-0.1.2.dist-info/METADATA

@@ -1,119 +0,0 @@
-Metadata-Version: 2.1
-Name: pydantic-settings-manager
-Version: 0.1.2
-Summary: A library for managing Pydantic settings objects
-Home-page: https://github.com/kiarina/pydantic-settings-manager
-License: MIT
-Keywords: pydantic,settings,configuration
-Author: kiarina
-Author-email: kiarinadawa@gmail.com
-Requires-Python: >=3.8,<4.0
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: pydantic (>=2.0.0,<3.0.0)
-Requires-Dist: pydantic-settings (>=2.0.0,<3.0.0)
-Project-URL: Documentation, https://github.com/kiarina/pydantic-settings-manager
-Project-URL: Repository, https://github.com/kiarina/pydantic-settings-manager
-Description-Content-Type: text/markdown
-
-# pydantic-settings-manager
-
-A library for managing Pydantic settings objects.
-
-## Features
-
-- Two types of settings managers:
-  - `SingleSettingsManager`: For managing a single settings object
-  - `MappedSettingsManager`: For managing multiple settings objects mapped to keys
-- Support for loading settings from multiple sources
-- Command line argument overrides
-- Settings validation through Pydantic
-- Type hints and documentation
-
-## Installation
-
-```bash
-pip install pydantic-settings-manager
-```
-
-## Quick Start
-
-### Single Settings Manager
-
-```python
-from pydantic_settings import BaseSettings
-from pydantic_settings_manager import SingleSettingsManager
-
-class MySettings(BaseSettings):
-    name: str = "default"
-    value: int = 0
-
-# Create a settings manager
-manager = SingleSettingsManager(MySettings)
-
-# Update settings from a configuration file
-manager.user_config = {"name": "from_file", "value": 42}
-
-# Update settings from command line arguments
-manager.cli_args = {"value": 100}
-
-# Get the current settings (combines both sources)
-settings = manager.settings
-assert settings.name == "from_file"  # from user_config
-assert settings.value == 100  # from cli_args (overrides user_config)
-```
-
-### Mapped Settings Manager
-
-```python
-from pydantic_settings import BaseSettings
-from pydantic_settings_manager import MappedSettingsManager
-
-class MySettings(BaseSettings):
-    name: str = "default"
-    value: int = 0
-
-# Create a settings manager
-manager = MappedSettingsManager(MySettings)
-
-# Set up multiple configurations
-manager.user_config = {
-    "map": {
-        "dev": {"name": "development", "value": 42},
-        "prod": {"name": "production", "value": 100}
-    }
-}
-
-# Select which configuration to use
-manager.set_cli_args("dev")
-
-# Get the current settings
-settings = manager.settings
-assert settings.name == "development"
-assert settings.value == 42
-
-# Switch to a different configuration
-manager.set_cli_args("prod")
-settings = manager.settings
-assert settings.name == "production"
-assert settings.value == 100
-```
-
-## Documentation
-
-For more detailed documentation, please see the [GitHub repository](https://github.com/kiarina/pydantic-settings-manager).
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-

pydantic_settings_manager-0.1.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-pydantic_settings_manager/__init__.py,sha256=6EYixuoo-sI93B6zv4z-WcgQ8CpSboSGKOQgozbBcTo,955
-pydantic_settings_manager/base.py,sha256=dZqHHCamZkFirlDCBxJy4AKRqWtE17OmqdiHueQc5gQ,1270
-pydantic_settings_manager/mapped.py,sha256=mJJxqCUrFe6vPdZDnsfDNwwyC2dn3b4i2yR6G57JNZg,7715
-pydantic_settings_manager/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_settings_manager/single.py,sha256=MXCv8-jMdVwEQIjuauEShcZ2849OnjKb3KOyKyE3icw,2771
-pydantic_settings_manager/types.py,sha256=XvZoUmmNDjzAr5ns77uq1YhZPocT2BFkLMPZVZt1Lt8,133
-pydantic_settings_manager/utils.py,sha256=ciBAczruqEiaudUvk38pCzrjAUz8liIl9JO6QS8hUg0,1322
-pydantic_settings_manager-0.1.2.dist-info/LICENSE,sha256=GtwfENGLMnpE6iSmuiVTC1AhFCLGvBYycR--RKNSs80,1060
-pydantic_settings_manager-0.1.2.dist-info/METADATA,sha256=69fhvEEn6vIZfjjUiHlXSjpYzqNEFEbUFcK37m6eRkQ,3514
-pydantic_settings_manager-0.1.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pydantic_settings_manager-0.1.2.dist-info/RECORD,,