pydantic-settings-manager 0.1.0__tar.gz

pydantic_settings_manager-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydantic_settings_manager-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.1
+Name: pydantic-settings-manager
+Version: 0.1.0
+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: 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.0/README.md

@@ -0,0 +1,90 @@
+# 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.0/pydantic_settings_manager/__init__.py

@@ -0,0 +1,37 @@
+"""
+pydantic-settings-manager
+========================
+
+A library for managing Pydantic settings objects.
+
+This library provides two types of settings managers:
+
+1. SingleSettingsManager: For managing a single settings object
+2. MappedSettingsManager: For managing multiple settings objects mapped to keys
+
+Both managers support:
+- Loading settings from multiple sources
+- Command line argument overrides
+- Settings validation through Pydantic
+"""
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from .base import BaseSettingsManager
+from .mapped import MappedSettingsManager, SettingsMap
+from .single import SingleSettingsManager
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Re-exports from pydantic_settings
+    "BaseSettings",
+    "SettingsConfigDict",
+    # Base manager
+    "BaseSettingsManager",
+    # Single settings manager
+    "SingleSettingsManager",
+    # Mapped settings manager
+    "MappedSettingsManager",
+    "SettingsMap",
+]

pydantic_settings_manager-0.1.0/pydantic_settings_manager/base.py

@@ -0,0 +1,52 @@
+"""
+Base classes for settings managers.
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Generic, Type, TypeVar
+
+from pydantic_settings import BaseSettings
+
+T = TypeVar("T", bound=BaseSettings)
+
+
+class BaseSettingsManager(ABC, Generic[T]):
+    """
+    Base class for settings managers.
+
+    This abstract class defines the interface that all settings managers must implement.
+    It provides a generic way to manage Pydantic settings objects.
+
+    Type Parameters:
+        T: A type that inherits from BaseSettings
+    """
+
+    @abstractmethod
+    def __init__(self, settings_cls: Type[T]):
+        """
+        Initialize the settings manager.
+
+        Args:
+            settings_cls: The settings class to manage
+        """
+        self.settings_cls = settings_cls
+        """The settings class being managed"""
+
+        self.user_config: dict[str, Any] = {}
+        """User configuration dictionary"""
+
+    @property
+    @abstractmethod
+    def settings(self) -> T:
+        """
+        Get the current settings.
+
+        Returns:
+            The current settings object
+        """
+
+    @abstractmethod
+    def clear(self):
+        """
+        Clear the current settings.
+        This typically involves clearing any cached settings.
+        """

pydantic_settings_manager-0.1.0/pydantic_settings_manager/mapped.py

@@ -0,0 +1,282 @@
+"""
+Mapped settings manager implementation.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Generic, Type
+
+from pydantic import BaseModel, Field
+from pydantic.main import create_model
+
+from .base import BaseSettingsManager, T
+from .utils import diff_dict, update_dict
+
+
+class SettingsMap(BaseModel, Generic[T]):
+    """
+    A model that maps keys to settings objects.
+
+    This model is used by MappedSettingsManager to store multiple settings objects
+    and track which one is currently active.
+
+    Type Parameters:
+        T: A type that inherits from BaseSettings
+
+    Attributes:
+        key: The key of the currently active settings
+        map: A dictionary mapping keys to settings objects
+    """
+
+    key: str = ""
+    """The key of the currently active settings"""
+
+    map: Dict[str, T] = Field(default_factory=dict)
+    """A dictionary mapping keys to settings objects"""
+
+
+class MappedSettingsManager(BaseSettingsManager[T]):
+    """
+    A settings manager that manages multiple settings objects mapped to keys.
+
+    This manager is useful when you need to switch between different configurations
+    at runtime. Each configuration is identified by a unique key.
+
+    Type Parameters:
+        T: A type that inherits from BaseSettings
+
+    Example:
+        ```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
+        ```
+    """
+
+    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
+        """The settings class being managed"""
+
+        self.cli_args: SettingsMap[T] = SettingsMap[T]()
+        """Command line arguments"""
+
+        self.user_config: Dict[str, Any] = {}
+        """User configuration"""
+
+        self.system_settings: T = settings_cls()
+        """System settings"""
+
+        self._map_settings: SettingsMap[T] | None = None
+        """Cached settings map"""
+
+    @property
+    def settings_cls_name(self) -> str:
+        """
+        Get the name of the settings class.
+
+        Returns:
+            The name of the settings class
+        """
+        return self.settings_cls.__name__
+
+    def set_cli_args(self, key: str, value: T | None = None):
+        """
+        Set the command line arguments.
+
+        Args:
+            key: The key to make active
+            value: Optional settings to associate with the key
+        """
+        self.cli_args.key = key
+
+        if value:
+            self.cli_args.map[key] = value
+
+        self.clear()
+
+    @property
+    def _cli_args_config(self) -> Dict[str, Any]:
+        """
+        Get the command line arguments as a dictionary.
+
+        Returns:
+            The command line arguments
+        """
+        vanilla = SettingsMap[T]()
+
+        for k, _ in self.cli_args.map.items():
+            vanilla.map[k] = self.settings_cls()
+
+        base = vanilla.model_dump()
+        target = self.cli_args.model_dump()
+
+        return diff_dict(base, target)
+
+    @property
+    def _system_settings_config(self) -> Dict[str, Any]:
+        """
+        Get the system settings as a dictionary.
+
+        Returns:
+            The system settings
+        """
+        base = self.settings_cls().model_dump()
+        target = self.system_settings.model_dump()
+        return diff_dict(base, target)
+
+    @property
+    def map_settings(self) -> SettingsMap[T]:
+        """
+        Get the settings map.
+
+        Returns:
+            The settings map
+        """
+        if not self._map_settings:
+            self._map_settings = self._get_map_settings()
+
+        return self._map_settings
+
+    def _get_map_settings(self) -> SettingsMap[T]:
+        """
+        Create a new settings map.
+
+        Returns:
+            A new settings map
+        """
+        DynamicMapSettings = create_model(
+            "DynamicMapSettings",
+            key=(str, ""),
+            map=(Dict[str, self.settings_cls], {}),  # type: ignore[name-defined]
+            __base__=SettingsMap[T],
+        )
+
+        # Merge user configuration and command line arguments
+        config = update_dict(self.user_config, self._cli_args_config)
+
+        # Merge system settings into each configuration
+        if "map" in config:
+            for key, value in config["map"].items():
+                config["map"][key] = update_dict(value, self._system_settings_config)
+
+        return DynamicMapSettings(**config)
+
+    def clear(self):
+        """
+        Clear the cached settings map.
+        """
+        self._map_settings = None
+
+    @property
+    def settings(self) -> T:
+        """
+        Get the current settings.
+
+        Returns:
+            The current settings object
+
+        Raises:
+            ValueError: If the active key does not exist in the settings map
+        """
+        if not self.map_settings.key:
+            if not self.map_settings.map:
+                settings = self.settings_cls(**self.system_settings.model_dump())
+            else:
+                key = list(self.map_settings.map.keys())[0]
+                settings = self.map_settings.map[key]
+        else:
+            if self.map_settings.key not in self.map_settings.map:
+                raise ValueError(
+                    f"Key does not exist in settings map: "
+                    f"{self.settings_cls_name}, {self.map_settings.key}"
+                )
+            else:
+                settings = self.map_settings.map[self.map_settings.key]
+
+        return settings
+
+    def has_key(self, key: str) -> bool:
+        """
+        Check if a key exists in the settings map.
+
+        Args:
+            key: The key to check
+
+        Returns:
+            True if the key exists, False otherwise
+        """
+        return key in self.map_settings.map
+
+    def get_settings_by_key(self, key: str = "") -> T:
+        """
+        Get settings by key.
+
+        Args:
+            key: The key to get settings for. If empty, returns the active settings.
+
+        Returns:
+            The settings object for the specified key
+
+        Raises:
+            ValueError: If the specified key does not exist in the settings map
+        """
+        if not key:
+            return self.settings
+
+        if not self.has_key(key):
+            raise ValueError(f"Key does not exist in settings map: {key}")
+
+        return self.map_settings.map[key]
+
+    @property
+    def active_key(self) -> str:
+        """
+        Get the active key.
+
+        Returns:
+            The active key
+        """
+        return self.map_settings.key
+
+    @property
+    def all_settings(self) -> Dict[str, T]:
+        """
+        Get all settings.
+
+        Returns:
+            A dictionary mapping keys to settings objects
+        """
+        return self.map_settings.map

pydantic_settings_manager-0.1.0/pydantic_settings_manager/single.py

@@ -0,0 +1,96 @@
+"""
+Single settings manager implementation.
+"""
+from typing import Any, Dict, Type
+
+from .base import BaseSettingsManager, T
+from .utils import NestedDict, nested_dict, update_dict
+
+
+class SingleSettingsManager(BaseSettingsManager[T]):
+    """
+    A settings manager that manages a single settings object.
+
+    This manager is useful when you need to manage a single configuration that can be
+    updated from multiple sources (e.g., command line arguments, configuration files).
+
+    Type Parameters:
+        T: A type that inherits from BaseSettings
+
+    Example:
+        ```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)
+        ```
+    """
+
+    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
+        """The settings class being managed"""
+
+        self.cli_args: NestedDict = nested_dict()
+        """Command line arguments"""
+
+        self.user_config: Dict[str, Any] = {}
+        """User configuration"""
+
+        self._settings: T | None = None
+        """Cached settings"""
+
+    @property
+    def settings(self) -> T:
+        """
+        Get the current settings.
+
+        The settings are created by combining the user configuration and command line
+        arguments, with command line arguments taking precedence.
+
+        Returns:
+            The current settings object
+        """
+        if not self._settings:
+            self._settings = self._get_settings()
+
+        return self._settings
+
+    def _get_settings(self) -> T:
+        """
+        Create a new settings object.
+
+        Returns:
+            A new settings object
+        """
+        config = update_dict(self.user_config, self.cli_args)
+        return self.settings_cls(**config)
+
+    def clear(self):
+        """
+        Clear the cached settings.
+
+        This forces the next access to settings to create a new settings object.
+        """
+        self._settings = None

pydantic_settings_manager-0.1.0/pydantic_settings_manager/types.py

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

pydantic_settings_manager-0.1.0/pydantic_settings_manager/utils.py

@@ -0,0 +1,50 @@
+"""
+Utility functions for dictionary operations.
+"""
+from collections import defaultdict
+from typing import Any, Dict
+
+from .types import NestedDict
+
+
+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.
+    """
+    result = {}
+
+    for key in target:
+        if key not in base:
+            result[key] = target[key]
+        elif isinstance(target[key], dict) and isinstance(base[key], dict):
+            nested = diff_dict(base[key], target[key])
+            if nested:
+                result[key] = nested
+        elif target[key] != base[key]:
+            result[key] = target[key]
+
+    return result
+
+
+def update_dict(base: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Update a dictionary with another dictionary.
+    Performs a deep update.
+    """
+    result = base.copy()
+
+    for key, value in update.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = update_dict(result[key], value)
+        else:
+            result[key] = value
+
+    return result
+
+
+def nested_dict() -> NestedDict:
+    """
+    ネストした dict を作成する
+    """
+    return defaultdict(nested_dict)

pydantic_settings_manager-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+[tool.poetry]
+name = "pydantic-settings-manager"
+version = "0.1.0"
+description = "A library for managing Pydantic settings objects"
+authors = ["kiarina <kiarinadawa@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/kiarina/pydantic-settings-manager"
+repository = "https://github.com/kiarina/pydantic-settings-manager"
+documentation = "https://github.com/kiarina/pydantic-settings-manager"
+keywords = ["pydantic", "settings", "configuration"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+packages = [
+    { include = "pydantic_settings_manager" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+pydantic = "^2.0.0"
+pydantic-settings = "^2.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0"
+black = "^23.7.0"
+isort = "^5.12.0"
+mypy = "^1.5.0"
+ruff = "^0.0.284"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 100
+target-version = ["py38"]
+
+[tool.isort]
+profile = "black"
+line_length = 100
+multi_line_output = 3
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+
+[tool.ruff]
+line-length = 100
+target-version = "py38"
+select = ["E", "F", "B", "I"]