abcdi-config 0.0.1__tar.gz

abcdi_config-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julian Kenwood
+
+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.

abcdi_config-0.0.1/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: abcdi-config
+Version: 0.0.1
+Summary: A Python library for configuration-based dependency injection using the abcdi library
+Author-email: Julian Kenwood <julian.kenwood@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nomad010/abcdi-config
+Project-URL: Repository, https://github.com/nomad010/abcdi-config
+Project-URL: Issues, https://github.com/nomad010/abcdi-config/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: abcdi==0.7.0
+Requires-Dist: annotated-types==0.8.0
+Requires-Dist: pydantic==2.13.5
+Requires-Dist: pydantic-core==2.46.5
+Requires-Dist: pydantic-settings==2.15.0
+Requires-Dist: python-dotenv==1.2.4
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: typing-extensions==4.16.0
+Requires-Dist: typing-inspection==0.4.4
+Provides-Extra: dev
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pylint>=2.15.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# abcdi-config
+
+A Python library for configuration-based dependency injection using the abcdi library.
+Define your application dependencies in YAML configuration files and automatically
+instantiate them with proper dependency injection.
+
+## Features
+
+- Configuration-driven dependency injection
+- YAML-based configuration files
+- Factory pattern for creating instances
+- Support for environment variable overrides
+- Type safety with Pydantic validation
+- Lazy dependency loading support
+
+## Installation
+
+```bash
+pip install abcdi-config
+```
+
+## Quick Start
+
+```python
+from pathlib import Path
+from abcdi_config import load_configuration, configuration
+from abcdi_config.schema import Config
+
+# Load configuration from YAML file
+load_configuration(Path("config.yaml"), Config)
+
+# Access the loaded configuration
+config = configuration()
+
+# Get dependencies using abcdi
+import abcdi
+db = abcdi.get_dependency('database')
+```
+
+## Configuration Format
+
+```yaml
+dependencies:
+  database:
+    class_: sqlalchemy.create_engine
+    kwargs:
+      url: postgresql://user:pass@localhost/db
+      echo: true
+  
+  api_client:
+    class_: requests.Session
+    kwargs:
+      timeout: 30
+```
+
+## Development
+
+This project uses `uv` for dependency management and virtual environments.
+
+### Setup
+
+```bash
+# Install dependencies
+uv sync
+
+# Or install dependencies into your existing virtualenv
+uv pip sync requirements.txt dev-requirements.txt
+```
+
+### Linting
+
+#### Pylint
+
+Pylint is configured with a focus on reducing false positives for test files while catching real issues in production code.
+
+```bash
+uv run pylint src/ tests/
+```
+
+#### MyPy
+
+MyPy type checking is configured to skip third-party library stubs.
+
+```bash
+uv run mypy src/ tests/
+```
+
+### Running Tests
+
+```bash
+uv run pytest tests/
+```

abcdi_config-0.0.1/README.md

@@ -0,0 +1,92 @@
+# abcdi-config
+
+A Python library for configuration-based dependency injection using the abcdi library.
+Define your application dependencies in YAML configuration files and automatically
+instantiate them with proper dependency injection.
+
+## Features
+
+- Configuration-driven dependency injection
+- YAML-based configuration files
+- Factory pattern for creating instances
+- Support for environment variable overrides
+- Type safety with Pydantic validation
+- Lazy dependency loading support
+
+## Installation
+
+```bash
+pip install abcdi-config
+```
+
+## Quick Start
+
+```python
+from pathlib import Path
+from abcdi_config import load_configuration, configuration
+from abcdi_config.schema import Config
+
+# Load configuration from YAML file
+load_configuration(Path("config.yaml"), Config)
+
+# Access the loaded configuration
+config = configuration()
+
+# Get dependencies using abcdi
+import abcdi
+db = abcdi.get_dependency('database')
+```
+
+## Configuration Format
+
+```yaml
+dependencies:
+  database:
+    class_: sqlalchemy.create_engine
+    kwargs:
+      url: postgresql://user:pass@localhost/db
+      echo: true
+  
+  api_client:
+    class_: requests.Session
+    kwargs:
+      timeout: 30
+```
+
+## Development
+
+This project uses `uv` for dependency management and virtual environments.
+
+### Setup
+
+```bash
+# Install dependencies
+uv sync
+
+# Or install dependencies into your existing virtualenv
+uv pip sync requirements.txt dev-requirements.txt
+```
+
+### Linting
+
+#### Pylint
+
+Pylint is configured with a focus on reducing false positives for test files while catching real issues in production code.
+
+```bash
+uv run pylint src/ tests/
+```
+
+#### MyPy
+
+MyPy type checking is configured to skip third-party library stubs.
+
+```bash
+uv run mypy src/ tests/
+```
+
+### Running Tests
+
+```bash
+uv run pytest tests/
+```

abcdi_config-0.0.1/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "abcdi-config"
+description = "A Python library for configuration-based dependency injection using the abcdi library"
+readme = "README.md"
+requires-python = ">=3.13"
+license = { text = "MIT" }
+authors = [{ name = "Julian Kenwood", email = "julian.kenwood@example.com" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dynamic = ["version", "dependencies"]
+
+[project.urls]
+Homepage = "https://github.com/nomad010/abcdi-config"
+Repository = "https://github.com/nomad010/abcdi-config"
+Issues = "https://github.com/nomad010/abcdi-config/issues"
+
+[tool.setuptools.dynamic]
+version = { file = "version" }
+dependencies = { file = ["requirements.txt"] }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[dependency-groups]
+dev = [
+    "build>=1.6.1",
+    "twine>=7.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "build>=0.10.0",
+    "twine>=4.0.0",
+    "pytest>=7.0.0",
+    "pylint>=2.15.0",
+    "mypy>=1.0.0",
+]
+
+[project.scripts]

abcdi_config-0.0.1/requirements.txt

@@ -0,0 +1,25 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile requirements.in -o requirements.txt
+abcdi==0.7.0
+    # via -r requirements.in
+annotated-types==0.8.0
+    # via pydantic
+pydantic==2.13.5
+    # via pydantic-settings
+pydantic-core==2.46.5
+    # via pydantic
+pydantic-settings==2.15.0
+    # via -r requirements.in
+python-dotenv==1.2.4
+    # via pydantic-settings
+pyyaml==6.0.3
+    # via -r requirements.in
+typing-extensions==4.16.0
+    # via
+    #   pydantic
+    #   pydantic-core
+    #   typing-inspection
+typing-inspection==0.4.4
+    # via
+    #   pydantic
+    #   pydantic-settings

abcdi_config-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

abcdi_config-0.0.1/src/abcdi_config/__init__.py

@@ -0,0 +1,107 @@
+import os
+from pathlib import Path
+from typing import TypeVar
+
+import abcdi
+import yaml
+
+from abcdi_config.exceptions import (
+    ConfigAlreadyLoadedError,
+    ConfigError,
+    DependencyFactoryError,
+)
+from abcdi_config.schema import Config
+
+__all__ = [
+    "ConfigAlreadyLoadedError",
+    "ConfigError",
+    "DependencyFactoryError",
+    "configuration",
+    "load_configuration",
+]
+
+# TypeVar bound to Config for type-safe configuration classes
+ConfigT = TypeVar("ConfigT", bound=Config)
+
+
+CONFIGURATION = None
+
+
+def _resolve_class(cls_or_path: str) -> type[Config]:
+    """Resolve a class from either a class object or import path string."""
+    try:
+        from importlib import import_module
+        module_path, class_name = cls_or_path.rsplit('.', 1)
+        module = import_module(module_path)
+        cls = getattr(module, class_name)
+        if not issubclass(cls, Config):
+            raise ConfigError(f"Config class {cls_or_path} is not a subclass of abcdi_config.Config")
+        return cls
+    except (ValueError, ImportError, AttributeError) as e:
+        raise ConfigError(f"Failed to resolve class {cls_or_path}: {e}") from e
+
+
+def load_configuration(
+    path: Path, configuration_cls: type, lazy_di: bool = False
+) -> None:
+    """Load configuration from YAML and set up abcdi dependency injection context.
+
+    Args:
+        path: Path to the YAML configuration file.
+        lazy_di: If True, dependencies are created lazily. Defaults to False.
+        configuration_cls: Custom configuration class (subclass of Config).
+
+    Example:
+        load_configuration(Path("config.yaml"), Config)
+        load_configuration(Path("config.yaml"), CustomConfig)
+    """
+    global CONFIGURATION  # pylint: disable=global-statement
+    if CONFIGURATION is not None:
+        raise ConfigAlreadyLoadedError()
+
+    # Determine configuration class to use
+    # Priority: CONFIGURATION_CLS env var > configuration_cls param
+    configuration_class_override = os.environ.get("CONFIGURATION_CLS")
+    if configuration_class_override is not None:
+        config_cls = _resolve_class(configuration_class_override)
+    else:
+        config_cls = configuration_cls
+
+    # Determine lazy flag - env var takes priority over function parameter
+    configuration_lazy_override = os.environ.get("CONFIGURATION_LAZY")
+    if configuration_lazy_override is not None:
+        use_lazy_di = configuration_lazy_override.lower() == "true"
+    else:
+        use_lazy_di = lazy_di
+
+    # Use context manager for proper file handling
+    with open(path, encoding='utf-8') as f:
+        yaml_data = yaml.safe_load(f)
+    # Handle empty YAML or YAML with None
+    if yaml_data is None:
+        yaml_data = {}
+
+    # Handle null dependencies
+    if yaml_data.get("dependencies") is None:
+        yaml_data["dependencies"] = {}
+
+    CONFIGURATION = config_cls.model_validate(yaml_data)
+
+    # Convert to abcdi factory format
+    # Pydantic's ImportString automatically resolves the class on model instantiation
+    # Factory[X] has class_ and kwargs, abcdi.factory expects cls, *args, **kwargs
+    dependency_config = {}
+    for name, dependency in CONFIGURATION.dependencies.items():
+        try:
+            dependency_config[name] = abcdi.factory(dependency.class_, **dependency.kwargs)
+        except (ImportError, AttributeError) as e:
+            raise DependencyFactoryError(name, e) from e
+
+    abcdi.set_context(dependencies=dependency_config, lazy=use_lazy_di)
+
+
+def configuration() -> Config:
+    """Return the loaded configuration."""
+    if CONFIGURATION is None:
+        raise ConfigError("Configuration has not been loaded. Call load_configuration() first.")
+    return CONFIGURATION

abcdi_config-0.0.1/src/abcdi_config/exceptions.py

@@ -0,0 +1,32 @@
+"""Custom exceptions for abcdi-config."""
+
+
+class ConfigError(Exception):
+    """Base exception for configuration errors."""
+
+
+class ConfigLoadError(ConfigError):
+    """Raised when configuration fails to load."""
+
+    def __init__(self, message: str, original_error: Exception | None = None):
+        if original_error:
+            super().__init__(f"{message}: {original_error}")
+            self.__cause__ = original_error
+        else:
+            super().__init__(message)
+
+
+class ConfigAlreadyLoadedError(ConfigError):
+    """Raised when trying to load configuration when already loaded."""
+
+    def __init__(self) -> None:
+        super().__init__("Configuration is already loaded. Call configuration() to access it.")
+
+
+class DependencyFactoryError(ConfigError):
+    """Raised when a dependency factory cannot be created."""
+
+    def __init__(self, name: str, original_error: Exception) -> None:
+        super().__init__(f"Failed to create factory for dependency '{name}': {original_error}")
+        self.dependency_name = name
+        self.__cause__ = original_error

abcdi_config-0.0.1/src/abcdi_config/py.typed

@@ -0,0 +1 @@
+# Marker file to indicate this package supports type checking

abcdi_config-0.0.1/src/abcdi_config/schema/__init__.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from pydantic import BaseModel, ImportString
+from pydantic_settings import BaseSettings
+
+
+class Factory[X](BaseModel):
+    """Factory pattern for dynamically creating instances of classes with configuration."""
+    class_: ImportString[type[X]]  # Class to instantiate (import path as string)
+    kwargs: dict[str, Any] = {}  # Keyword arguments to pass to class constructor
+
+
+class Config(BaseSettings):
+    dependencies: dict[str, Factory[Any]] = {}  # Named dependencies to create upfront and make available throughout the application

abcdi_config-0.0.1/src/abcdi_config.egg-info/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: abcdi-config
+Version: 0.0.1
+Summary: A Python library for configuration-based dependency injection using the abcdi library
+Author-email: Julian Kenwood <julian.kenwood@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nomad010/abcdi-config
+Project-URL: Repository, https://github.com/nomad010/abcdi-config
+Project-URL: Issues, https://github.com/nomad010/abcdi-config/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: abcdi==0.7.0
+Requires-Dist: annotated-types==0.8.0
+Requires-Dist: pydantic==2.13.5
+Requires-Dist: pydantic-core==2.46.5
+Requires-Dist: pydantic-settings==2.15.0
+Requires-Dist: python-dotenv==1.2.4
+Requires-Dist: pyyaml==6.0.3
+Requires-Dist: typing-extensions==4.16.0
+Requires-Dist: typing-inspection==0.4.4
+Provides-Extra: dev
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pylint>=2.15.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# abcdi-config
+
+A Python library for configuration-based dependency injection using the abcdi library.
+Define your application dependencies in YAML configuration files and automatically
+instantiate them with proper dependency injection.
+
+## Features
+
+- Configuration-driven dependency injection
+- YAML-based configuration files
+- Factory pattern for creating instances
+- Support for environment variable overrides
+- Type safety with Pydantic validation
+- Lazy dependency loading support
+
+## Installation
+
+```bash
+pip install abcdi-config
+```
+
+## Quick Start
+
+```python
+from pathlib import Path
+from abcdi_config import load_configuration, configuration
+from abcdi_config.schema import Config
+
+# Load configuration from YAML file
+load_configuration(Path("config.yaml"), Config)
+
+# Access the loaded configuration
+config = configuration()
+
+# Get dependencies using abcdi
+import abcdi
+db = abcdi.get_dependency('database')
+```
+
+## Configuration Format
+
+```yaml
+dependencies:
+  database:
+    class_: sqlalchemy.create_engine
+    kwargs:
+      url: postgresql://user:pass@localhost/db
+      echo: true
+  
+  api_client:
+    class_: requests.Session
+    kwargs:
+      timeout: 30
+```
+
+## Development
+
+This project uses `uv` for dependency management and virtual environments.
+
+### Setup
+
+```bash
+# Install dependencies
+uv sync
+
+# Or install dependencies into your existing virtualenv
+uv pip sync requirements.txt dev-requirements.txt
+```
+
+### Linting
+
+#### Pylint
+
+Pylint is configured with a focus on reducing false positives for test files while catching real issues in production code.
+
+```bash
+uv run pylint src/ tests/
+```
+
+#### MyPy
+
+MyPy type checking is configured to skip third-party library stubs.
+
+```bash
+uv run mypy src/ tests/
+```
+
+### Running Tests
+
+```bash
+uv run pytest tests/
+```

abcdi_config-0.0.1/src/abcdi_config.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+requirements.txt
+version
+src/abcdi_config/__init__.py
+src/abcdi_config/exceptions.py
+src/abcdi_config/py.typed
+src/abcdi_config.egg-info/PKG-INFO
+src/abcdi_config.egg-info/SOURCES.txt
+src/abcdi_config.egg-info/dependency_links.txt
+src/abcdi_config.egg-info/requires.txt
+src/abcdi_config.egg-info/top_level.txt
+src/abcdi_config/schema/__init__.py
+tests/test_edge_cases.py
+tests/test_factory_usage.py
+tests/test_integration.py
+tests/test_main.py
+tests/test_schema.py

abcdi_config-0.0.1/src/abcdi_config.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abcdi_config-0.0.1/src/abcdi_config.egg-info/requires.txt

@@ -0,0 +1,16 @@
+abcdi==0.7.0
+annotated-types==0.8.0
+pydantic==2.13.5
+pydantic-core==2.46.5
+pydantic-settings==2.15.0
+python-dotenv==1.2.4
+pyyaml==6.0.3
+typing-extensions==4.16.0
+typing-inspection==0.4.4
+
+[dev]
+build>=0.10.0
+twine>=4.0.0
+pytest>=7.0.0
+pylint>=2.15.0
+mypy>=1.0.0

abcdi_config-0.0.1/src/abcdi_config.egg-info/top_level.txt

@@ -0,0 +1 @@
+abcdi_config

abcdi_config-0.0.1/tests/test_edge_cases.py

@@ -0,0 +1,50 @@
+"""Edge case and validation tests for abcdi-config."""
+import tempfile
+from pathlib import Path
+
+import pytest
+from pydantic import ValidationError
+
+from abcdi_config import load_configuration
+from abcdi_config.schema import Config
+
+
+class TestValidation:
+    """Tests for configuration validation."""
+
+    def test_missing_class_field_raises_error(self):
+        """Test that missing 'class' field raises ValidationError."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            config_yaml = """
+dependencies:
+  my_factory:
+    kwargs:
+      value: test
+"""
+            f.write(config_yaml)
+            config_path = Path(f.name)
+
+        try:
+            with pytest.raises(ValidationError):
+                load_configuration(config_path, Config)
+        finally:
+            config_path.unlink()
+
+    def test_nonexistent_class_raises_error(self):
+        """Test that nonexistent class path raises error."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            config_yaml = """
+dependencies:
+  my_factory:
+    class_: nonexistent.module.ThatClass
+    kwargs:
+      value: test
+"""
+            f.write(config_yaml)
+            config_path = Path(f.name)
+
+        try:
+            with pytest.raises(ValidationError):
+                load_configuration(config_path, Config)
+        finally:
+            config_path.unlink()

abcdi_config-0.0.1/tests/test_factory_usage.py

@@ -0,0 +1,200 @@
+"""Integration tests demonstrating Factory pattern usage."""
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from abcdi_config import load_configuration
+from abcdi_config.schema import Config
+
+
+class CustomService:
+    """A custom service class for testing."""
+
+    def __init__(self, host: str, port: int, debug: bool = False):
+        self.host = host
+        self.port = port
+        self.debug = debug
+
+    def get_url(self) -> str:
+        protocol = "http" if not self.debug else "https"
+        return f"{protocol}://{self.host}:{self.port}"
+
+
+class TestFactoryPattern:
+    """Tests for Factory pattern usage in configurations."""
+
+    def test_factory_creates_instance(self):
+        """Test that Factory correctly creates an instance."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            config_yaml = """
+dependencies:
+  custom_service:
+    class_: tests.test_factory_usage.CustomService
+    kwargs:
+      host: localhost
+      port: 8080
+      debug: true
+"""
+            f.write(config_yaml)
+            config_path = Path(f.name)
+
+        try:
+            import abcdi
+            load_configuration(config_path, Config)
+
+            service = abcdi.get_dependency('custom_service')
+            assert isinstance(service, CustomService)
+            assert service.host == "localhost"
+            assert service.port == 8080
+            assert service.debug is True
+            assert service.get_url() == "https://localhost:8080"
+
+        finally:
+            # Clean up
+            import abcdi
+
+            import abcdi_config
+            abcdi_config.CONFIGURATION = None
+            abcdi._current_context = None
+            config_path.unlink()
+
+    def test_factory_with_multiple_instances(self):
+        """Test creating multiple factory instances."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            config_yaml = """
+dependencies:
+  service_a:
+    class_: tests.test_factory_usage.CustomService
+    kwargs:
+      host: host-a
+      port: 8080
+  service_b:
+    class_: tests.test_factory_usage.CustomService
+    kwargs:
+      host: host-b
+      port: 9090
+"""
+            f.write(config_yaml)
+            config_path = Path(f.name)
+
+        try:
+            import abcdi
+            load_configuration(config_path, Config)
+
+            service_a = abcdi.get_dependency('service_a')
+            service_b = abcdi.get_dependency('service_b')
+
+            assert service_a.host == "host-a"
+            assert service_b.host == "host-b"
+            assert service_a.port == 8080
+            assert service_b.port == 9090
+
+        finally:
+            # Clean up
+            import abcdi
+
+            import abcdi_config
+            abcdi_config.CONFIGURATION = None
+            abcdi._current_context = None
+            config_path.unlink()
+
+    def test_factory_with_nested_kwargs(self):
+        """Test Factory with nested configuration objects."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            config_yaml = """
+dependencies:
+  database:
+    class_: tests.test_factory_usage.CustomService
+    kwargs:
+      host: db.example.com
+      port: 5432
+      debug: false
+"""
+            f.write(config_yaml)
+            config_path = Path(f.name)
+
+        try:
+            import abcdi
+            load_configuration(config_path, Config)
+
+            db = abcdi.get_dependency('database')
+            assert db.host == "db.example.com"
+            assert db.port == 5432
+            assert db.debug is False
+            assert db.get_url() == "http://db.example.com:5432"
+
+        finally:
+            # Clean up
+            import abcdi
+
+            import abcdi_config
+            abcdi_config.CONFIGURATION = None
+            abcdi._current_context = None
+            config_path.unlink()
+
+
+class TestDependencyResolution:
+    """Tests for dependency resolution behavior."""
+
+    def test_dependency_not_found_raises_error(self):
+        """Test that get_dependency raises when dependency doesn't exist."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            f.write("dependencies: {}")
+            config_path = Path(f.name)
+
+        try:
+            import abcdi
+            load_configuration(config_path, Config)
+
+            with pytest.raises(KeyError):  # abcdi raises KeyError for unknown dependency
+                abcdi.get_dependency('nonexistent')
+
+        finally:
+            # Clean up
+            import abcdi
+
+            import abcdi_config
+            abcdi_config.CONFIGURATION = None
+            abcdi._current_context = None
+            config_path.unlink()
+
+    def test_multiple_dependencies_independent(self):
+        """Test that multiple dependencies are independent instances."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            config_yaml = """
+dependencies:
+  counter:
+    class_: tests.test_factory_usage.CustomService
+    kwargs:
+      host: localhost
+      port: 1000
+  counter2:
+    class_: tests.test_factory_usage.CustomService
+    kwargs:
+      host: localhost
+      port: 2000
+"""
+            f.write(config_yaml)
+            config_path = Path(f.name)
+
+        try:
+            import abcdi
+            load_configuration(config_path, Config)
+
+            counter1 = abcdi.get_dependency('counter')
+            counter2 = abcdi.get_dependency('counter2')
+
+            # Verify they are different instances
+            assert counter1 is not counter2
+            assert counter1.port == 1000
+            assert counter2.port == 2000
+
+        finally:
+            # Clean up
+            import abcdi
+
+            import abcdi_config
+            abcdi_config.CONFIGURATION = None
+            abcdi._current_context = None
+            config_path.unlink()

abcdi_config-0.0.1/tests/test_integration.py

@@ -0,0 +1,86 @@
+"""Integration tests for abcdi-config."""
+import tempfile
+from pathlib import Path
+
+from abcdi_config import configuration, load_configuration
+from abcdi_config.schema import Config
+
+
+class CustomGreeting(Config):
+    """A custom greeting config for testing."""
+
+    name: str = "World"
+
+
+def test_load_configuration_with_datetime():
+    """Test loading configuration with a stdlib class (datetime.datetime)."""
+    import abcdi
+    # Create a temporary YAML configuration file
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+        config_yaml = """
+dependencies:
+  my_datetime:
+    class_: datetime.datetime
+    kwargs:
+      year: 2024
+      month: 1
+      day: 15
+"""
+        f.write(config_yaml)
+        config_path = Path(f.name)
+
+    try:
+        # Load the configuration
+        load_configuration(config_path, Config)
+
+        # Get the loaded configuration
+        loaded_config = configuration()
+        assert 'my_datetime' in loaded_config.dependencies
+
+        # Get the dependency from abcdi context
+        dt = abcdi.get_dependency('my_datetime')
+        assert dt.year == 2024
+        assert dt.month == 1
+        assert dt.day == 15
+
+    finally:
+        # Clean up
+        import abcdi
+
+        import abcdi_config
+        abcdi_config.CONFIGURATION = None
+        abcdi._current_context = None
+        config_path.unlink()
+
+
+def test_load_configuration_with_custom_class():
+    """Test loading configuration with a custom class from the project."""
+    import abcdi
+    # Create a temporary YAML configuration file
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+        config_yaml = """
+dependencies:
+  greeting:
+    class_: tests.test_integration.CustomGreeting
+    kwargs:
+      name: World
+"""
+        f.write(config_yaml)
+        config_path = Path(f.name)
+
+    try:
+        # Load the configuration
+        load_configuration(config_path, Config)
+
+        # Get the dependency from abcdi context
+        greeting = abcdi.get_dependency('greeting')
+        assert greeting.name == "World"
+
+    finally:
+        # Clean up
+        import abcdi
+
+        import abcdi_config
+        abcdi_config.CONFIGURATION = None
+        abcdi._current_context = None
+        config_path.unlink()

abcdi_config-0.0.1/tests/test_main.py

@@ -0,0 +1,33 @@
+"""Test that demonstrates the basic functionality of abcdi-config."""
+
+import tempfile
+from pathlib import Path
+
+from abcdi_config import configuration, load_configuration
+from abcdi_config.schema import Config
+
+
+def test_basic_import():
+    """Test that the package can be imported."""
+    assert True
+
+
+def test_empty_config():
+    """Test loading an empty configuration."""
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+        f.write("dependencies: {}")
+        config_path = Path(f.name)
+
+    try:
+        load_configuration(config_path, Config)
+        cfg = configuration()
+        assert cfg.dependencies == {}
+    finally:
+        config_path.unlink()
+
+
+if __name__ == "__main__":
+    # Run tests directly
+    test_basic_import()
+    test_empty_config()
+    print("All tests passed!")

abcdi_config-0.0.1/tests/test_schema.py

@@ -0,0 +1,72 @@
+"""Unit tests for the schema module."""
+import pytest
+from pydantic import ValidationError
+
+from abcdi_config.schema import Config, Factory
+
+
+class TestFactory:
+    """Tests for the Factory class."""
+
+    def test_factory_with_no_kwargs(self):
+        """Test Factory with minimal kwargs (empty dict)."""
+        factory = Factory(class_="datetime.datetime", kwargs={})
+        assert factory.class_.__name__ == "datetime"
+        assert factory.kwargs == {}
+
+    def test_factory_with_kwargs(self):
+        """Test Factory with keyword arguments."""
+        factory = Factory(
+            class_="datetime.datetime",
+            kwargs={"year": 2024, "month": 1, "day": 15}
+        )
+        assert factory.class_.__name__ == "datetime"
+        assert factory.kwargs == {"year": 2024, "month": 1, "day": 15}
+
+    def test_factory_invalid_class(self):
+        """Test Factory with invalid class path."""
+        with pytest.raises(ValidationError) as exc_info:
+            Factory(class_="nonexistent.module.Class", kwargs={})
+        # The error message should indicate an invalid import path
+        assert "nonexistent.module.Class" in str(exc_info.value)
+
+    def test_factory_with_custom_class(self):
+        """Test Factory with a custom class."""
+        from pathlib import Path
+
+        # Use Path from pathlib as the test class - it's a known importable class
+        factory = Factory(class_="pathlib.Path", kwargs={})
+        assert factory.class_ is Path
+        assert factory.kwargs == {}
+
+
+class TestConfig:
+    """Tests for the Config class."""
+
+    def test_config_with_no_dependencies(self):
+        """Test Config with empty dependencies."""
+        config = Config(dependencies={})
+        assert config.dependencies == {}
+
+    def test_config_with_single_dependency(self):
+        """Test Config with a single dependency."""
+        config = Config(dependencies={
+            "my_factory": Factory(class_="datetime.datetime", kwargs={})
+        })
+        assert len(config.dependencies) == 1
+        assert "my_factory" in config.dependencies
+
+    def test_config_with_multiple_dependencies(self):
+        """Test Config with multiple dependencies."""
+        config = Config(dependencies={
+            "factory1": Factory(class_="datetime.datetime", kwargs={}),
+            "factory2": Factory(class_="os.PathLike", kwargs={}),
+        })
+        assert len(config.dependencies) == 2
+        assert "factory1" in config.dependencies
+        assert "factory2" in config.dependencies
+
+    def test_config_default_dependencies(self):
+        """Test Config default dependencies value."""
+        config = Config()
+        assert config.dependencies == {}

abcdi_config-0.0.1/version

@@ -0,0 +1 @@
+0.0.1