pico-ioc 1.5.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

pico_ioc/exceptions.py

@@ -0,0 +1,66 @@
+# src/pico_ioc/exceptions.py
+from typing import Any, Iterable
+
+class PicoError(Exception):
+    pass
+
+class ProviderNotFoundError(PicoError):
+    def __init__(self, key: Any):
+        super().__init__(f"Provider not found for key: {getattr(key, '__name__', key)}")
+        self.key = key
+
+class CircularDependencyError(PicoError):
+    def __init__(self, chain: Iterable[Any], current: Any):
+        chain_str = " -> ".join(getattr(k, "__name__", str(k)) for k in chain)
+        cur_str = getattr(current, "__name__", str(current))
+        super().__init__(f"Circular dependency detected: {chain_str} -> {cur_str}")
+        self.chain = tuple(chain)
+        self.current = current
+
+class ComponentCreationError(PicoError):
+    def __init__(self, key: Any, cause: Exception):
+        k = getattr(key, "__name__", key)
+        super().__init__(f"Failed to create component for key: {k}; cause: {cause.__class__.__name__}: {cause}")
+        self.key = key
+        self.cause = cause
+
+class ScopeError(PicoError):
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+class ConfigurationError(PicoError):
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+class SerializationError(PicoError):
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+class ValidationError(PicoError):
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+class InvalidBindingError(ValidationError):
+    def __init__(self, errors: list[str]):
+        super().__init__("Invalid bindings:\n" + "\n".join(f"- {e}" for e in errors))
+        self.errors = errors
+
+class EventBusError(PicoError):
+    def __init__(self, msg: str):
+        super().__init__(msg)
+
+class EventBusClosedError(EventBusError):
+    def __init__(self):
+        super().__init__("EventBus is closed")
+
+class EventBusQueueFullError(EventBusError):
+    def __init__(self):
+        super().__init__("Event queue is full")
+
+class EventBusHandlerError(EventBusError):
+    def __init__(self, event_name: str, handler_name: str, cause: Exception):
+        super().__init__(f"Handler {handler_name} failed for event {event_name}: {cause.__class__.__name__}: {cause}")
+        self.event_name = event_name
+        self.handler_name = handler_name
+        self.cause = cause
+

pico_ioc/factory.py

@@ -0,0 +1,48 @@
+# src/pico_ioc/factory.py
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Optional, Set, Tuple, Union
+from .exceptions import ProviderNotFoundError
+
+KeyT = Union[str, type]
+Provider = Callable[[], Any]
+
+@dataclass(frozen=True)
+class ProviderMetadata:
+    key: KeyT
+    provided_type: Optional[type]
+    concrete_class: Optional[type]
+    factory_class: Optional[type]
+    factory_method: Optional[str]
+    qualifiers: Set[str]
+    primary: bool
+    lazy: bool
+    infra: Optional[str]
+    pico_name: Optional[Any]
+    override: bool = False
+    scope: str = "singleton"
+
+class ComponentFactory:
+    def __init__(self) -> None:
+        self._providers: Dict[KeyT, Provider] = {}
+    def bind(self, key: KeyT, provider: Provider) -> None:
+        self._providers[key] = provider
+    def has(self, key: KeyT) -> bool:
+        return key in self._providers
+    def get(self, key: KeyT) -> Provider:
+        if key not in self._providers:
+            raise ProviderNotFoundError(key)
+        return self._providers[key]
+
+class DeferredProvider:
+    def __init__(self, builder: Callable[[Any, Any], Any]) -> None:
+        self._builder = builder
+        self._pico: Any = None
+        self._locator: Any = None
+    def attach(self, pico, locator) -> None:
+        self._pico = pico
+        self._locator = locator
+    def __call__(self) -> Any:
+        if self._pico is None or self._locator is None:
+            raise RuntimeError("DeferredProvider must be attached before use")
+        return self._builder(self._pico, self._locator)
+

pico_ioc/locator.py

@@ -0,0 +1,53 @@
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, Union
+from .factory import ProviderMetadata
+
+KeyT = Union[str, type]
+
+class ComponentLocator:
+    def __init__(self, metadata: Dict[KeyT, ProviderMetadata], indexes: Dict[str, Dict[Any, List[KeyT]]]) -> None:
+        self._metadata = metadata
+        self._indexes = indexes
+        self._candidates: Optional[Set[KeyT]] = None
+    def _ensure(self) -> Set[KeyT]:
+        return set(self._metadata.keys()) if self._candidates is None else set(self._candidates)
+    def _select_index(self, name: str, values: Iterable[Any]) -> Set[KeyT]:
+        out: Set[KeyT] = set()
+        idx = self._indexes.get(name, {})
+        for v in values:
+            out.update(idx.get(v, []))
+        return out
+    def _new(self, candidates: Set[KeyT]) -> "ComponentLocator":
+        nl = ComponentLocator(self._metadata, self._indexes)
+        nl._candidates = candidates
+        return nl
+    def with_index_any(self, name: str, *values: Any) -> "ComponentLocator":
+        base = self._ensure()
+        sel = self._select_index(name, values)
+        return self._new(base & sel)
+    def with_index_all(self, name: str, *values: Any) -> "ComponentLocator":
+        base = self._ensure()
+        cur = base
+        for v in values:
+            cur = cur & set(self._indexes.get(name, {}).get(v, []))
+        return self._new(cur)
+    def with_qualifier_any(self, *qs: Any) -> "ComponentLocator":
+        return self.with_index_any("qualifier", *qs)
+    def primary_only(self) -> "ComponentLocator":
+        return self.with_index_any("primary", True)
+    def lazy(self, is_lazy: bool = True) -> "ComponentLocator":
+        return self.with_index_any("lazy", True) if is_lazy else self.with_index_any("lazy", False)
+    def infra(self, *names: Any) -> "ComponentLocator":
+        return self.with_index_any("infra", *names)
+    def pico_name(self, *names: Any) -> "ComponentLocator":
+        return self.with_index_any("pico_name", *names)
+    def by_key_type(self, t: type) -> "ComponentLocator":
+        base = self._ensure()
+        if t is str:
+            c = {k for k in base if isinstance(k, str)}
+        elif t is type:
+            c = {k for k in base if isinstance(k, type)}
+        else:
+            c = {k for k in base if isinstance(k, t)}
+        return self._new(c)
+    def keys(self) -> List[KeyT]:
+        return list(self._ensure())

pico_ioc/scope.py

@@ -1,41 +1,112 @@
-from __future__ import annotations
+import contextvars
+from typing import Any, Dict, Optional, Tuple
+from collections import OrderedDict
 
-from typing import Any, Optional
+class ScopeProtocol:
+    def get_id(self) -> Any | None: ...
 
-from .container import PicoContainer
+class ContextVarScope(ScopeProtocol):
+    def __init__(self, var: contextvars.ContextVar) -> None:
+        self._var = var
+    def get_id(self) -> Any | None:
+        return self._var.get()
+    def activate(self, scope_id: Any) -> contextvars.Token:
+        return self._var.set(scope_id)
+    def deactivate(self, token: contextvars.Token) -> None:
+        self._var.reset(token)
 
-class ScopedContainer(PicoContainer):
-    def __init__(self, built_container: PicoContainer, base: Optional[PicoContainer], strict: bool):
-        super().__init__(providers=getattr(built_container, "_providers", {}).copy())
-        self._active_profiles = getattr(built_container, "_active_profiles", ())
-        base_method_its = getattr(base, "_method_interceptors", ()) if base else ()
-        base_container_its = getattr(base, "_container_interceptors", ()) if base else ()
-        self._method_interceptors = base_method_its
-        self._container_interceptors = base_container_its
-        self._seen_interceptor_types = {type(it) for it in base_container_its}
-        for it in getattr(built_container, "_method_interceptors", ()):
-            self.add_method_interceptor(it)
-        for it in getattr(built_container, "_container_interceptors", ()):
-            self.add_container_interceptor(it)
-        self._base = base
-        self._strict = strict
-        if base:
-            self._singletons.update(getattr(base, "_singletons", {}))
+class ComponentContainer:
+    def __init__(self) -> None:
+        self._instances: Dict[object, object] = {}
+    def get(self, key):
+        return self._instances.get(key)
+    def put(self, key, value):
+        self._instances[key] = value
+    def items(self):
+        return list(self._instances.items())
 
-    def __enter__(self): return self
-    def __exit__(self, exc_type, exc, tb): return False
+class _NoCacheContainer(ComponentContainer):
+    def __init__(self) -> None:
+        pass
+    def get(self, key):
+        return None
+    def put(self, key, value):
+        return
+    def items(self):
+        return []
 
-    def has(self, key: Any) -> bool:
-        if super().has(key): return True
-        if not self._strict and self._base is not None:
-            return self._base.has(key)
-        return False
-
-    def get(self, key: Any):
-        try:
-            return super().get(key)
-        except NameError as e:
-            if not self._strict and self._base is not None and self._base.has(key):
-                return self._base.get(key)
-            raise e
+class ScopeManager:
+    def __init__(self) -> None:
+        self._scopes: Dict[str, ScopeProtocol] = {
+            "request": ContextVarScope(contextvars.ContextVar("pico_request_id", default=None)),
+            "session": ContextVarScope(contextvars.ContextVar("pico_session_id", default=None)),
+            "transaction": ContextVarScope(contextvars.ContextVar("pico_tx_id", default=None)),
+        }
+    def register_scope(self, name: str, implementation: ScopeProtocol) -> None:
+        if not isinstance(name, str) or not name:
+            from .exceptions import ScopeError
+            raise ScopeError("Scope name must be a non-empty string")
+        if name in ("singleton", "prototype"):
+            from .exceptions import ScopeError
+            raise ScopeError("Cannot register or override reserved scopes: 'singleton' or 'prototype'")
+        self._scopes[name] = implementation
+    def get_id(self, name: str) -> Any | None:
+        if name in ("singleton", "prototype"):
+            return None
+        impl = self._scopes.get(name)
+        return impl.get_id() if impl else None
+    def activate(self, name: str, scope_id: Any) -> Optional[contextvars.Token]:
+        if name in ("singleton", "prototype"):
+            return None
+        impl = self._scopes.get(name)
+        if impl is None:
+            from .exceptions import ScopeError
+            raise ScopeError(f"Unknown scope: {name}")
+        if hasattr(impl, "activate"):
+            return getattr(impl, "activate")(scope_id)
+        return None
+    def deactivate(self, name: str, token: Optional[contextvars.Token]) -> None:
+        if name in ("singleton", "prototype"):
+            return
+        impl = self._scopes.get(name)
+        if impl is None:
+            from .exceptions import ScopeError
+            raise ScopeError(f"Unknown scope: {name}")
+        if token is not None and hasattr(impl, "deactivate"):
+            getattr(impl, "deactivate")(token)
+    def names(self) -> Tuple[str, ...]:
+        return tuple(n for n in self._scopes.keys() if n not in ("singleton", "prototype"))
+    def signature(self, names: Tuple[str, ...]) -> Tuple[Any, ...]:
+        return tuple(self.get_id(n) for n in names)
+    def signature_all(self) -> Tuple[Any, ...]:
+        return self.signature(self.names())
 
+class ScopedCaches:
+    def __init__(self, max_scopes_per_type: int = 2048) -> None:
+        self._singleton = ComponentContainer()
+        self._by_scope: Dict[str, OrderedDict[Any, ComponentContainer]] = {}
+        self._max = int(max_scopes_per_type)
+        self._no_cache = _NoCacheContainer()
+    def for_scope(self, scopes: ScopeManager, scope: str) -> ComponentContainer:
+        if scope == "singleton":
+            return self._singleton
+        if scope == "prototype":
+            return self._no_cache
+        sid = scopes.get_id(scope)
+        bucket = self._by_scope.setdefault(scope, OrderedDict())
+        if sid in bucket:
+            c = bucket.pop(sid)
+            bucket[sid] = c
+            return c
+        if len(bucket) >= self._max:
+            bucket.popitem(last=False)
+        c = ComponentContainer()
+        bucket[sid] = c
+        return c
+    def all_items(self):
+        for item in self._singleton.items():
+            yield item
+        for b in self._by_scope.values():
+            for c in b.values():
+                for item in c.items():
+                    yield item

pico_ioc-2.0.0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: pico-ioc
+Version: 2.0.0
+Summary: A minimalist, zero-dependency Inversion of Control (IoC) container for Python.
+Author-email: David Perez Cabrera <dperezcabrera@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 David Pérez Cabrera
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/dperezcabrera/pico-ioc
+Project-URL: Repository, https://github.com/dperezcabrera/pico-ioc
+Project-URL: Issue Tracker, https://github.com/dperezcabrera/pico-ioc/issues
+Keywords: ioc,di,dependency injection,inversion of control,decorator
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 📦 Pico-IoC: A Robust, Async-Native IoC Container for Python
+
+[![PyPI](https://img.shields.io/pypi/v/pico-ioc.svg)](https://pypi.org/project/pico-ioc/)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/dperezcabrera/pico-ioc)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+![CI (tox matrix)](https://github.com/dperezcabrera/pico-ioc/actions/workflows/ci.yml/badge.svg)
+[![codecov](https://codecov.io/gh/dperezcabrera/pico-ioc/branch/main/graph/badge.svg)](https://codecov.io/gh/dperezcabrera/pico-ioc)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-ioc&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-ioc)
+[![Duplicated Lines (%)](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-ioc&metric=duplicated_lines_density)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-ioc)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=dperezcabrera_pico-ioc&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=dperezcabrera_pico-ioc)
+
+**pico-ioc** is a **robust, async-native, decorator-based IoC container for Python**.
+It helps you build loosely-coupled, testable, enterprise-grade applications without manual wiring. Inspired by the Spring ecosystem, but fully Pythonic.
+
+> ⚠️ **Requires Python 3.10+** (due to extensive use of modern `typing` features).
+
+---
+
+## ⚖️ Principles
+
+* **Focus & Simplicity**: A declarative API for one job: managing dependencies. It avoids accidental complexity by doing one thing well.
+* **Declarative & Explicit**: No magic. Behavior is deterministic, relying on explicit decorators (`@component`, `@factory`) and type hints.
+* **Unified Composition Root**: The application is assembled from a single entry point (`init`) which defines a clear, predictable boundary.
+* **Fail-Fast by Design**: Catches **circular dependencies** and **missing bindings** at startup, not at runtime. If the application runs, it's wired correctly.
+* **Testability First**: Features like `@conditional`, profiles, and `overrides` are first-class citizens, enabling fast and isolated testing.
+* **Async Native & Extensible**: Full `async`/`await` support, AOP (`@intercepted_by`), and a built-in `EventBus` are available out-of-the-box.
+* **Framework Agnostic**: Zero hard dependencies (standard library only). It works with any Python application, from simple scripts to complex web servers.
+
+---
+
+## ✨ Why Pico-IoC?
+
+`pico-ioc` exists to solve a common problem that arises as Python applications grow: managing how objects are created and connected becomes complex and brittle. This manual wiring, where a change deep in the application can cause a cascade of updates, makes the code hard to test and maintain.
+
+`pico-ioc` introduces the principle of Inversion of Control (IoC) in a simple, Pythonic way. Instead of you creating and connecting every object, you declare your components with a simple `@component` decorator, and the container automatically wires them together based on their type hints. It brings the architectural robustness and testability of mature frameworks like Spring to the Python ecosystem, allowing you to build complex, loosely-coupled applications that remain simple to manage.
+
+| Feature | Manual Wiring | With Pico-IoC |
+| :--- | :--- | :--- |
+| **Object Creation** | `service = Service(Repo(Config()))` | `svc = container.get(Service)` |
+| **Testing** | Manual replacement or monkey-patching | `overrides={Repo: FakeRepo()}` |
+| **Coupling** | High (code knows about constructors) | Low (code just asks for a type) |
+| **Maintenance** | Brittle (changing a constructor breaks consumers) | Robust (changes are isolated) |
+| **Learning Curve** | Ad-hoc, implicit patterns | Uniform, explicit, documented |
+
+---
+
+## 🧩 Features
+
+### Core
+
+* **Zero external dependencies** — pure Python, framework-agnostic.
+* **Decorator-based API** — `@component`, `@factory`, `@provides`, `@configuration`.
+* **Fail-fast Bootstrap** — Detects **circular dependencies** and **missing bindings** at startup.
+* **Async-Native Resolution** — Full `async`/`await` support with `container.aget()`.
+* **Sophisticated Scopes** — `singleton`, `prototype`, and `ContextVar`-based scopes (e.g., `request`, `session`).
+* **Typed Configuration** — Injects `dataclasses` from environment/files via `@configuration`.
+* **Test-Driven** — Built-in `overrides` and `profiles` for easy mocking.
+
+### Advanced
+
+* **AOP / Interceptors** — Intercept method calls with `@intercepted_by`.
+* **Qualifiers** — Inject subsets of components with `Annotated[List[T], Qualifier(...)]`.
+* **Async Event Bus** — Built-in `EventBus` for decoupled, event-driven architecture.
+* **Conditional Registration** — `@conditional` (by profile, env var) and `@on_missing` (fallbacks).
+* **Lifecycle Hooks** — `@configure` (post-init) and `@cleanup` (on shutdown).
+* **Health Checks** — Built-in `@health` decorator and `container.health_check()`.
+* **Serializable Proxies** — Lazy (`@lazy`) and AOP proxies are `pickle`-safe.
+
+---
+
+## 📦 Installation
+
+```bash
+# Requires Python 3.10+
+pip install pico-ioc
+````
+
+-----
+
+## 🚀 Quick Start
+
+```python
+from pico_ioc import component, init, configuration
+from dataclasses import dataclass
+
+@configuration
+@dataclass
+class Config:
+    url: str = "sqlite:///demo.db"
+
+@component
+class Repo:
+    def __init__(self, cfg: Config):
+        self.url = cfg.url
+    def fetch(self): 
+        return f"fetching from {self.url}"
+
+@component
+class Service:
+    def __init__(self, repo: Repo):
+        self.repo = repo
+    def run(self): 
+        return self.repo.fetch()
+
+# Bootstrap the container by scanning modules
+# We use __name__ to scan the current module
+container = init(modules=[__name__])
+
+# Resolve the service and run
+svc = container.get(Service)
+print(svc.run())
+```
+
+**Output:**
+
+```
+fetching from sqlite:///demo.db
+```
+
+-----
+
+### Quick Overrides for Testing
+
+The `init` function accepts `overrides` to replace any component for testing.
+
+```python
+import my_app_module
+from pico_ioc import init
+
+# Define a fake repository
+class FakeRepo:
+    def fetch(self): 
+        return "fake-data"
+
+# Initialize the container, overriding the real Repo
+container = init(
+    modules=[my_app_module],
+    overrides={
+        Repo: FakeRepo()  # Override by type
+    }
+)
+
+# The service now receives FakeRepo instead of the real one
+svc = container.get(Service)
+assert svc.run() == "fake-data"
+```
+
+-----
+
+## 📖 Documentation
+
+  * **🚀 New to pico-ioc? Start with the User Guide.**
+
+      * [**guide.md**](.docs/guide.md) — Learn with practical examples: testing, configuration, AOP, async, and web framework integration.
+
+  * **🏗️ Want to understand the internals? See the Architecture.**
+
+      * [**architecture.md**](./docs/architecture.md) — A deep dive into the resolution algorithm, lifecycle, and internal design.
+
+-----
+
+## 🧪 Development
+
+```bash
+pip install tox
+tox
+```
+
+-----
+
+## 📜 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history.
+
+-----
+
+## 📜 License
+
+MIT — see [LICENSE](https://opensource.org/licenses/MIT)
+
+```
+```
+
+

pico_ioc-2.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pico_ioc/__init__.py,sha256=sfAtaueMwYKztdJOmU_0-lkMQ_1Lr196KOZE__mzQXI,2373
+pico_ioc/_version.py,sha256=hwOJuFUEKtsgiOt4l6op9s-hviovM6TK1uCdtRNWY4E,22
+pico_ioc/aop.py,sha256=YBvwPwSw8lbXxr_zGbJ8SyxSMh_1kwTFmaB9ezKIDrM,11602
+pico_ioc/api.py,sha256=iu61f3RAqGZ6W4B8JtF3CVkGVukF708O41rx46Q29Ro,32685
+pico_ioc/config_runtime.py,sha256=z1cHDb5PbM8PMLYRFf5c2dmze8V22xwEzpWcBhtmMpA,11950
+pico_ioc/constants.py,sha256=AhIt0ieDZ9Turxb_YbNzj11wUbBbzjKfWh1BDlSx2Nw,183
+pico_ioc/container.py,sha256=xNO1boVXuiMxjJGk8uZdFpLPGugQn1Hyvk1OO0ZcUBk,12509
+pico_ioc/event_bus.py,sha256=0u-uAvniNWk22r3IRqONyeR74SH4Ekc6zb2ZlIJ4HFE,8348
+pico_ioc/exceptions.py,sha256=IwhK7q28_cubG6yiD2mlBYwYPl5I4JAPyt4nss7WFJw,2254
+pico_ioc/factory.py,sha256=Q3aLwZ-MWbXKjm8unr871vlWSeVUDmzFQZ1mXzPkY5I,1557
+pico_ioc/locator.py,sha256=PBxZYO_xCOxG7aJZ0adDtINrJass_ZDNYmPD2O_oNqM,2401
+pico_ioc/scope.py,sha256=BZVEklggnpiKBlE07Ec9NNhJQ6Wg5cnS7IYRAiDB3-E,4473
+pico_ioc-2.0.0.dist-info/licenses/LICENSE,sha256=N1_nOvHTM6BobYnOTNXiQkroDqCEi6EzfGBv8lWtyZ0,1077
+pico_ioc-2.0.0.dist-info/METADATA,sha256=ubMhg9j-hhpzo3Ok5ySrfRMudhgnJol-7SIDKgCbNsE,9624
+pico_ioc-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pico_ioc-2.0.0.dist-info/top_level.txt,sha256=_7_RLu616z_dtRw16impXn4Mw8IXe2J4BeX5912m5dQ,9
+pico_ioc-2.0.0.dist-info/RECORD,,

pico_ioc/_state.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from threading import RLock
-from contextvars import ContextVar
-from contextlib import contextmanager
-from typing import Optional, TYPE_CHECKING
-
-# Type-only import to avoid cycles
-if TYPE_CHECKING:
-    from .container import PicoContainer
-
-
-# ---- Task/process context for the active container ----
-
-@dataclass(frozen=True, slots=True)
-class ContainerContext:
-    """Immutable snapshot for the active container state."""
-    container: "PicoContainer"
-    fingerprint: tuple
-    root_name: Optional[str]
-
-
-# Process-wide fallback (for non-async code) guarded by a lock
-_lock = RLock()
-_current_context: Optional[ContainerContext] = None
-
-# Task-local context (for async isolation)
-_ctxvar: ContextVar[Optional[ContainerContext]] = ContextVar("pico_ioc_ctx", default=None)
-
-
-def get_context() -> Optional[ContainerContext]:
-    """Return the current context (task-local first, then process-global)."""
-    ctx = _ctxvar.get()
-    return ctx if ctx is not None else _current_context
-
-
-def set_context(ctx: Optional[ContainerContext]) -> None:
-    """Atomically set both task-local and process-global context."""
-    with _lock:
-        _ctxvar.set(ctx)
-        globals()["_current_context"] = ctx
-
-
-# Optional compatibility helpers (only used by legacy API paths)
-def get_fingerprint() -> Optional[tuple]:
-    ctx = get_context()
-    return ctx.fingerprint if ctx else None
-
-
-def set_fingerprint(fp: Optional[tuple]) -> None:
-    """Compatibility shim: setting None clears the active context."""
-    if fp is None:
-        set_context(None)
-        return
-    ctx = get_context()
-    if ctx is not None:
-        set_context(ContainerContext(container=ctx.container, fingerprint=fp, root_name=ctx.root_name))
-
-
-# ---- Scan/resolve guards (kept as-is) ----
-
-_scanning: ContextVar[bool] = ContextVar("pico_scanning", default=False)
-_resolving: ContextVar[bool] = ContextVar("pico_resolving", default=False)
-
-
-@contextmanager
-def scanning_flag():
-    """Mark scanning=True within the block."""
-    tok = _scanning.set(True)
-    try:
-        yield
-    finally:
-        _scanning.reset(tok)
-