wireup 2.8.0__tar.gz → 2.10.0__tar.gz

{wireup-2.8.0 → wireup-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wireup
-Version: 2.8.0
+Version: 2.10.0
 Summary: Python Dependency Injection Library
 Project-URL: Homepage, https://github.com/maldoinc/wireup
 Project-URL: Repository, https://github.com/maldoinc/wireup
@@ -47,39 +47,68 @@ Type-driven dependency injection for Python. Wireup is battle-tested in producti
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/wireup)](https://pypi.org/project/wireup/)
 [![PyPI - Version](https://img.shields.io/pypi/v/wireup)](https://pypi.org/project/wireup/)
 <br />
-[![Documentation](https://img.shields.io/badge/%F0%9F%93%9A%20-Documentation-3D9970)](https://maldoinc.github.io/wireup)
-[![Documentation](https://img.shields.io/badge/%E2%AD%90-Enjoying%20Wireup%3F%20Star%20on%20GitHub-3D9970)](https://maldoinc.github.io/wireup)
 
 </div>
 
+<p align="center">
+  <a href="#quick-start"><strong>Quick Start</strong></a> &middot;
+  <a href="https://maldoinc.github.io/wireup"><strong>Docs</strong></a> &middot;
+  <a href="https://maldoinc.github.io/wireup/latest/benchmarks/"><strong>Benchmarks</strong></a> &middot;
+  <a href="https://maldoinc.github.io/wireup/latest/migrate_to_wireup/"><strong>Migrate to Wireup</strong></a>
+</p>
+
+## Why Wireup?
+
+<table>
+<tr>
+<td align="center" valign="top" width="33%">
+<h3>🔁 Define Once, Use Anywhere</h3>
+Reuse the same application code in APIs, CLIs, workers, and scripts without rewriting your wiring.
+</td>
+<td align="center" valign="top" width="33%">
+<h3>✅ Correct by Default</h3>
+If the container starts, your dependency graph is valid. Wireup checks for missing or misconfigured dependencies to avoid surprises at runtime. See <a href="https://maldoinc.github.io/wireup/latest/what_wireup_validates/">What Wireup Validates</a>
+</td>
+<td align="center" valign="top" width="33%">
+<h3>🌐 Framework-Ready</h3>
+Native integrations for <strong>FastAPI</strong>, <strong>Django</strong>, <strong>Flask</strong>, <strong>Starlette</strong>, <strong>Celery</strong>, <strong>Click</strong>, <strong>Typer</strong>, and more.
+</td>
+</tr>
+<tr>
+<td align="center" valign="top">
+<h3>⚡ Zero-Overhead Handlers</h3>
+Resolve singleton constructor dependencies once at startup in <a href="https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/">FastAPI</a> and <a href="https://maldoinc.github.io/wireup/latest/integrations/aiohttp/class_based_handlers/">AIOHTTP</a> class-based handlers, not per request.
+</td>
+<td align="center" valign="top">
+<h3>🧩 Advanced Wiring</h3>
+Go beyond simple constructor injection with
+<a href="https://maldoinc.github.io/wireup/latest/reusable_bundles/">reusable bundles</a>,
+<a href="https://maldoinc.github.io/wireup/latest/lifetimes_and_scopes/">explicit scope context sharing</a>, and
+more using plain Python.
+</td>
+<td align="center" valign="top">
+<h3>🧪 Easy to test</h3>
+Override dependencies with context managers, keep tests isolated, and restore the original graph automatically.
+</td>
+</tr>
+</table>
+
+## Benchmarks
 
 <p align="center">
     <picture>
     <source media="(prefers-color-scheme: dark)" srcset="docs/pages/img/benchmarks_scoped_dark.svg">
     <source media="(prefers-color-scheme: light)" srcset="docs/pages/img/benchmarks_scoped_light.svg">
-    <img alt="Scoped Dependency Injection Performance" src="docs/pages/img/benchmarks_scoped_light.svg">
+    <img alt="Scoped Dependency Injection Performance" src="docs/pages/img/benchmarks_scoped_light.svg" height="300">
     </picture>
 </p>
 
 <p align="center">
-    <i>Inject a dense dependency graph in FastAPI + Uvicorn on every request<br>
-    (Requests per second, higher is better. Manual Wiring represents the upper bound.).<br>
+    <i>Dense dependency graph resolved per request in FastAPI + Uvicorn<br>
+    (Requests per second, higher is better. Manual Wiring represents the upper bound.)<br>
     Full methodology and reproducibility: <a href="https://maldoinc.github.io/wireup/latest/benchmarks/">benchmarks</a>.</i>
 </p>
 
-
-
-> [!TIP]
-> **New**: Inject singleton dependencies in FastAPI with zero overhead using [Class-Based Handlers](https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/).
-## Why Wireup?
-
-- **Correct by default**: Wireup catches missing dependencies, circular references, lifetime mismatches, duplicate registrations, and missing config keys at startup. Shared dependencies are created in a thread-safe way.
-- **Define once, inject anywhere**: reuse the same service layer in APIs, CLIs, workers, and scripts.
-- **Framework-ready**: native integrations for **FastAPI**, **Flask**, **Django**, **Starlette**, **AIOHTTP**, **ASGI**, **FastMCP**, **Celery**, **Click**, **Typer**, and **Strawberry**. [See Integrations](https://maldoinc.github.io/wireup/latest/integrations).
-- **Startup-resolved constructor injection for [FastAPI](https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/) and [AIOHTTP](https://maldoinc.github.io/wireup/latest/integrations/aiohttp/class_based_handlers/) handlers**: constructor dependencies are resolved once at startup, not per request. [FastAPI class-based handlers](https://maldoinc.github.io/wireup/latest/integrations/fastapi/class_based_handlers/).
-- **Test overrides with context managers**: replace any injectable for a test scope and restore automatically. [See testing docs](https://maldoinc.github.io/wireup/latest/testing/).
-- **Reusable sub-graphs**: run multiple configured instances of the same dependency graph without spinning up separate containers. [See reusable factory bundles](https://maldoinc.github.io/wireup/latest/factories/#reusable-factory-bundles).
-
 ## Installation
 
 ```bash
@@ -87,13 +116,20 @@ pip install wireup
 ```
 
 
-## Complete Example
+## Quick Start
 
 ```python
+import fastapi
+import wireup
+import wireup.integration.fastapi
+from wireup import Injected, injectable
+
+
 @injectable
 class Database:
     def query(self, sql: str) -> list[str]: ...
 
+
 @injectable
 class UserService:
     def __init__(self, db: Database) -> None:
@@ -102,56 +138,29 @@ class UserService:
     def get_users(self) -> list[str]:
         return self.db.query("SELECT name FROM users")
 
+
 app = fastapi.FastAPI()
 
+
 @app.get("/users")
 def get_users(service: Injected[UserService]) -> list[str]:
     return service.get_users()
 
+
 container = wireup.create_async_container(injectables=[Database, UserService])
 wireup.integration.fastapi.setup(container, app)
 ```
 
-For a fully working end-to-end walkthrough, see the [Getting Started guide](https://maldoinc.github.io/wireup/latest/getting_started/).
-
-## Features
-
-### ⚡ Clean & Type-Safe DI
-
-Use decorators and annotations for concise, co-located definitions, or factories to keep your domain model pure and decoupled.
-
-**1. Basic Usage**
-
-Register classes with `@injectable` and let the container resolve dependencies automatically.
+For a full end-to-end walkthrough, start with the [Getting Started guide](https://maldoinc.github.io/wireup/latest/getting_started/).
 
-```python
-@injectable
-class Database:
-    def __init__(self) -> None:
-        self.engine = sqlalchemy.create_engine("sqlite://")
-
-@injectable
-class UserService:
-    def __init__(self, db: Database) -> None:
-        self.db = db
-
-container = wireup.create_sync_container(injectables=[Database, UserService])
-
-# Inject via framework integration or @inject_from_container (recommended)
-@app.get("/users")
-def get_users(service: Injected[UserService]) -> list[str]: ...
+## Basic Usage
 
-# Or resolve directly for advanced use cases (middleware, startup, scripts)
-user_service = container.get(UserService)
-```
+Wireup also supports config injection, decorator-free domain models, and package-level registration.
 
-**2. Inject Configuration**
+**1. Inject Configuration**
 
 Inject configuration alongside dependencies. No need to write factories just to pass a config value.
 
-<details>
-<summary>View Code</summary>
-
 ```python
 @injectable
 class Database:
@@ -164,9 +173,7 @@ container = wireup.create_sync_container(
 )
 ```
 
-</details>
-
-**3. Clean Architecture**
+**2. Clean Architecture**
 
 Need strict boundaries? Use factories to wire pure domain objects and integrate external libraries like Pydantic.
 
@@ -194,12 +201,9 @@ def make_database(settings: Settings) -> Database:
 container = wireup.create_sync_container(injectables=[make_settings, make_database])
 ```
 
-**4. Auto-Discover**
+**3. Package-level registration**
 
-No need to list every injectable manually. Scan entire modules or packages to register all at once. This is the recommended default for larger applications.
-
-<details>
-<summary>View Code</summary>
+No need to list every injectable manually. Provide entire modules or packages to register all at once.
 
 ```python
 import app
@@ -214,11 +218,11 @@ container = wireup.create_sync_container(
 )
 ```
 
-</details>
+## More Features
 
 ### 🎯 Function Injection
 
-Inject dependencies into any function. CLI commands, background tasks, event handlers, or any standalone function that needs container access.
+Inject dependencies into CLI commands, background tasks, event handlers, or any standalone function that needs container access.
 
 ```python
 @inject_from_container(container)
@@ -228,7 +232,7 @@ def migrate_database(db: Injected[Database], settings: Injected[Settings]) -> No
 
 ### 📝 Interfaces & Abstractions
 
-Depend on abstractions, not implementations. Bind implementations to interfaces using Protocols or ABCs.
+Bind implementations to interfaces using Protocols or ABCs.
 
 ```python
 class Notifier(Protocol):
@@ -238,17 +242,16 @@ class Notifier(Protocol):
 class SlackNotifier:
     def notify(self) -> None: ...
 
-container = create_sync_container(injectables=[SlackNotifier])
-
 # SlackNotifier is injected wherever Notifier is requested
 @app.post("/notify")
 def send_notification(notifier: Injected[Notifier]) -> None:
     notifier.notify()
 ```
 
-### 🏭 Flexible Creation Patterns
+### 🏭 Factories & Resources
 
-Defer instantiation to factories when initialization or cleanup is non-trivial. Full support for sync, async, and generator factories. Wireup handles cleanup at the right time based on lifetime.
+Defer instantiation to specialized factories when complex initialization or cleanup is required. 
+Full support for sync, async, and generator factories. Wireup handles cleanup at the right time based on lifetime.
 
 ```python
 class WeatherClient:
@@ -278,9 +281,9 @@ async def weather_client_factory() -> AsyncIterator[WeatherClient]:
 </details>
 
 
-### 🔄 Managed Lifetimes
+### 🔄 Lifetimes & Scopes
 
-Declare dependencies as singleton, scoped, or transient to control instance reuse.
+Declare dependencies as `singleton`, `scoped`, or `transient` to control reuse explicitly.
 
 ```python
 # Singleton: one instance per application (default)
@@ -306,36 +309,9 @@ class OrderProcessor:
     pass
 ```
 
-
-### ❓ Optional Dependencies
-
-First-class support for `Optional[T]` and `T | None`.
-
-```python
-@injectable
-def make_cache(settings: Settings) -> RedisCache | None:
-    return RedisCache(settings.redis_url) if settings.cache_enabled else None
-
-@injectable
-class UserService:
-    def __init__(self, cache: RedisCache | None) -> None:
-        self.cache = cache
-
-# Retrieve optional dependencies directly when needed
-cache = container.get(RedisCache | None)
-```
-
-### 🧩 Reusable sub-graphs
-
-Need to register multiple sub-graphs with different settings (e.g. primary + analytics DB)?
-
-Wireup supports this natively without requiring a dedicated provider class or a separate container. 
-See [Reusable Factory Bundles](https://maldoinc.github.io/wireup/latest/factories/#reusable-factory-bundles).
-
-
 ### 🛡️ Startup Validation
 
-Wireup validates the entire dependency graph when the container is created.
+Wireup validates the dependency graph when the container is created. See <a href="https://maldoinc.github.io/wireup/latest/what_wireup_validates/">What Wireup Validates</a> for the full rules and limits.
 
 ```python
 # Missing dependencies: caught at startup, not at runtime
@@ -347,76 +323,25 @@ container = wireup.create_sync_container(injectables=[Foo])
 # ❌ Parameter 'unknown' of 'Foo' depends on an unknown injectable 'NotManagedByWireup'.
 ```
 
-```python
-container = wireup.create_sync_container(injectables=[])
+It also catches circular dependencies, duplicate registrations, misconfigured lifetimes, and missing config at startup.
 
-# Decorated functions validated at import time
-@inject_from_container(container)
-def my_function(oops: Injected[NotManagedByWireup]): ...
-# ❌ Parameter 'oops' of 'my_function' depends on an unknown injectable 'NotManagedByWireup'.
+### 🧪 Testing
 
-```
-
-```python
-# Missing config keys caught at startup
-@injectable
-class Database:
-    def __init__(self, url: Annotated[str, Inject(config="db_url")]) -> None: ...
-
-container = wireup.create_sync_container(injectables=[Database], config={})
-# ❌ Parameter 'url' of Type 'Database' depends on an unknown Wireup config key 'db_url'.
-```
-
-Additional checks: circular dependencies, lifetime mismatches (e.g. singleton depending on scoped), and duplicate registrations.
-
-### 📍 Framework Independent
-
-Define your service layer once. Run it anywhere.
-
-```python
-# Define once
-# injectables = [UserService, Database, ...]
-
-# FastAPI (native integration, no extra decorator needed)
-@app.get("/users")
-async def view(service: Injected[UserService]): ...
-
-# Click
-@click.command()
-def command(service: Injected[UserService]): ...
-
-# Use @inject_from_container to inject dependencies into any function.
-# Most useful for scripts or when no Wireup integration is available.
-@inject_from_container(container)
-def run_worker(service: Injected[UserService]): ...
-```
-
-Have a useful integration to recommend? Create an issue or PR!
-
-
-### 🔌 Framework Integrations
-
-Native integrations manage request scopes, endpoint injection, and dependency lifetimes.
-
-Supported: **FastAPI**, **Flask**, **Django**, **AIOHTTP**, **Starlette**, **Click**, **Typer**, **Strawberry**
-
-[View all integrations →](https://maldoinc.github.io/wireup/latest/integrations/)
-
-### 🧪 Simplified Testing
-
-Wireup decorators only collect metadata. Injectables are plain classes and functions. Test them directly with no special setup.
+Wireup decorators only collect metadata. Injectables are plain classes and functions, so you can test them directly with no special setup.
 
 Swap dependencies during tests with `container.override`:
 
 ```python
 with container.override.injectable(target=Database, new=in_memory_database):
-    # All code that depends on Database will receive in_memory_database
+    # Injectables that depend on Database will receive in_memory_database
     # for the duration of this context manager
     response = client.get("/users")
 ```
 
 ## 📚 Documentation
 
+See the docs for integrations, lifetimes, factories, testing, and more advanced patterns.
+
 [https://maldoinc.github.io/wireup](https://maldoinc.github.io/wireup)
 
-If Wireup helps your team move faster, consider starring the repo to help more Python developers discover it.
+If Wireup is useful to you, a star on GitHub helps others find it.

{wireup-2.8.0 → wireup-2.10.0}/docs/mkdocs.yml

@@ -9,15 +9,20 @@ nav:
       - Container: container.md
       - Injectables: injectables.md
       - Configuration: configuration.md
-    - Advanced Features:
+    - Features:
       - Lifetimes & Scopes: lifetimes_and_scopes.md
       - Factories: factories.md
       - Resource Management: resources.md
       - Interfaces: interfaces.md
       - Function Injection: function_injection.md
+    - Advanced Patterns:
+      - Reusable Bundles: reusable_bundles.md
+      - Conditional Registration: conditional_registration.md
+      - Generic Dependencies: generic_dependencies.md
     - Guides:
+      - Packaging Injectables: packaging_injectables.md
       - Testing: testing.md
-      - Conditional Registration: conditional_registration.md
+      - What Wireup Validates: what_wireup_validates.md
       - Upgrading: upgrading.md
       - Versioning: versioning.md
 
@@ -28,7 +33,7 @@ nav:
         - Django Integration: integrations/django/index.md
         - Setup and Installation: integrations/django/setup.md
         - Inject in Views: integrations/django/view_injection.md
-        - Request Lifecycle Patterns: integrations/django/request_lifecycle_patterns.md
+        - Request-Time Injection: integrations/django/request_time_injection.md
         - App-Level Injection: integrations/django/app_injection.md
         - Django Testing: integrations/django/testing.md
         - Troubleshooting: integrations/django/troubleshooting.md
@@ -37,7 +42,7 @@ nav:
         - Inject in Routes: integrations/fastapi/inject_in_routes.md
         - Request and WebSocket Context in Services: integrations/fastapi/context_in_services.md
         - Class Based Handlers: integrations/fastapi/class_based_handlers.md
-        - Request Lifecycle Patterns: integrations/fastapi/request_lifecycle_patterns.md
+        - Request-Time Injection: integrations/fastapi/request_time_injection.md
         - Background Tasks: integrations/fastapi/background_tasks.md
         - FastAPI Testing: integrations/fastapi/testing.md
         - Troubleshooting: integrations/fastapi/troubleshooting.md

wireup-2.10.0/docs/overrides/main.html

@@ -0,0 +1,24 @@
+{% extends "base.html" %}
+
+{% block outdated %}
+You're not viewing the latest version.
+<a href="{{ '../' ~ base_url }}">
+
+  <strong>Click here to go to latest.</strong>
+</a>
+{% endblock %}
+
+{% block footer %}
+{{ super() }}
+<div class="md-footer">
+  <div class="md-footer-meta md-typeset">
+    <div class="md-footer-meta__inner md-grid">
+      <div class="md-copyright">
+        If Wireup is useful to you,
+        <a href="https://github.com/maldoinc/wireup" target="_blank" rel="noopener">a ⭐ on GitHub helps others find
+          it.</a>.
+      </div>
+    </div>
+  </div>
+</div>
+{% endblock %}

{wireup-2.8.0 → wireup-2.10.0}/docs/pages/benchmarks.md

@@ -25,20 +25,20 @@ This benchmark uses an artificial workload to measure the overhead of the depend
 services, the test focuses on how fast the library can resolve and inject dependencies without the results being hidden
 by application logic.
 
-Testing is done within a FastAPI + Uvicorn environment to measure performance in a realistic web-based environment
+Testing is done within a FastAPI + Uvicorn environment to measure performance in a realistic web-based environment.
 Notably, this also allows for the inclusion of `fastapi.Depends` in the comparison, 
 as it is the most popular choice by virtue of being the FastAPI default. 
 
 This setup tests also the overall dependency injection package of each library which includes container resolution, scoping,
 injecting into functions/route handlers as well as framework integration rather than a microbenchmark where 
-you repeatedly resolve dependencies from the raw container instance in a tight loop
+you repeatedly resolve dependencies from the raw container instance in a tight loop.
 This benchmark intentionally uses non-trivial singleton/scoped graphs to stress test the containers.
 
 The workload uses two separate, independent graphs:
 the singleton graph (`Settings -> A -> B`) and the scoped graph (`C -> I`) where each service depends on multiple others.
 H is a context manager, I is an async context manager.
 
-This graph is intentionally non-trivial: large enough to emulate realistic container behavior, but still representative of practical applications (rather than synthetic 100-node chains). The exact shape is less important than the workload characteristics: multiple dependencies and lifecycle-managed resources, which stress container resolution, scoping, and teardown more than a simple linear graph.
+This graph is intentionally non-trivial: large enough to emulate realistic container behavior, but still representative of practical applications (rather than 100-node chains). The exact shape is less important than the workload characteristics: multiple dependencies and lifecycle-managed resources, which stress container resolution, scoping, and teardown more than a simple linear graph.
 
 ??? "Click to view the graphs"
 
@@ -99,8 +99,8 @@ For each run, the server is started, a liveness probe must pass, warmup traffic
 Actual requests per second (RPS) will change based on your hardware. The most important metric is how the libraries
 perform relative to each other.
 
-**Globals** represents the theoretical maximum performance. In this setup, services are accessed directly from the
-global scope or manually instantiated within the route handler, bypassing DI containers entirely.
+**Manual Wiring (No DI)** represents the theoretical maximum performance. In this setup, services are manually instantiated
+within the route handler, bypassing DI containers entirely.
 This row exists purely to establish an upper bound on DI overhead, not as an endorsement of global state or manual wiring.
 
 **Wireup Class-Based** represents the performance of Wireup when using the
@@ -120,6 +120,7 @@ The benchmark measures the following:
     performance with fewer outliers. **Lower is better.**
 - **RSS Memory Peak (MB)**: The highest post-iteration RSS sample observed across runs. **Lower is better.**
     This includes the full server process footprint (Uvicorn + FastAPI app + framework runtime), not only service objects.
+    Summary percentages and relative-throughput comparisons on this page are computed from the main Median Run tables, not the Stability or Total Time tables.
 
 ### Hardware Environment
 
@@ -265,7 +266,7 @@ and Settings** from the graph.
 This tests the container's bookkeeping performance and how efficiently it can return existing instances.
 
 <!-- singleton-summary-start -->
-In this benchmark, both **Wireup Class-Based** (<!-- meta:singleton_wireup_cbr_pct -->**99.93%**<!-- /meta:singleton_wireup_cbr_pct -->) and **Wireup** (<!-- meta:singleton_wireup_pct -->**98.97%**<!-- /meta:singleton_wireup_pct -->) operate within measurement noise of manual wiring throughput, showing very small overhead vs globals in this workload.
+In this benchmark, both **Wireup Class-Based** (<!-- meta:singleton_wireup_cbr_pct -->**99.93%**<!-- /meta:singleton_wireup_cbr_pct -->) and **Wireup** (<!-- meta:singleton_wireup_pct -->**98.97%**<!-- /meta:singleton_wireup_pct -->) operate very close to manual wiring throughput, showing very small overhead vs manual wiring in this workload.
 For context, this corresponds to roughly <!-- meta:singleton_wireup_vs_fastapi_x -->**2.15x**<!-- /meta:singleton_wireup_vs_fastapi_x --> the throughput of **FastAPI Depends** and <!-- meta:singleton_wireup_vs_next_best_x -->**1.25x**<!-- /meta:singleton_wireup_vs_next_best_x --> the next closest library in this benchmark (**<!-- meta:singleton_next_best_name -->diwire<!-- /meta:singleton_next_best_name -->**).
 <!-- singleton-summary-end -->
 
@@ -337,8 +338,9 @@ Prerequisite:
 
 Run from repository root:
 
-
-`make bench`
+```bash
+make bench
+```
 
 Enable workload-shape assertions:
 

wireup-2.10.0/docs/pages/class/fastapi_integration.md

@@ -0,0 +1,8 @@
+## wireup.integration.fastapi
+
+::: wireup.integration.fastapi
+
+!!! note
+    For best performance with `WireupTask`, prefer regular top-level functions for background task callbacks.
+    Wireup creates cached injection wrappers for top-level functions, but callable objects and nested
+    functions/closures do not benefit from that caching.

wireup-2.10.0/docs/pages/class/starlette_integration.md

@@ -0,0 +1,8 @@
+## wireup.integration.flask
+
+::: wireup.integration.starlette
+
+!!! note
+    For best performance with `WireupTask`, prefer regular top-level functions for background task callbacks.
+    Wireup creates cached injection wrappers for top-level functions, but callable objects and nested
+    functions/closures do not benefit from that caching.

{wireup-2.8.0 → wireup-2.10.0}/docs/pages/conditional_registration.md

@@ -1,13 +1,11 @@
 # Conditional Registration
 
-Wireup does not own your registration strategy. It only consumes whatever you pass in `injectables=[...]`.
+Wireup does not use a special syntax for conditional registration. Build the `injectables` list in normal Python based
+on environment, feature flags, or deployment mode, then pass the final list to the container.
 
-That means you can build the list yourself based on environment, feature flags, or deployment mode, then hand the final
-list to Wireup.
+Wireup still validates the final graph when the container is created.
 
-Once the container is created, Wireup runs the same startup validation guarantees on the final graph.
-
-## Bundle + If Pattern
+## Bundle + If Statements
 
 Use small bundle functions (or constants) and compose them with normal Python `if` statements.
 
@@ -74,35 +72,7 @@ else:
 container = wireup.create_sync_container(injectables=injectables)
 ```
 
-## Single Dependency Swap: Mailer
-
-For one-off swaps, keep it simple and choose one injectable with a plain `if`:
-
-```python
-import os
-import wireup
-
-from my_app.services import UserService
-from my_app.mail.dev_mailer import ConsoleMailer
-from my_app.mail.prod_mailer import SesMailer
-
-env = os.getenv("APP_ENV", "dev")
-
-injectables = [UserService]
-
-if env == "prod":
-    injectables.append(SesMailer)
-else:
-    injectables.append(ConsoleMailer)
-
-container = wireup.create_sync_container(injectables=injectables)
-```
-
-## Why Use This Pattern
 
-* No new DSL to learn. Registration composition stays pure Python.
-* Composition stays explicit and local to app bootstrap.
-* Wireup remains environment-agnostic.
-* Validation still happens at startup for the graph you actually run.
+## Next Steps
 
-For reusable sub-graphs with runtime parameters, see [Factories: Reusable Factory Bundles](factories.md#reusable-factory-bundles).
+For cases where the same injectables need to be registered more than once with different settings, see [Reusable Bundles](reusable_bundles.md).