pico-ioc 1.3.0__tar.gz → 1.4.0__tar.gz

{pico_ioc-1.3.0 → pico_ioc-1.4.0}/.llm/ARCHITECTURE.md

@@ -5,7 +5,7 @@
 >
 > ⚠️ **Requires Python 3.10+** (uses `typing.Annotated` with `include_extras=True`).
 
------
+---
 
 ## 1\) Design goals & non-goals
 
@@ -23,11 +23,12 @@
   - Hot reload or runtime graph mutation beyond explicit overrides.
   - Magical filesystem-wide auto-imports.
 
------
+---
 
 ## 2\) High-level model
 
   - **Component** → class marked with `@component`. Instantiated by the container.
+  - **Config Component** → class marked with `@config_component`. Instantiated and populated from external sources like files or environment variables.
   - **Factory component** → class marked with `@factory_component`; owns provider methods via `@provides(key=TypeOrToken)`. Providers return *externals* (e.g., `Flask`, DB clients).
   - **Interceptor** → class or function marked with `@interceptor`. Discovered automatically to apply cross-cutting logic.
   - **Container** → built by `pico_ioc.init(mod_or_list, ...)`; resolve with `container.get(KeyOrType)`.
@@ -38,8 +39,9 @@
 sequenceDiagram
     participant App as Your package(s)
     participant IOC as pico-ioc Container
-    App->>IOC: init(packages, ...)
-    IOC->>App: scan decorators (@component, @factory_component, @interceptor)
+    App->>IOC: init(packages, config, ...)
+    IOC->>IOC: Create ConfigRegistry from sources
+    IOC->>App: scan decorators (@component, @config_component, @interceptor)
     IOC->>IOC: register providers and collect interceptor declarations
     IOC->>IOC: build and activate interceptors
     IOC->>IOC: apply policy (e.g., @primary, @on_missing aliases)
@@ -50,13 +52,14 @@ sequenceDiagram
     IOC-->>App: instance(Service)
 ```
 
------
+---
 
 ## 3\) Discovery & registration
 
 1.  **Scan inputs** passed to `init(...)`: module or list of modules/packages.
 2.  **Collect**:
       * `@component` classes → registered by a **key** (defaults to the class type).
+      * `@config_component` classes → registered as special components whose instances are built from external configuration sources.
       * `@factory_component` classes → introspected for `@provides(key=...)` methods.
       * `@interceptor` classes/functions → collected for activation.
       * `@plugin` classes → if explicitly passed via `init(..., plugins=(...))`.
@@ -65,7 +68,7 @@ sequenceDiagram
 
 **Precedence:** If multiple providers are active for the same key (e.g., one with `@primary`, another regular), a deterministic policy is applied to choose the winner. Direct overrides are applied last, having the final say.
 
------
+---
 
 ## 4\) Resolution algorithm (deterministic)
 
@@ -94,7 +97,7 @@ If the constructor requests `list[T]` or `list[Annotated[T, Q]]`:
   * Registration order is preserved; no implicit sorting.
   * Returns an empty list if no matches.
 
------
+---
 
 ## 5\) Lifecycles & scopes
 
@@ -103,7 +106,7 @@ If the constructor requests `list[T]` or `list[Annotated[T, Q]]`:
 
 **Rationale:** Most Python app composition (config, clients, web apps) fits singleton-per-container; it’s simple and fast.
 
------
+---
 
 ## 6\) Factories & providers
 
@@ -127,7 +130,7 @@ Guidelines:
   * Providers should be **pure constructors** (no long-running work).
   * Prefer **typed keys** (e.g., `Flask`) over strings.
 
------
+---
 
 ## 7\) Concurrency model
 
@@ -135,7 +138,7 @@ Guidelines:
   * Caches & resolution are **thread/async safe** (internal isolation; no global singletons).
   * Instances you create **must** be safe for your usage patterns; the container cannot fix non-thread-safe libraries.
 
------
+---
 
 ## 8\) Error handling & diagnostics
 
@@ -147,22 +150,60 @@ Guidelines:
 
 **Tip:** Keep constructors **cheap**; push I/O to explicit start/serve methods.
 
------
+---
 
 ## 9\) Configuration
 
-Treat config as a **component**:
+Configuration is treated as a first-class, type-safe component using a dedicated injection system.
 
-```python
-@component
-class Config:
-    WORKERS: int = int(os.getenv("WORKERS", "4"))
-    DEBUG: bool = os.getenv("DEBUG", "0") == "1"
-```
+1.  **Define a Config Class**: Create a class (preferably a `dataclass`) and mark it with `@config_component`. An optional `prefix` can be used for environment variables.
+
+    ```python
+    from pico_ioc import config_component
+    from dataclasses import dataclass
+
+    @config_component(prefix="APP_")
+    @dataclass(frozen=True)
+    class Settings:
+        db_url: str
+        timeout: int = 30
+    ```
+
+2.  **Provide Sources**: At bootstrap, pass an ordered tuple of `ConfigSource` objects to the `config` parameter of `init()`. The order defines precedence (first source wins).
+
+    ```python
+    from pico_ioc import init
+    from pico_ioc.config import EnvSource, FileSource
+
+    container = init(
+        "my_app",
+        config=(
+            EnvSource(prefix="APP_"), # Highest priority
+            FileSource("config.prod.yml", optional=True),
+            FileSource("config.yml"), # Lowest priority
+        ),
+    )
+    ```
+
+3.  **Inject and Use**: Inject the config class into other components just like any other dependency.
+
+    ```python
+    from pico_ioc import component
+
+    @component
+    class Database:
+        def __init__(self, settings: Settings):
+            self.connection = connect(settings.db_url)
+    ```
+
+### Resolution Logic
+
+  - **Automatic Binding**: By default, `pico-ioc` binds fields automatically. For a field like `db_url`, it checks for keys like `APP_DB_URL` (in `EnvSource`), `DB_URL`, or `db_url` (in `FileSource`).
+  - **Manual Overrides**: For more complex cases where keys don't align, you can use field-level helpers like `Env["CUSTOM_VAR"]`, `File["key.in.file"]`, or `Path.file["nested.key"]` to specify the exact key to use.
 
-Inject `Config` where needed; avoid scattered `os.getenv` calls.
+This system ensures that configuration is **type-safe**, **externalized**, and **testable**, while remaining simple for the common cases.
 
------
+---
 
 ## 10\) Overrides & composition
 
@@ -176,9 +217,9 @@ The policy engine respects definition order. While not a strict "last-wins", pro
 
 ```python
 c = init(app, overrides={
-    Repo: FakeRepo(),                         # constant instance
-    "fast_model": lambda: {"mock": True},     # provider
-    "expensive": (lambda: object(), True),    # provider with lazy=True
+    Repo: FakeRepo(),                      # constant instance
+    "fast_model": lambda: {"mock": True},  # provider
+    "expensive": (lambda: object(), True), # provider with lazy=True
 })
 ```
 
@@ -191,7 +232,7 @@ c = init(app, overrides={
       * `key: (callable, lazy_bool)`
   * With `reuse=True`, re-calling `init(..., overrides=...)` applies new overrides to the cached container.
 
------
+---
 
 ## 11\) Interceptors (AOP & Lifecycle Hooks)
 
@@ -229,7 +270,7 @@ These implement the `ContainerInterceptor` protocol and hook into the container'
 
 **Registration:** Interceptors are discovered by the scanner during `init()` or `scope()`. There is no need to pass them manually. Their activation can be controlled with the same `@conditional` decorator and gates (`profiles`, `require_env`) used for other components.
 
------
+---
 
 ## 12\) Profiles & conditional providers
 
@@ -260,7 +301,7 @@ class InMemoryCache(Cache): ...
   * `predicate=callable` → must return a truthy value to activate.
   * If no active provider satisfies a required type and something depends on it → **bootstrap error** (fail fast).
 
------
+---
 
 ## 13\) Qualifiers & collection injection
 
@@ -271,7 +312,7 @@ Attach qualifiers to group/select implementations using `@qualifier`.
 
 This preserves registration order and returns a stable list.
 
------
+---
 
 ## 14\) Plugins
 
@@ -285,7 +326,7 @@ This preserves registration order and returns a stable list.
 
 Plugins are passed **explicitly** via `init(..., plugins=(MyPlugin(),))`. Prefer **interceptors** for fine-grained wiring events; use **plugins** for coarse lifecycle integration.
 
------
+---
 
 ## 15\) Scoped subgraphs (`scope`)
 
@@ -320,7 +361,7 @@ Providers may carry `tags` (via `@component(tags=...)` or `@provides(..., tags=.
 
 **Use cases:** fast unit tests, integration-lite, CLI tools, microbenchmarks.
 
------
+---
 
 ## 16\) Diagnostics & diagrams
 
@@ -371,7 +412,7 @@ flowchart TD
     G --> Z
 ```
 
------
+---
 
 ## 17\) Rationale & trade-offs
 
@@ -381,7 +422,7 @@ flowchart TD
   * **Fail fast**: configuration and graph issues surface at startup, not mid-request.
   * **Interceptors over AOP**: precise, opt-in hooks without full-blown aspect weavers.
 
------
+---
 
 **TL;DR**
-`pico-ioc` builds a **deterministic, typed dependency graph** from decorated components, factories, and interceptors. It resolves by **type** (with qualifiers and collections), memoizes **singletons**, supports **overrides**, **plugins**, **conditionals/profiles**, and **scoped subgraphs**—keeping wiring **predictable, testable, and framework-agnostic**.
+`pico-ioc` builds a **deterministic, typed dependency graph** from decorated components, factories, and interceptors. It resolves by **type** (with qualifiers and collections), memoizes **singletons**, supports **type-safe configuration injection**, **overrides**, **plugins**, **conditionals/profiles**, and **scoped subgraphs**—keeping wiring **predictable, testable, and framework-agnostic**.

{pico_ioc-1.3.0 → pico_ioc-1.4.0}/.llm/DECISIONS.md

@@ -131,6 +131,17 @@ A true "last-wins" only occurs when binding the *exact same key* multiple times,
 
 ---
 
+### 15) Configuration Injection
+**Decision**: Provide `@config_component` for strongly typed configuration classes, populated from ordered `ConfigSource`s (`EnvSource`, `FileSource`, etc.).  
+**Rationale**: Type-safe configuration with minimal boilerplate, supporting both automatic autowiring by field name and manual overrides (`Env`, `File`, `Path`, `Value`).  
+**Implications**:
+- Precedence is explicit: `overrides` > sources (in order) > field defaults.
+- Missing required fields (no default and not resolvable) raise `NameError`.
+- Supported formats: env vars, JSON, INI, dotenv, YAML (if available).
+- Encourages using `dataclass(frozen=True)` for immutable, validated settings.
+
+---
+
 ## ❌ Won’t-Do Decisions
 
 ### A) Alternative scopes (request/session)

pico_ioc-1.4.0/.llm/GUIDE-CONFIGURATION-INJECTION.md

@@ -0,0 +1,129 @@
+# GUIDE-CONFIGURATION-INJECTION
+
+`pico-ioc` includes a powerful and flexible configuration injection system that allows you to decouple your application's configuration in a type-safe way. You can load values from environment variables, files (YAML, JSON, INI, .env), and more.
+
+## 1\. Basic Concepts
+
+Configuration injection is built on three pillars:
+
+1.  **`@config_component`**: A decorator to mark a class (preferably a `dataclass`) that will hold your configuration values.
+2.  **`ConfigSource`**: Objects that tell `pico-ioc` *where* to find configuration values (e.g., `EnvSource` for environment variables, `FileSource` for files).
+3.  **The `config` parameter in `pico.init()`**: An ordered tuple of `ConfigSource`s. The first source that contains a key wins.
+
+## 2\. Basic Usage: Autowiring
+
+In the most common use case, `pico-ioc` can populate the fields of your configuration class automatically.
+
+#### Step 1: Define Your Configuration Class
+
+Use `@config_component` and, optionally, a prefix for environment variables.
+
+```python
+# in settings.py
+from dataclasses import dataclass
+from pico_ioc import config_component
+
+@config_component(prefix="APP_")
+@dataclass(frozen=True)
+class Settings:
+    # Will look for APP_DB_URL or DB_URL in the environment, or db_url in files.
+    db_url: str
+
+    # Will look for APP_TIMEOUT or TIMEOUT, or timeout in files.
+    timeout: int = 10  # Default value if not found in any source
+
+    # Will look for APP_DEBUG or DEBUG, or debug in files.
+    debug: bool = False
+```
+
+#### Step 2: Provide the Sources on Initialization
+
+Imagine you have these files:
+
+**`config.yml`**
+
+```yaml
+db_url: "postgresql://user:pass@host:5432/prod_db"
+timeout: 30
+```
+
+**Environment Variables**
+
+```shell
+export APP_DEBUG=true
+export APP_DB_URL="postgresql://user:pass@host:5432/env_db"
+```
+
+Now, initialize the container, specifying the priority order of the sources.
+
+```python
+# in main.py
+from pico_ioc import init
+from pico_ioc.config import EnvSource, FileSource
+from .settings import Settings
+
+container = init(
+    __name__,
+    config=(
+        # 1. First, look in environment variables with the "APP_" prefix
+        EnvSource(prefix="APP_"),
+        
+        # 2. If not found, look in config.yml
+        FileSource("config.yml"),
+    ),
+)
+
+# Request your configuration like any other component!
+settings = container.get(Settings)
+
+print(f"Database URL: {settings.db_url}") # -> postgresql://user:pass@host:5432/env_db (from environment)
+print(f"Timeout: {settings.timeout}")     # -> 30 (from file, as it's not in the environment)
+print(f"Debug: {settings.debug}")       # -> True (from environment)
+```
+
+## 3\. Advanced Usage: Manual Field Overrides
+
+Sometimes, the field name in your class doesn't match the key in the configuration source, or you need more granular control. For that, you can use the `Env`, `File`, `Path`, and `Value` helpers.
+
+```python
+from dataclasses import dataclass
+from pico_ioc import config_component
+from pico_ioc.config import Env, File, Path, Value
+
+@config_component
+@dataclass(frozen=True)
+class AdvancedSettings:
+    # 1. Only look in environment variables with a specific name
+    api_key: str = Env["THIRD_PARTY_API_KEY"]
+
+    # 2. Only look for a top-level key in files
+    pool_size: int = File["database.pool.size", 10] # With a default value
+
+    # 3. Look for a nested path within a structured file (YAML/JSON)
+    #    Will look in config.yml -> services -> auth -> url
+    auth_service_url: str = Path.file["services.auth.url"]
+
+    # 4. Control the source order for a specific field
+    #    For this field, the file has precedence over the environment.
+    region: str = Value["aws.region", sources=("file", "env"), default="eu-west-1"]
+```
+
+## 4\. Configuration Sources (`ConfigSource`)
+
+`pico-ioc` comes with two primary sources:
+
+  * `EnvSource(prefix: str = "")`: Reads from environment variables. The `prefix` is optional but recommended. It will look for `PREFIX_KEY` and then `KEY`.
+  * `FileSource(path: str, optional: bool = False)`: Reads from a file.
+      * **Supported formats**: Automatically detects YAML, JSON, INI, and `.env` (`KEY=VALUE` format).
+      * **`optional=True`**: If the file does not exist, it won't raise an error. This is very useful for environment-specific configuration files (e.g., `config.local.yml`).
+
+## 5\. Summary of Precedence Rules
+
+For a given configuration field, the value is resolved in the following order:
+
+1.  **Manual Override (`Env`, `File`, etc.)**: If used, its specific rules are followed.
+2.  **Automatic Lookup**:
+    1.  It searches in the **first `ConfigSource`** provided in the `config` tuple during `init()`.
+    2.  If not found, it checks the **second `ConfigSource`**, and so on.
+3.  **Python Default Value**: If the value is not found in any source, the default value defined in the class is used (e.g., `timeout: int = 10`).
+4.  **Error**: If the value isn't found in any source and the field has no default, `pico-ioc` will raise a `NameError` when trying to create the instance. Fail-fast\!

{pico_ioc-1.3.0 → pico_ioc-1.4.0}/.llm/GUIDE.md

@@ -116,9 +116,12 @@ if __name__ == "__main__":
 
 -----
 
-## 4\) Configuration patterns
+## 4) Configuration patterns
 
-**Env-backed config:**
+You can either hardcode config with `os.getenv` **or** use the new
+**configuration injection system** for type-safe settings.
+
+### 4.1 Env-backed config (manual)
 
 ```python
 import os
@@ -130,15 +133,42 @@ class Config:
     DEBUG: bool = os.getenv("DEBUG", "0") == "1"
 ```
 
+### 4.2 Config injection (recommended)
+
+```python
+from dataclasses import dataclass
+from pico_ioc import config_component
+from pico_ioc.config import EnvSource, FileSource
+
+@config_component(prefix="APP_")
+@dataclass(frozen=True)
+class Settings:
+    db_url: str
+    timeout: int = 10
+    debug: bool = False
+
+# main.py
+from pico_ioc import init
+container = init(
+    __name__,
+    config=(EnvSource(prefix="APP_"), FileSource("config.json")),
+)
+settings = container.get(Settings)
+```
+
+* Supports **Env**, **File** (YAML/JSON/INI/dotenv), dotted `Path.file[...]`,
+  and per-field overrides.
+* Precedence: `overrides` > sources (in order) > class defaults.
+* Missing required fields raise `NameError`.
+
 **Inject into consumers:**
 
 ```python
 @component
 class Runner:
-    def __init__(self, cfg: Config):
-        self._debug = cfg.DEBUG
+    def __init__(self, s: Settings):
+        self._debug = s.debug
 ```
-
 -----
 
 ## 5\) Testing & overrides

pico_ioc-1.4.0/.llm/OVERVIEW.md

@@ -0,0 +1,167 @@
+# 📦 pico-ioc — Overview
+
+## 🎯 Mission
+
+**pico-ioc’s mission is to simplify dependency management and accelerate development by shortening feedback loops.** It gives Python projects a tiny, predictable IoC container that removes boilerplate wiring, making apps easier to test, extend, and run.
+
+> ⚠️ **Requires Python 3.10+** (relies on `typing.Annotated` and `include_extras=True`).
+
+---
+
+## 🔍 What is pico-ioc?
+
+pico-ioc is a **minimal Inversion of Control (IoC) and Dependency Injection (DI) container for Python**.
+
+  - **Zero dependencies** → pure Python, framework-agnostic.
+  - **Decorator API** → `@component`, `@factory_component`, `@provides`, `@plugin`.
+  - **Type-safe Configuration** → `@config_component` classes are auto-populated from environment variables and files (YAML, JSON, .env).
+  - **Automatic wiring** → resolves by: param name → exact type → MRO base → string key.
+  - **Fail-fast bootstrap** → eager by default; opt into `lazy=True` proxies.
+  - **Scoped subgraphs** → load only what you need with `scope(...)`.
+  - **Overrides** → replace providers directly in `init(overrides={...})`.
+  - **Qualifiers & collections** → tag/group implementations; inject `list[Annotated[T, Q]]`.
+  - **Interceptors API** → observe/modify resolution, instantiation, invocation, errors.
+  - **Conditional providers** → enable components by env vars or predicates (profiles).
+  - **Plugins** → lifecycle hooks (`before_scan`, `after_ready`).
+  - **Thread/async safe** → isolation via `ContextVar`.
+  - **Public API helper** → auto-export decorated symbols, cleaner `__init__.py`.
+
+In short: **a Spring-like container for Python — tiny, predictable, and test-oriented.**
+
+---
+
+## ⚡ Example: Hello Service
+
+```python
+from pico_ioc import component, config_component, init
+
+# This class is now populated from env vars or files (e.g., config.yml)
+@config_component
+class Config:
+    url: str = "sqlite:///demo.db" # Default value
+
+@component
+class Repo:
+    def __init__(self, config: Config):
+        self.url = config.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
+import myapp
+from pico_ioc.config import EnvSource
+
+# The container will build the Config object from environment variables
+c = init(myapp, config=(EnvSource(),))
+svc = c.get(Service)
+print(svc.run())
+```
+
+**Output:**
+
+```
+fetching from sqlite:///demo.db
+```
+
+---
+
+## 🚀 Why pico-ioc?
+
+  * **Less glue code** — no manual wiring.
+  * **Predictable lifecycle** — fail early, debug easily.
+  * **Test-friendly** — overrides & scoped subgraphs make mocking trivial.
+  * **Externalized Configuration** — Manage settings for different environments without code changes.
+  * **Universal** — works with Flask, FastAPI, CLIs, or scripts.
+  * **Extensible** — logging, metrics, tracing via interceptors or plugins.
+  * **Profiles** — conditionals let you switch implementations by env/config.
+
+---
+
+## 🧪 Testing patterns
+
+Replace providers quickly in tests:
+
+```python
+from pico_ioc import init
+import myapp
+
+fake = {"repo": "fake-data"}
+c = init(myapp, overrides={
+    "fast_model": fake,             # constant
+    "user_service": lambda: {"id": 1},  # provider
+})
+assert c.get("fast_model") == {"repo": "fake-data"}
+```
+
+Or use `scope()` to build only a subgraph:
+
+```python
+from pico_ioc import scope
+from src.runner_service import RunnerService
+from tests.fakes import FakeDocker
+import src
+
+c = scope(
+    modules=[src],
+    roots=[RunnerService],
+    overrides={"docker.DockerClient": FakeDocker()},
+    strict=True, lazy=True,
+)
+svc = c.get(RunnerService)
+```
+
+---
+
+## 📦 Public API Helper
+
+Instead of manual exports in `__init__.py`:
+
+```python
+# app/__init__.py
+from pico_ioc.public_api import export_public_symbols_decorated
+__getattr__, __dir__ = export_public_symbols_decorated("app", include_plugins=True)
+```
+
+This auto-exposes:
+
+  * All `@component` and `@factory_component` classes
+  * All `@plugin` classes (if `include_plugins=True`)
+  * Any symbols in `__all__`
+
+So you can import cleanly:
+
+```python
+from app import Service, Config, TracingPlugin
+```
+
+---
+
+## 📖 Documentation
+
+  * **🚀 New to pico-ioc? Start with the User Guide.**
+
+      * [**GUIDE.md**](GUIDE.md) — Learn with practical examples: testing, configuration, collection injection, and web framework integration.
+
+  * **⚙️ Feature & Pattern Guides**
+
+      * [**Guide: Configuration Injection**](GUIDE-CONFIGURATION-INJECTION.md) — A deep dive into the type-safe configuration system.
+      * [**Guide: Creating Plugins and Interceptors**](GUIDE_CREATING_PLUGINS_AND_INTERCEPTORS.md) — Learn how to extend pico-ioc with custom logic.
+      * [**Pattern: Implementing a CQRS Command Bus**](GUIDE_CQRS.md) — An example of building clean architectures with pico-ioc.
+
+  * **🏗️ Want to understand the internals? See the Architecture.**
+
+      * [**ARCHITECTURE.md**](ARCHITECTURE.md) — A deep dive into the algorithms, lifecycle, and internal diagrams. Perfect for contributors.
+
+  * **🤔 Want to know *why* it's designed this way? Read the Decisions.**
+
+  * [**DECISIONS.md**](DECISIONS.md) — The history and rationale behind key technical decisions.
+
+  * [Readme](../README.md) — readme.md file.
+
+  * [Changelog](../CHANGELOG.md) — release history.
+  

{pico_ioc-1.3.0 → pico_ioc-1.4.0}/CHANGELOG.md

@@ -73,11 +73,8 @@ These were evaluated and **rejected** to keep pico-ioc simple, deterministic, an
 
 ## [1.3.0] — 2025-09-14
 
-### 💥 Breaking Changes
-- **Interceptor API Rework**: The interceptor registration mechanism has been completely changed. The `interceptors` and `method_interceptors` parameters have been **removed** from `pico_ioc.init()` and `pico_ioc.scope()`. Interceptors are now discovered and registered automatically.
-
 ### ✨ New
-- **`@interceptor` Decorator**: Interceptors are now declared in-place using the `@interceptor` decorator on a class or a provider method. The scanner discovers and activates them automatically based on their metadata (`kind`, `order`, `profiles`, etc.). This simplifies the bootstrap process and co-locates cross-cutting concerns with their implementation.
+- **`@interceptor` Decorator**: Interceptors are declared in-place using the `@interceptor` decorator on a class or a provider method. The scanner discovers and activates them automatically based on their metadata (`kind`, `order`, `profiles`, etc.). This simplifies the bootstrap process and co-locates cross-cutting concerns with their implementation.
 
 - **Conditional providers**
   - `@conditional(require_env=("VAR",))` activates a component only if env vars are present.
@@ -90,6 +87,25 @@ These were evaluated and **rejected** to keep pico-ioc simple, deterministic, an
 
 ---
 
+## [1.4.0] — 2025-09-16
+
+### ✨ New
+- **Configuration Injection**
+  - Added `@config_component` for strongly typed settings classes.
+  - Supports environment variables and property files (YAML, JSON, INI, dotenv).
+  - Automatic field autowiring by name, with manual overrides (`Env`, `File`, `Path`, `Value`).
+  - Precedence: `overrides` > declared config sources > field defaults.
+  - Strict mode: missing required fields (no default and not resolvable) raise `NameError`.
+
+### 🧪 Testing
+- Added tests for precedence (env > file > default), dotted-path resolution, lazy instantiation, and required-field validation.
+
+
+### 📚 Docs
+- Added **GUIDE-CONFIGURATION-INJECTION.md** with examples for the new configuration injection system.
+
+---
+
 ## [Unreleased]
 - Upcoming improvements and fixes will be listed here.
 

{pico_ioc-1.3.0 → pico_ioc-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pico-ioc
-Version: 1.3.0
+Version: 1.4.0
 Summary: A minimalist, zero-dependency Inversion of Control (IoC) container for Python.
 Author-email: David Perez Cabrera <dperezcabrera@gmail.com>
 License: MIT License
@@ -221,6 +221,12 @@ tox
 
 ---
 
+## 📜 Overview
+
+See [OVERVIEW.md](.llm/OVERVIEW.md) Just need a quick summary?
+
+---
+
 ## 📜 Changelog
 
 See [CHANGELOG.md](./CHANGELOG.md) for version history.