pico-ioc 1.0.0__tar.gz → 1.1.0__tar.gz

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/.llm/ARCHITECTURE.md

@@ -165,7 +165,9 @@ class Config:
 
 ## 10) Extensibility & overrides
 
-* **Test overrides**: register a factory after the app module.
+### Test overrides (module-based)
+
+Register a factory after the app module:
 
 ```python
 @factory_component
@@ -173,7 +175,7 @@ class TestOverrides:
     @provides(key=Repo)   # same key as production
     def provide_repo(self) -> Repo:
         return FakeRepo()
-```
+````
 
 Then:
 
@@ -181,7 +183,29 @@ Then:
 c = init([app, test_overrides])  # overrides win by order
 ```
 
-* **Multi-env composition**: define `app.prod`, `app.dev`, `app.test` packages that import different provider sets, then `init([app.prod])` etc.
+### Direct overrides argument
+
+`init()` also accepts an `overrides` dict for ad-hoc replacement:
+
+```python
+c = init(app, overrides={
+    Repo: FakeRepo(),                         # constant instance
+    "fast_model": lambda: {"mock": True},     # provider
+    "expensive": (lambda: object(), True),    # provider with lazy=True
+})
+```
+
+* **Applied before eager instantiation** → replaced providers never run.
+* **Formats supported**:
+
+  * `key: instance` → constant
+  * `key: callable` → non-lazy provider
+  * `key: (callable, lazy_bool)` → provider with explicit laziness
+* With `reuse=True`, calling `init(..., overrides=...)` again mutates the cached container bindings.
+
+### Multi-env composition
+
+Define `app.prod`, `app.dev`, `app.test` packages that import different provider sets, then call `init([app.prod])`, etc.
 
 ### Plugins
 
@@ -238,7 +262,7 @@ classDiagram
 flowchart TD
   A[Request instance for Type T] --> B{Cached?}
   B -- yes --> Z[Return cached]
-  B -- no --> C[Find provider for T (type→MRO→token)]
+  B -- no --> C[Find provider for T: type / MRO / token]
   C -- none --> E[Raise bootstrap error]
   C -- found --> D[Resolve constructor args recursively]
   D --> F[Instantiate]

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/.llm/DECISIONS.md

@@ -75,6 +75,22 @@ Each entry has a rationale and implications. If a decision is revoked, it should
 
 ---
 
+### 7. Overrides in `init()`
+- **Decision**: `init(..., overrides={...})` allows binding custom providers/instances at bootstrap time.
+- **Rationale**:  
+  * Simplifies unit testing and ad-hoc mocking.  
+  * Avoids creating dedicated override modules when only a few dependencies need to be replaced.  
+  * Keeps semantics explicit: last binding wins.
+- **Implications**:  
+  * Overrides are applied **before eager instantiation** — ensuring replaced providers never run.  
+  * Accepted formats:
+    - `key: instance` → constant binding
+    - `key: provider_callable` → non-lazy binding
+    - `key: (provider_callable, lazy_bool)` → binding with explicit laziness
+  * If `reuse=True`, calling `init(..., overrides=...)` again applies overrides on the cached container.
+
+---
+
 ## ❌ Won’t-Do Decisions
 
 ### 1. Alternative scopes (request/session)
@@ -115,4 +131,5 @@ Features that add complexity (alternative scopes, async providers, hot reload) a
 - **2025-08**: Dropped Python 3.8/3.9 support, minimum 3.10.  
 - **2025-08**: Clarified resolution order as *name-first*.  
 - **2025-08**: Documented lifecycle, plugins, and fail-fast policy.  
+- **2025-09**: Added `init(..., overrides)` feature for test/mocking convenience.
 

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/.llm/GUIDE.md

@@ -12,7 +12,7 @@ This guide shows how to structure a Python app with **pico-ioc**: define compone
 * **Component**: a class managed by the container. Use `@component`.
 * **Factory component**: a class that *provides* concrete instances (e.g., `Flask()`, clients). Use `@factory_component`.
 * **Provider**: a method on a factory that returns a dependency and declares its **key** (usually a type). Use `@provides(key=Type)` so consumers can request by type.
-* **Container**: built via `pico_ioc.init(package_or_module)`. Resolve with `container.get(TypeOrClass)`.
+* **Container**: built via `pico_ioc.init(package_or_module, ..., overrides=...)`. Resolve with `container.get(TypeOrClass)`.
 
 Resolution rule of thumb: **ask by type** (e.g., `container.get(Flask)` or inject `def __init__(..., app: Flask)`).
 
@@ -156,10 +156,15 @@ class Runner:
 
 ## 5) Testing & overrides
 
+You often want to replace real dependencies with fakes or mocks in tests.  
+There are two main patterns:
+
+### 5.1 Composition modules
+
 Define a **test factory** that provides fakes using the same keys:
 
 ```python
-# tests/test_overrides.py
+# tests/test_overrides_module.py
 from pico_ioc import factory_component, provides
 from app.repo import Repo
 
@@ -172,27 +177,55 @@ class TestOverrides:
     @provides(key=Repo)
     def provide_repo(self) -> Repo:
         return FakeRepo()
-```
+````
 
 Build the container for tests with both packages (app + overrides):
 
 ```python
-# tests/test_service.py
 from pico_ioc import init
 import app
-from tests import test_overrides
+from tests import test_overrides_module
 
 def test_service_fetch():
-    c = init([app, test_overrides])   # pass a list (composition root for tests)
+    c = init([app, test_overrides_module])
     svc = c.get(app.service.Service)
     assert svc.run() == "fake-data"
 ```
 
-> Pattern: use a **composition module** per environment (prod/test) and call `init([...])` with the modules that declare your providers. Providers registered later override earlier ones for the same key.
+### 5.2 Direct `overrides` argument
+
+`init()` also accepts an `overrides` dict for ad-hoc mocks. Each entry can be:
+
+* **Instance** → bound as constant.
+* **Callable** (0 args) → bound as provider, non-lazy.
+* **(provider, lazy\_bool)** → provider with explicit laziness.
+
+```python
+from pico_ioc import init
+import app
+
+fake_repo = object()
+
+c = init(app, overrides={
+    app.repo.Repo: fake_repo,            # constant
+    "fast_model": lambda: {"id": 123},   # provider
+    "expensive": (lambda: object(), True) # lazy provider
+})
+```
+
+This is handy for **quick mocking in unit tests**:
+
+```python
+def test_with_direct_overrides():
+    c = init(app, overrides={"fast_model": {"fake": True}}, reuse=False)
+    svc = c.get(app.service.Service)
+    assert svc.repo.fetch() == "fake-data"
+```
 
+> Note: if you call `init(..., reuse=True, overrides=...)` on an already built container, the overrides are applied on the cached container.
 ---
 
-## 5b) Qualifiers & collection injection
+## 6) Qualifiers & collection injection
 
 ```python
 from typing import Protocol, Annotated
@@ -218,14 +251,14 @@ class Orchestrator:
 
     def run(self, s: str) -> list[str]:
         return [h.handle("ok") for h in self.handlers]
-```
 
-If you request `list[Handler]` you get **all** implementations.
-If you request `list[Annotated[Handler, PAYMENTS]]`, you only get the tagged ones.
+```
+If you request list[Handler] you get all implementations.
+If you request list[Annotated[Handler, PAYMENTS]], you only get the tagged ones.
 
 ---
 
-## 5c) Plugins & Public API helper
+## 7) Plugins & Public API helper
 
 ```python
 from pico_ioc import plugin
@@ -264,7 +297,7 @@ from app import Service, Config, TracingPlugin
 
 ---
 
-## 6) Tips & guardrails
+## 8) Tips & guardrails
 
 * **Ask by type**: inject `Flask`, `Config`, `Repo` instead of strings.
 * **Keep constructors cheap**: do not perform I/O in `__init__`.
@@ -275,7 +308,7 @@ from app import Service, Config, TracingPlugin
 
 ---
 
-## 7) Troubleshooting
+## 9) Troubleshooting
 
 * **“No provider for X”**
   Ensure a `@provides(key=X)` exists in a module passed to `init(...)`, and your constructor type annotation is exactly `X`.
@@ -291,6 +324,88 @@ from app import Service, Config, TracingPlugin
 
 ---
 
+## 10) Examples
+
+### 10.1 Bootstrap & auto-imports
+
+```python
+# src/__init__.py
+from pico_ioc.public_api import export_public_symbols_decorated
+__getattr__, __dir__ = export_public_symbols_decorated("src", include_plugins=True)
+```
+
+Now you can import cleanly:
+
+```python
+from src import Service, Config, TracingPlugin
+```
+
+### 10.2 Flask with waitress
+
+```python
+# main_flask.py
+import logging
+from waitress import serve
+import pico_ioc, src
+from flask import Flask
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+    c = pico_ioc.init(src)
+    app = c.get(Flask)
+    serve(app, host="0.0.0.0", port=5001, threads=8)
+```
+
+### 10.3 FastAPI with uvicorn
+
+```python
+# main_fastapi.py
+import logging
+import pico_ioc, src, uvicorn
+from fastapi import FastAPI
+
+def main():
+    logging.basicConfig(level=logging.INFO)
+    c = pico_ioc.init(src)
+    app = c.get(FastAPI)
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+### 10.4 App Factory for externals
+
+```python
+# src/app_factory.py
+from pico_ioc import factory_component, provides
+from flask import Flask
+from fastapi import FastAPI
+import docker
+from .config import Config
+
+@factory_component
+class AppFactory:
+    def __init__(self):
+        self._config = Config()
+
+    @provides(key=Config)
+    def provide_config(self) -> Config:
+        return self._config
+
+    @provides(key=Flask)
+    def provide_flask(self) -> Flask:
+        return Flask(__name__)
+
+    @provides(key=FastAPI)
+    def provide_fastapi(self) -> FastAPI:
+        return FastAPI()
+
+    @provides(key=docker.DockerClient)
+    def provide_docker(self) -> docker.DockerClient:
+        return docker.from_env()
+```
+
+---
+
 **TL;DR**
 Decorate components, provide externals by type, `init()` once, and let the container do the wiring—so you can **run tests, serve web apps, or batch jobs with minimal glue**.
 
+

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/.llm/OVERVIEW.md

@@ -67,6 +67,7 @@ fetching from sqlite:///demo.db
 * **Test-friendly** → swap out components via `@provides`.
 * **Universal** → works with Flask, FastAPI, CLIs, or plain scripts.
 * **Extensible** → add tracing, logging, or metrics via plugins.
+* **Overrides for testing** → inject mocks/fakes directly via `init(overrides={...})`.
 
 ---
 
@@ -102,6 +103,26 @@ This keeps `__init__.py` **clean, declarative, and convention-driven**.
 
 ---
 
+## Testing with overrides
+
+You can replace providers on the fly during tests:
+
+```python
+from pico_ioc import init
+import myapp
+
+fake = {"repo": "fake-data"}
+c = init(myapp, overrides={
+    "fast_model": fake,                     # constant instance
+    "user_service": lambda: {"id": 1},      # provider
+})
+
+svc = c.get("fast_model")
+assert svc == {"repo": "fake-data"}
+
+```
+
+---
 
 👉 Next steps:
 

pico_ioc-1.1.0/CHANGELOG.md

@@ -0,0 +1,56 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+---
+
+## [1.0.0] — 2025-08-28
+
+### 🚀 Highlights
+- **Dropped legacy runtimes**
+  - Minimum Python version is now **3.10+**
+  - Simplifies internals by relying on `typing.Annotated` and `include_extras=True`
+
+- **Qualifiers support**
+  - Components can be tagged with `Qualifier` via `@qualifier(Q)`
+  - Enables fine-grained grouping of implementations
+
+- **Collection injection**
+  - Inject `list[T]` or `tuple[T]` to receive all registered implementations
+  - Supports filtered injection with `list[Annotated[T, Q]]`
+
+### 🔌 Core principles reaffirmed
+- **Singleton per container** — no request/session scopes
+- **Fail-fast bootstrap** — eager instantiation by default
+- **Explicit plugins** — passed to `init()` directly, no magic auto-discovery
+- **Public API helper** — `export_public_symbols_decorated` keeps `__init__.py` clean
+
+### ❌ Won’t-do decisions
+- Alternative scopes (request/session)
+- Async providers (`async def`)
+- Hot reload / dynamic re-scan
+
+These were evaluated and **rejected** to keep pico-ioc simple, deterministic, and testable.
+
+---
+
+## [1.1.0] — 2025-09-08
+
+### ✨ New
+- **Overrides in `init()`**
+  - Added `overrides` argument to `init(...)` for ad-hoc mocking/testing.
+  - Accepted formats:
+    - `key: instance` → constant binding
+    - `key: callable` → non-lazy provider
+    - `key: (callable, lazy_bool)` → provider with explicit laziness
+  - Applied **before eager instantiation**, so replaced providers never run.
+  - If `reuse=True`, calling `init(..., overrides=...)` again mutates the cached container.
+
+### 📚 Docs
+- Updated **README.md**, **GUIDE.md**, **OVERVIEW.md**, **DECISIONS.md**, and **ARCHITECTURE.md** to document overrides support.
+
+---
+
+## [Unreleased]
+- Upcoming improvements and fixes will be listed here.
+

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pico-ioc
-Version: 1.0.0
+Version: 1.1.0
 Summary: A minimalist, zero-dependency Inversion of Control (IoC) container for Python.
 Author-email: David Perez Cabrera <dperezcabrera@gmail.com>
 License: MIT License
@@ -72,6 +72,7 @@ It helps you build loosely-coupled, testable apps without manual wiring. Inspire
 - **Plugins** — lifecycle hooks (`before_scan`, `after_ready`).
 - **Public API helper** — auto-export decorated symbols in `__init__.py`.
 - **Thread/async safe** — isolation via `ContextVar`.
+- **Overrides for testing** — inject mocks/fakes directly via `init(overrides={...})`.
 
 ---
 
@@ -117,7 +118,21 @@ print(svc.run())
 ```
 fetching from sqlite:///demo.db
 ```
+---
+
+### Quick overrides for testing
+
+```python
+from pico_ioc import init
+import myapp
 
+fake = {"repo": "fake-data"}
+c = init(myapp, overrides={
+    "fast_model": fake,                  # constant instance
+    "user_service": lambda: {"id": 1},   # provider
+})
+assert c.get("fast_model") == {"repo": "fake-data"}
+```
 ---
 
 ## 📖 Documentation
@@ -137,6 +152,12 @@ tox
 
 ---
 
+## 📜 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history.
+
+---
+
 ## 📜 License
 
 MIT — see [LICENSE](https://opensource.org/licenses/MIT)

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/README.md

@@ -27,6 +27,7 @@ It helps you build loosely-coupled, testable apps without manual wiring. Inspire
 - **Plugins** — lifecycle hooks (`before_scan`, `after_ready`).
 - **Public API helper** — auto-export decorated symbols in `__init__.py`.
 - **Thread/async safe** — isolation via `ContextVar`.
+- **Overrides for testing** — inject mocks/fakes directly via `init(overrides={...})`.
 
 ---
 
@@ -72,7 +73,21 @@ print(svc.run())
 ```
 fetching from sqlite:///demo.db
 ```
+---
+
+### Quick overrides for testing
+
+```python
+from pico_ioc import init
+import myapp
 
+fake = {"repo": "fake-data"}
+c = init(myapp, overrides={
+    "fast_model": fake,                  # constant instance
+    "user_service": lambda: {"id": 1},   # provider
+})
+assert c.get("fast_model") == {"repo": "fake-data"}
+```
 ---
 
 ## 📖 Documentation
@@ -92,6 +107,12 @@ tox
 
 ---
 
+## 📜 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history.
+
+---
+
 ## 📜 License
 
 MIT — see [LICENSE](https://opensource.org/licenses/MIT)

pico_ioc-1.1.0/src/pico_ioc/_version.py

@@ -0,0 +1 @@
+__version__ = '1.1.0'

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/src/pico_ioc/api.py

@@ -3,7 +3,7 @@
 import inspect
 import logging
 from contextlib import contextmanager
-from typing import Callable, Optional, Tuple
+from typing import Callable, Optional, Tuple, Any, Dict  # ⬅️ Any, Dict
 
 from .container import PicoContainer, Binder
 from .plugins import PicoPlugin
@@ -24,14 +24,14 @@ def init(
     auto_exclude_caller: bool = True,
     plugins: Tuple[PicoPlugin, ...] = (),
     reuse: bool = True,
+    overrides: Optional[Dict[Any, Any]] = None,  # ⬅️ NUEVO
 ) -> PicoContainer:
-    """
-    Initialize and configure a PicoContainer by scanning a root package.
-    """
+
     root_name = root_package if isinstance(root_package, str) else getattr(root_package, "__name__", None)
 
-    # Reuse only if the existing container was built for the same root
     if reuse and _state._container and _state._root_name == root_name:
+        if overrides:
+            _apply_overrides(_state._container, overrides)
         return _state._container
 
     combined_exclude = _build_exclude(exclude, auto_exclude_caller, root_name=root_name)
@@ -48,6 +48,9 @@ def init(
             plugins=plugins,
         )
 
+    if overrides:
+        _apply_overrides(container, overrides)
+
     _run_hooks(plugins, "after_bind", container, binder)
     _run_hooks(plugins, "before_eager", container, binder)
 
@@ -57,22 +60,32 @@ def init(
 
     logging.info("Container configured and ready.")
     _state._container = container
-    _state._root_name = root_name  # remember which root this container represents
+    _state._root_name = root_name
     return container
 
 
 # -------------------- helpers --------------------
 
+def _apply_overrides(container: PicoContainer, overrides: Dict[Any, Any]) -> None:
+    for key, val in overrides.items():
+        lazy = False
+        if isinstance(val, tuple) and len(val) == 2 and callable(val[0]) and isinstance(val[1], bool):
+            provider = val[0]
+            lazy = val[1]
+        elif callable(val):
+            provider = val
+        else:
+            def provider(v=val):
+                return v
+        container.bind(key, provider, lazy=lazy)
+
+
 def _build_exclude(
     exclude: Optional[Callable[[str], bool]],
     auto_exclude_caller: bool,
     *,
     root_name: Optional[str] = None,
 ) -> Optional[Callable[[str], bool]]:
-    """
-    Compose the exclude predicate. When auto_exclude_caller=True, exclude only
-    the exact calling module, but never exclude modules under the root being scanned.
-    """
     if not auto_exclude_caller:
         return exclude
 
@@ -91,7 +104,6 @@ def _build_exclude(
 
 
 def _get_caller_module_name() -> Optional[str]:
-    """Return the module name that called `init`."""
     try:
         f = inspect.currentframe()
         # frame -> _get_caller_module_name -> _build_exclude -> init

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/src/pico_ioc/container.py

@@ -28,6 +28,9 @@ class PicoContainer:
         self._singletons: Dict[Any, Any] = {}
 
     def bind(self, key: Any, provider, *, lazy: bool):
+        # 🔧 rebind must evict any cached singleton for this key
+        self._singletons.pop(key, None)
+
         meta = {"factory": provider, "lazy": bool(lazy)}
         try:
             q = getattr(key, QUALIFIERS_KEY, ())

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/src/pico_ioc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pico-ioc
-Version: 1.0.0
+Version: 1.1.0
 Summary: A minimalist, zero-dependency Inversion of Control (IoC) container for Python.
 Author-email: David Perez Cabrera <dperezcabrera@gmail.com>
 License: MIT License
@@ -72,6 +72,7 @@ It helps you build loosely-coupled, testable apps without manual wiring. Inspire
 - **Plugins** — lifecycle hooks (`before_scan`, `after_ready`).
 - **Public API helper** — auto-export decorated symbols in `__init__.py`.
 - **Thread/async safe** — isolation via `ContextVar`.
+- **Overrides for testing** — inject mocks/fakes directly via `init(overrides={...})`.
 
 ---
 
@@ -117,7 +118,21 @@ print(svc.run())
 ```
 fetching from sqlite:///demo.db
 ```
+---
+
+### Quick overrides for testing
+
+```python
+from pico_ioc import init
+import myapp
 
+fake = {"repo": "fake-data"}
+c = init(myapp, overrides={
+    "fast_model": fake,                  # constant instance
+    "user_service": lambda: {"id": 1},   # provider
+})
+assert c.get("fast_model") == {"repo": "fake-data"}
+```
 ---
 
 ## 📖 Documentation
@@ -137,6 +152,12 @@ tox
 
 ---
 
+## 📜 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for version history.
+
+---
+
 ## 📜 License
 
 MIT — see [LICENSE](https://opensource.org/licenses/MIT)

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/src/pico_ioc.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 .coveragerc
+CHANGELOG.md
 LICENSE
 MANIFEST.in
 README.md

{pico_ioc-1.0.0 → pico_ioc-1.1.0}/tests/test_api_unit.py

@@ -121,3 +121,77 @@ def test_logging_messages_emitted(caplog, monkeypatch):
     assert any("Initializing pico-ioc..." in m for m in msgs)
     assert any("Container configured and ready." in m for m in msgs)
 
+
+# --- Overrides tests -----------------------------------------------------------
+
+def test_overrides_bind_instance_provider_and_lazy(monkeypatch):
+    """
+    Verify that `overrides` supports:
+      - constant instance bindings,
+      - provider callable bindings (non-lazy),
+      - (provider, lazy_bool) bindings (lazy).
+    And that overrides are applied BEFORE eager instantiation so that
+    scanned providers don't run if they are replaced.
+    """
+    calls = {"scanned_x": 0, "prov_y": 0, "lazy_z": 0}
+
+    # Fake scan that would bind an eager provider for key "x"
+    def fake_scan(root_package, container, *, exclude, plugins):
+        container.bind("x", lambda: ("scanned", calls.__setitem__("scanned_x", calls["scanned_x"] + 1)), lazy=False)
+
+    monkeypatch.setattr(api, "scan_and_configure", fake_scan)
+
+    # Prepare overrides:
+    #  - "x": constant instance → must replace scanned provider and avoid its execution
+    #  - "y": provider (non-lazy) → executed during eager
+    #  - "z": (provider, True) lazy → executed only on first get()
+    def prov_y():
+        calls["prov_y"] += 1
+        return {"y": "from-provider"}
+
+    def prov_z():
+        calls["lazy_z"] += 1
+        return {"z": "lazy-provider"}
+
+    c = api.init(
+        "pkg",
+        reuse=False,
+        overrides={
+            "x": {"x": "constant"},    # instance
+            "y": prov_y,               # provider, non-lazy
+            "z": (prov_z, True),       # provider, lazy=True
+        },
+    )
+
+    # "x" should be the constant instance; scanned provider must not have run
+    assert c.get("x") == {"x": "constant"}
+    assert calls["scanned_x"] == 0
+
+    # "y" is non-lazy → created during eager (exactly once)
+    assert c.get("y") == {"y": "from-provider"}
+    assert calls["prov_y"] == 1
+
+    # "z" is lazy → not created at eager time
+    assert calls["lazy_z"] == 0
+    assert c.get("z") == {"z": "lazy-provider"}
+    assert calls["lazy_z"] == 1
+    # Cached singleton on subsequent gets
+    assert c.get("z") == {"z": "lazy-provider"}
+    assert calls["lazy_z"] == 1
+
+
+def test_overrides_apply_on_reused_container(monkeypatch):
+    """
+    If reuse=True and the root matches, calling init() again with new overrides
+    should apply them on the cached container.
+    """
+    monkeypatch.setattr(api, "scan_and_configure", lambda *a, **k: None)
+
+    c1 = api.init("pkg", reuse=True, overrides={"k": {"v": 1}})
+    assert c1.get("k") == {"v": 1}
+
+    # Reuse the same root, override with a different value
+    c2 = api.init("pkg", reuse=True, overrides={"k": {"v": 2}})
+    assert c1 is c2
+    assert c2.get("k") == {"v": 2}  # updated
+

pico_ioc-1.0.0/src/pico_ioc/_version.py

@@ -1 +0,0 @@
-__version__ = '1.0.0'