doppy-di 0.1.0__tar.gz

doppy_di-0.1.0/.gitignore

@@ -0,0 +1,235 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+.refact
+
+node_modules
+
+ecosystem.md
+plan.md
+source.md
+*.lock
+!uv.lock
+
+.clinerules
+
+!commitlint.config.cjs
+!package.json
+!.releaserc.json
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+.uv-cache/
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+
+#Ignore vscode AI rules
+.github\instructions\codacy.instructions.md

doppy_di-0.1.0/LICENSE

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

doppy_di-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: doppy-di
+Version: 0.1.0
+Summary: Minimal dependency injection container
+Project-URL: Homepage, https://github.com/MaxGoryunov/doppy-di
+Project-URL: Repository, https://github.com/MaxGoryunov/doppy-di
+Author: doppy maintainers
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: mypy<2,>=1.16; extra == 'dev'
+Requires-Dist: nox>=2025.5.1; extra == 'dev'
+Requires-Dist: pre-commit>=4.2; extra == 'dev'
+Requires-Dist: pytest-cov>=6.2; extra == 'dev'
+Requires-Dist: pytest>=8.4; extra == 'dev'
+Requires-Dist: ruff>=0.12; extra == 'dev'
+Requires-Dist: uv>=0.11; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# python-dic

doppy_di-0.1.0/README.md

@@ -0,0 +1 @@
+# python-dic

doppy_di-0.1.0/container.py

@@ -0,0 +1,359 @@
+"""Core dependency injection container.
+
+This module provides immutable rule descriptions and a minimal container with
+explicit rule registration.
+
+Example:
+    >>> builder = ContainerBuilder()
+    >>> builder.service("answer", lambda: 42)
+    >>> container = builder.build()
+    >>> container.get("answer")
+    42
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Type, Union
+
+
+class KeyProtocol(Protocol):
+    """A protocol for custom hashable keys."""
+
+    def __hash__(self) -> int: ...
+
+    def __eq__(self, other: object) -> bool: ...
+
+
+Key = Union[str, type, KeyProtocol]
+Lifetime = str
+
+
+class CycleError(Exception):
+    """Raised when the rule graph contains a dependency cycle.
+
+    Example:
+        >>> raise CycleError(["a", "b", "a"])
+    """
+
+    def __init__(self, path: List[Key]) -> None:
+        self.path = tuple(path)
+        super().__init__(f"Cycle detected: {' -> '.join(map(repr, path))}")
+
+
+class NestedRuleError(Exception):
+    """Raised when a nested rule validation fails.
+
+    Example:
+        >>> raise NestedRuleError("service", "db", "field mismatch")
+    """
+
+    def __init__(self, parent: Key, child: str, reason: str) -> None:
+        self.parent = parent
+        self.child = child
+        self.reason = reason
+        super().__init__(f"Nested rule error: {parent!r}.{child} - {reason}")
+
+
+@dataclass(frozen=True)
+class Rule:
+    """Immutable service rule.
+
+    Args:
+        key: Registration key.
+        make: Factory callable.
+        lifetime: Service lifetime.
+        deps: Dependency keys.
+
+    Example:
+        >>> rule = Rule("answer", lambda: 42, "singleton", ())
+        >>> rule.key
+        'answer'
+    """
+
+    key: Key
+    make: Callable[..., Any]
+    lifetime: Lifetime = "transient"
+    deps: Tuple[Key, ...] = ()
+
+
+class RuleSet:
+    """Immutable-by-convention rule storage and dependency graph.
+
+    Example:
+        >>> rules = RuleSet()
+        >>> rules.add("x", Rule("x", lambda: 1))
+        >>> rules.find("x").key
+        'x'
+    """
+
+    __slots__ = ("graph", "map")
+
+    def __init__(
+        self,
+        rules_map: Optional[Dict[Key, Rule]] = None,
+        graph: Optional[Dict[Key, Tuple[Key, ...]]] = None,
+    ) -> None:
+        self.map = dict(rules_map or {})
+        self.graph = dict(graph or {})
+
+    def add(self, key: Key, rule: Rule) -> None:
+        """Add a rule and validate graph cycles."""
+        self.map[key] = rule
+        self.graph[key] = tuple(rule.deps)
+        self._check_cycle(key)
+
+    def find(self, key: Key) -> Rule:
+        """Return a rule by key."""
+        return self.map[key]
+
+    def has(self, key: Key) -> bool:
+        """Check whether a key is registered."""
+        return key in self.map
+
+    def deps_of(self, key: Key) -> Tuple[Key, ...]:
+        """Return direct dependencies for a key."""
+        return self.graph.get(key, ())
+
+    def keys(self) -> Tuple[Key, ...]:
+        """Return registered keys."""
+        return tuple(self.map.keys())
+
+    def _check_cycle(self, start: Key) -> None:
+        """Check graph cycles from the given start node."""
+        stack: List[Key] = []
+        on_stack: set[Key] = set()
+        visited: set[Key] = set()
+
+        def dfs(node: Key) -> None:
+            if node in on_stack:
+                raise CycleError([*stack, node])
+            if node in visited:
+                return
+            visited.add(node)
+            on_stack.add(node)
+            stack.append(node)
+            for dep in self.graph.get(node, ()):
+                if dep in self.map:
+                    dfs(dep)
+            stack.pop()
+            on_stack.remove(node)
+
+        dfs(start)
+
+
+class ResolveContext:
+    """Resolution context used during object creation.
+
+    Example:
+        >>> builder = ContainerBuilder()
+        >>> builder.service("x", lambda: 1)
+        >>> c = builder.build()
+        >>> ctx = ResolveContext(c)
+        >>> ctx.get("x")
+        1
+    """
+
+    __slots__ = ("container", "scope")
+
+    def __init__(self, container: Container, scope: Optional[Scope] = None) -> None:
+        self.container = container
+        self.scope = scope or container
+
+    def get(self, key: Key) -> Any:
+        return self.scope.get(key) if isinstance(self.scope, Scope) else self.container.get(key)
+
+
+class OverrideContext:
+    """Context manager for temporary overrides.
+
+    Example:
+        >>> builder = ContainerBuilder()
+        >>> builder.value("x", 1)
+        >>> c = builder.build()
+        >>> with c.override("x", 2):
+        ...     c.get("x")
+        2
+    """
+
+    __slots__ = ("container", "had_old", "key", "old", "value")
+
+    def __init__(self, container: Container, key: Key, value: Any) -> None:
+        self.container = container
+        self.key = key
+        self.value = value
+        self.old: Any = None
+        self.had_old = False
+
+    def __enter__(self) -> OverrideContext:
+        if self.key in self.container.single:
+            self.old = self.container.single[self.key]
+            self.had_old = True
+        self.container.single[self.key] = self.value
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if self.had_old:
+            self.container.single[self.key] = self.old
+        else:
+            self.container.single.pop(self.key, None)
+
+
+class Scope:
+    """Scope-local cache over a container.
+
+    Example:
+        >>> builder = ContainerBuilder()
+        >>> builder.service("x", lambda: object(), lifetime="transient")
+        >>> c = builder.build()
+        >>> with c.scope("req") as s:
+        ...     a = s.get("x")
+        ...     b = s.get("x")
+        ...     a is b
+        True
+    """
+
+    __slots__ = ("cache", "container", "name")
+
+    def __init__(self, container: Container, name: str) -> None:
+        self.container = container
+        self.name = name
+        self.cache: Dict[Key, Any] = {}
+
+    def get(self, key: Key) -> Any:
+        if key in self.cache:
+            return self.cache[key]
+        obj = self.container.get(key)
+        self.cache[key] = obj
+        return obj
+
+    def __enter__(self) -> Scope:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.cache.clear()
+
+
+class Container:
+    """Runtime container with singleton cache.
+
+    Example:
+        >>> builder = ContainerBuilder()
+        >>> builder.service("answer", lambda: 42, lifetime="singleton")
+        >>> container = builder.build()
+        >>> container.get("answer")
+        42
+    """
+
+    __slots__ = ("config", "scopes", "single")
+
+    def __init__(self, config: ContainerConfig) -> None:
+        self.config = config
+        self.single: Dict[Key, Any] = {}
+        self.scopes: Dict[str, Scope] = {}
+
+    def get(self, key: Key) -> Any:
+        if key in self.single:
+            return self.single[key]
+
+        rule = self.config.ruleset.find(key)
+        ctx = ResolveContext(self)
+        args = [ctx.get(dep) for dep in rule.deps]
+        obj = rule.make(*args)
+
+        if rule.lifetime == "singleton":
+            self.single[key] = obj
+        self._cache_nested_aliases(key, obj)
+
+        return obj
+
+    def _cache_nested_aliases(self, key: Key, obj: Any) -> None:
+        for alias in self.config.ruleset.map:
+            if not isinstance(alias, tuple) or len(alias) != 2 or alias[0] != key:
+                continue
+            child = alias[1]
+            if isinstance(child, str) and hasattr(obj, child):
+                self.single[alias] = getattr(obj, child)
+
+    def has(self, key: Key) -> bool:
+        return self.config.ruleset.has(key)
+
+    def scope(self, name: str) -> Scope:
+        if name in self.scopes:
+            return self.scopes[name]
+        scope = Scope(self, name)
+        self.scopes[name] = scope
+        return scope
+
+    def override(self, key: Key, value: Any) -> OverrideContext:
+        return OverrideContext(self, key, value)
+
+
+@dataclass(frozen=True)
+class ContainerConfig:
+    """Immutable container configuration.
+
+    Example:
+        >>> rules = RuleSet()
+        >>> config = ContainerConfig(rules)
+        >>> isinstance(config.ruleset, RuleSet)
+        True
+    """
+
+    ruleset: RuleSet
+
+
+class ContainerBuilder:
+    """Builder for a container.
+
+    Example:
+        >>> builder = ContainerBuilder()
+        >>> builder.value("x", 1)
+        >>> c = builder.build()
+        >>> c.get("x")
+        1
+    """
+
+    __slots__ = ("rules",)
+
+    def __init__(self) -> None:
+        self.rules = RuleSet()
+
+    def service(
+        self,
+        key: Key,
+        make: Callable[..., Any],
+        lifetime: Lifetime = "transient",
+        deps: Optional[List[Key]] = None,
+    ) -> None:
+        rule = Rule(key=key, make=make, lifetime=lifetime, deps=tuple(deps or ()))
+        self.rules.add(key, rule)
+
+    def value(self, key: Key, value: Any) -> None:
+        def make_value() -> Any:
+            return value
+
+        self.rules.add(
+            key,
+            Rule(key=key, make=make_value, lifetime="singleton", deps=()),
+        )
+
+    def alias(self, key: Key, target: Key) -> None:
+        self.rules.add(
+            key,
+            Rule(key=key, make=lambda: None, lifetime="transient", deps=(target,)),
+        )
+
+    def build(self) -> Container:
+        return Container(ContainerConfig(self.rules))

doppy_di-0.1.0/devkit/__init__.py

@@ -0,0 +1,29 @@
+"""Devkit package for optional runtime layers and validation."""
+
+from container import ResolveContext
+
+from .logging import LoggingContainer
+from .nested import NestedPolicy, NestedRules, SameObjectPolicy, SameValuePolicy
+from .policy import (
+    ChildrenFirstPolicy,
+    OrderPolicy,
+    ParentFirstPolicy,
+    UnorderedPolicy,
+)
+from .validation import ValidatingContainer, ValidationRule, ValidationRunner
+
+__all__ = [
+    "ChildrenFirstPolicy",
+    "LoggingContainer",
+    "NestedPolicy",
+    "NestedRules",
+    "OrderPolicy",
+    "ParentFirstPolicy",
+    "ResolveContext",
+    "SameObjectPolicy",
+    "SameValuePolicy",
+    "UnorderedPolicy",
+    "ValidatingContainer",
+    "ValidationRule",
+    "ValidationRunner",
+]

doppy_di-0.1.0/devkit/logging.py

@@ -0,0 +1,58 @@
+"""Logging layer for container access.
+
+Example:
+    >>> from container import ContainerBuilder
+    >>> builder = ContainerBuilder()
+    >>> builder.value("x", 1)
+    >>> base = builder.build()
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from container import Container, Key, OverrideContext, Scope
+
+
+@dataclass(frozen=True)
+class LoggingContainer:
+    """Log container operations while preserving the same API.
+
+    Example:
+        >>> events = []
+        >>> def log(msg):
+        ...     events.append(msg)
+        >>> from container import ContainerBuilder
+        >>> builder = ContainerBuilder()
+        >>> builder.value("x", 1)
+        >>> base = builder.build()
+        >>> wrapped = LoggingContainer(base, log)
+        >>> wrapped.get("x")
+        1
+    """
+
+    wrapped: Container
+    log: Callable[[str], None]
+
+    def get(self, key: Key) -> Any:
+        self.log(f"get({key!r})")
+        try:
+            obj = self.wrapped.get(key)
+            self.log(f"get({key!r}) -> ok")
+            return obj
+        except Exception as exc:
+            self.log(f"get({key!r}) -> error: {exc.__class__.__name__}")
+            raise
+
+    def has(self, key: Key) -> bool:
+        self.log(f"has({key!r})")
+        return self.wrapped.has(key)
+
+    def scope(self, name: str) -> Scope:
+        self.log(f"scope({name!r})")
+        return self.wrapped.scope(name)
+
+    def override(self, key: Key, value: Any) -> OverrideContext:
+        self.log(f"override({key!r})")
+        return self.wrapped.override(key, value)

doppy_di-0.1.0/devkit/nested.py

@@ -0,0 +1,108 @@
+"""Nested-rule validation helpers.
+
+Example:
+    >>> from container import ContainerBuilder
+    >>> builder = ContainerBuilder()
+    >>> builder.value("x", 1)
+    >>> nested = NestedRules()
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Protocol
+
+from container import Container, Key, NestedRuleError, Rule, RuleSet
+
+
+class NestedPolicy(Protocol):
+    """Policy used to compare nested objects."""
+
+    def check(self, nested: Any, resolved: Any) -> bool:
+        """Return True if nested object is valid."""
+
+
+@dataclass(frozen=True)
+class SameObjectPolicy:
+    """Check object identity for nested values.
+
+    Example:
+        >>> policy = SameObjectPolicy()
+        >>> policy.check(object(), object())
+        False
+    """
+
+    def check(self, nested: Any, resolved: Any) -> bool:
+        return nested is resolved
+
+
+@dataclass(frozen=True)
+class SameValuePolicy:
+    """Check value equality for nested values.
+
+    Example:
+        >>> policy = SameValuePolicy()
+        >>> policy.check(1, 1)
+        True
+    """
+
+    def check(self, nested: Any, resolved: Any) -> bool:
+        return bool(nested == resolved)
+
+
+@dataclass(frozen=True)
+class NestedEntry:
+    """Describe one nested registration.
+
+    Example:
+        >>> entry = NestedEntry("service", "repo")
+        >>> entry.parent
+        'service'
+    """
+
+    parent: Key
+    child: str
+
+
+class NestedRules:
+    """Track nested relations and validate resolved objects.
+
+    Example:
+        >>> nested = NestedRules()
+        >>> rule = Rule(("service", "repo"), lambda repo: repo)
+        >>> nested.add_nested("service", "repo", rule, RuleSet())
+    """
+
+    __slots__ = ("map", "same_policy")
+
+    def __init__(self) -> None:
+        self.map: Dict[Key, List[str]] = {}
+        self.same_policy: NestedPolicy = SameValuePolicy()
+
+    def add_nested(self, parent: Key, child: str, rule: Rule, ruleset: RuleSet) -> None:
+        nested_key = (parent, child)
+        ruleset.add(nested_key, rule)
+        self.map.setdefault(parent, [])
+        if child not in self.map[parent]:
+            self.map[parent].append(child)
+
+    def children_of(self, parent: Key) -> List[str]:
+        return list(self.map.get(parent, []))
+
+    def validate_nested(self, parent: Key, container: Container, parent_obj: Any = None) -> None:
+        children = self.children_of(parent)
+        if not children:
+            return
+
+        if parent_obj is None:
+            parent_obj = container.get(parent)
+        for child in children:
+            nested_key = (parent, child)
+            nested_obj = container.get(nested_key)
+
+            if not hasattr(parent_obj, child):
+                raise NestedRuleError(parent, child, f"field {child!r} not found")
+
+            resolved = getattr(parent_obj, child)
+            if not self.same_policy.check(nested_obj, resolved):
+                raise NestedRuleError(parent, child, "nested validation failed")

doppy_di-0.1.0/devkit/policy.py

@@ -0,0 +1,91 @@
+"""Resolution order policies for container layers.
+
+Example:
+    >>> from container import ContainerBuilder
+    >>> builder = ContainerBuilder()
+    >>> builder.value("x", 1)
+    >>> container = builder.build()
+    >>> policy = UnorderedPolicy()
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Protocol
+
+from container import Key, ResolveContext, RuleSet
+
+
+class OrderPolicy(Protocol):
+    """A strategy for controlling resolution order."""
+
+    def before_resolve(self, key: Key, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        """Run before object resolution."""
+
+    def after_resolve(self, key: Key, obj: Any, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        """Run after object resolution."""
+
+
+@dataclass(frozen=True)
+class UnorderedPolicy:
+    """Policy with no extra resolution ordering.
+
+    Example:
+        >>> policy = UnorderedPolicy()
+        >>> isinstance(policy, UnorderedPolicy)
+        True
+    """
+
+    def before_resolve(self, key: Key, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        return None
+
+    def after_resolve(self, key: Key, obj: Any, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        return None
+
+
+@dataclass(frozen=True)
+class ChildrenFirstPolicy:
+    """Resolve nested children before the parent.
+
+    Example:
+        >>> policy = ChildrenFirstPolicy(nested={"service": ["repo"]})
+        >>> isinstance(policy, ChildrenFirstPolicy)
+        True
+    """
+
+    nested: Dict[Key, List[str]]
+
+    def __init__(self, nested: Optional[Dict[Key, List[str]]] = None) -> None:
+        object.__setattr__(self, "nested", dict(nested or {}))
+
+    def before_resolve(self, key: Key, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        for child_name in self.nested.get(key, []):
+            child_key = (key, child_name)
+            ctx.get(child_key)
+
+    def after_resolve(self, key: Key, obj: Any, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        return None
+
+
+@dataclass(frozen=True)
+class ParentFirstPolicy:
+    """Resolve parent first, then optionally inspect children.
+
+    Example:
+        >>> policy = ParentFirstPolicy(nested={"service": ["repo"]})
+        >>> isinstance(policy, ParentFirstPolicy)
+        True
+    """
+
+    nested: Dict[Key, List[str]]
+
+    def __init__(self, nested: Optional[Dict[Key, List[str]]] = None) -> None:
+        object.__setattr__(self, "nested", dict(nested or {}))
+
+    def before_resolve(self, key: Key, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        return None
+
+    def after_resolve(self, key: Key, obj: Any, ruleset: RuleSet, ctx: ResolveContext) -> None:
+        for child_name in self.nested.get(key, []):
+            child_key = (key, child_name)
+            ctx.get(child_key)

doppy_di-0.1.0/devkit/validation.py

@@ -0,0 +1,100 @@
+"""Validation layer for container resolution.
+
+Example:
+    >>> from container import ContainerBuilder
+    >>> builder = ContainerBuilder()
+    >>> builder.value("x", 1)
+    >>> container = builder.build()
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, List, Optional, Protocol
+
+from container import Container, Key, OverrideContext, ResolveContext, Scope
+
+from .nested import NestedRules
+from .policy import OrderPolicy
+
+
+class ValidationRule(Protocol):
+    """A validation rule executed after resolution."""
+
+    def check(self, container: Container, key: Key, obj: Any) -> None:
+        """Validate resolved object."""
+
+
+@dataclass(frozen=True)
+class ValidationRunner:
+    """Run a list of validation rules.
+
+    Example:
+        >>> runner = ValidationRunner()
+        >>> len(runner.rules)
+        0
+    """
+
+    rules: tuple[ValidationRule, ...]
+
+    def __init__(self, rules: Optional[List[ValidationRule]] = None) -> None:
+        object.__setattr__(self, "rules", tuple(rules or ()))
+
+    def add(self, rule: ValidationRule) -> None:
+        object.__setattr__(self, "rules", (*self.rules, rule))
+
+    def run(self, container: Container, key: Key, obj: Any) -> None:
+        for rule in self.rules:
+            rule.check(container, key, obj)
+
+
+class ValidatingContainer:
+    """Container view that applies order policy and validation.
+
+    Example:
+        >>> from container import ContainerBuilder
+        >>> builder = ContainerBuilder()
+        >>> builder.value("x", 1)
+        >>> base = builder.build()
+        >>> wrapped = ValidatingContainer(base, UnorderedPolicy(), ValidationRunner())
+        >>> wrapped.get("x")
+        1
+    """
+
+    __slots__ = ("nested", "policy", "validator", "wrapped")
+
+    def __init__(
+        self,
+        wrapped: Container,
+        policy: OrderPolicy,
+        validator: Optional[ValidationRunner] = None,
+        nested: Optional[NestedRules] = None,
+    ) -> None:
+        self.wrapped = wrapped
+        self.policy = policy
+        self.validator = validator or ValidationRunner()
+        self.nested = nested
+
+    def get(self, key: Key) -> Any:
+        ctx = ResolveContext(self.wrapped)
+        ruleset = self.wrapped.config.ruleset
+
+        self.policy.before_resolve(key, ruleset, ctx)
+        obj = self.wrapped.get(key)
+        self.policy.after_resolve(key, obj, ruleset, ctx)
+
+        self.validator.run(self.wrapped, key, obj)
+
+        if self.nested is not None and key in self.nested.map:
+            self.nested.validate_nested(key, self.wrapped, obj)
+
+        return obj
+
+    def has(self, key: Key) -> bool:
+        return self.wrapped.has(key)
+
+    def scope(self, name: str) -> Scope:
+        return self.wrapped.scope(name)
+
+    def override(self, key: Key, value: Any) -> OverrideContext:
+        return self.wrapped.override(key, value)

doppy_di-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "doppy-di"
+version = "0.1.0"
+description = "Minimal dependency injection container"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "doppy maintainers" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/MaxGoryunov/doppy-di"
+Repository = "https://github.com/MaxGoryunov/doppy-di"
+
+[project.optional-dependencies]
+dev = [
+    "mypy>=1.16,<2",
+    "nox>=2025.5.1",
+    "pre-commit>=4.2",
+    "pytest>=8.4",
+    "pytest-cov>=6.2",
+    "ruff>=0.12",
+    "uv>=0.11",
+]
+
+[tool.hatch.build]
+include = [
+    "container.py",
+    "devkit/**/*.py",
+]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["A", "B", "C4", "E", "F", "I", "N", "PT", "RUF", "SIM", "UP", "W"]
+ignore = ["UP006", "UP007", "UP035", "UP037", "UP045"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+warn_unreachable = true
+files = ["container.py", "devkit"]
+exclude = ['(^|/)noxfile\.py$', '\.venv/', 'venv/', 'tests/']
+
+[[tool.mypy.overrides]]
+module = "noxfile"
+ignore_errors = true
+
+[tool.pytest.ini_options]
+addopts = "--cov=container --cov=devkit --cov-report=term-missing"
+testpaths = ["tests"]
+
+[tool.coverage.run]
+branch = true
+source = ["container", "devkit"]
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "0.1.0"
+tag_format = "v$version"
+update_changelog_on_bump = true
+major_version_zero = true