urich 0.1.0__tar.gz

urich-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Korolev Roman Urich
+
+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.

urich-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: urich
+Version: 0.1.0
+Summary: Async DDD framework for microservices on Starlette
+Project-URL: Homepage, https://github.com/KashN9sh/urich
+Project-URL: Repository, https://github.com/KashN9sh/urich
+Keywords: asgi,ddd,microservices,starlette,cqrs
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: starlette>=0.41.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+Requires-Dist: uvicorn; extra == "dev"
+Provides-Extra: cli
+Requires-Dist: typer>=0.9.0; extra == "cli"
+Dynamic: license-file
+
+# Urich
+
+Async DDD framework for microservices on Starlette. The application is composed from module objects via `app.register(module)` — similar to FastAPI with routers, but one consistent style for domain, events, RPC and discovery.
+
+## Idea
+
+- **One object = one building block:** DomainModule, EventBusModule, OutboxModule, DiscoveryModule, RpcModule. All configured via fluent API and attached with `app.register(module)`.
+- **DDD:** Bounded context as DomainModule with `.aggregate()`, `.repository()`, `.command()`, `.query()`, `.on_event()`. Commands and queries get HTTP routes automatically.
+- **No lock-in:** Protocols (EventBus, ServiceDiscovery, RpcTransport) in core; implementations (Redis, Consul, HTTP+JSON) supplied by the user or optional out-of-the-box adapters.
+
+## Install
+
+```bash
+pip install urich
+# CLI for generating skeletons:
+pip install "urich[cli]"
+```
+
+## Quick start
+
+```python
+from urich import Application
+from urich.ddd import DomainModule
+
+# One object = full bounded context
+from orders.module import orders_module
+
+app = Application()
+app.register(orders_module)
+
+# Run: python -m uvicorn main:app --reload  (or: pip install uvicorn && uvicorn main:app --reload)
+```
+
+Routes by convention: `POST /orders/commands/create_order`, `GET /orders/queries/get_order`.
+
+## OpenAPI / Swagger
+
+After registering all modules, call `app.openapi(title="My API", version="0.1.0")`. Then:
+
+- **GET /openapi.json** — OpenAPI 3.0 spec
+- **GET /docs** — Swagger UI
+
+```python
+app = Application()
+# ... app.register(module) ...
+app.openapi(title="My API", version="0.1.0")
+```
+
+## CLI
+
+```bash
+urich create-app myapp
+cd myapp
+urich add-context orders --dir .
+urich add-aggregate orders Order --dir .
+# In main.py: from orders.module import orders_module; app.register(orders_module)
+```
+
+## Module structure (DomainModule)
+
+- **domain** — aggregate (AggregateRoot), domain events (DomainEvent).
+- **application** — commands/queries (Command/Query), handlers (one per command/query).
+- **infrastructure** — repository interface and implementation (e.g. in-memory for prototypes).
+- **module.py** — one object `DomainModule("orders").aggregate(...).repository(...).command(...).query(...).on_event(...)`; register in the app with `app.register(orders_module)`.
+
+## Other modules
+
+- **EventBusModule** — `.adapter(impl)` or `.in_memory()`; in container as EventBus.
+- **OutboxModule** — `.storage(...)` and `.publisher(...)`; contracts in core.
+- **DiscoveryModule** — `.static({"svc": "http://..."})` or `.adapter(impl)`; ServiceDiscovery protocol.
+- **RpcModule** — `.server(path="/rpc")` and `.client(discovery=..., transport=...)`; optional JsonHttpRpcTransport (requires httpx).
+
+Full composition example: `examples/ecommerce/main.py`.

urich-0.1.0/README.md

@@ -0,0 +1,73 @@
+# Urich
+
+Async DDD framework for microservices on Starlette. The application is composed from module objects via `app.register(module)` — similar to FastAPI with routers, but one consistent style for domain, events, RPC and discovery.
+
+## Idea
+
+- **One object = one building block:** DomainModule, EventBusModule, OutboxModule, DiscoveryModule, RpcModule. All configured via fluent API and attached with `app.register(module)`.
+- **DDD:** Bounded context as DomainModule with `.aggregate()`, `.repository()`, `.command()`, `.query()`, `.on_event()`. Commands and queries get HTTP routes automatically.
+- **No lock-in:** Protocols (EventBus, ServiceDiscovery, RpcTransport) in core; implementations (Redis, Consul, HTTP+JSON) supplied by the user or optional out-of-the-box adapters.
+
+## Install
+
+```bash
+pip install urich
+# CLI for generating skeletons:
+pip install "urich[cli]"
+```
+
+## Quick start
+
+```python
+from urich import Application
+from urich.ddd import DomainModule
+
+# One object = full bounded context
+from orders.module import orders_module
+
+app = Application()
+app.register(orders_module)
+
+# Run: python -m uvicorn main:app --reload  (or: pip install uvicorn && uvicorn main:app --reload)
+```
+
+Routes by convention: `POST /orders/commands/create_order`, `GET /orders/queries/get_order`.
+
+## OpenAPI / Swagger
+
+After registering all modules, call `app.openapi(title="My API", version="0.1.0")`. Then:
+
+- **GET /openapi.json** — OpenAPI 3.0 spec
+- **GET /docs** — Swagger UI
+
+```python
+app = Application()
+# ... app.register(module) ...
+app.openapi(title="My API", version="0.1.0")
+```
+
+## CLI
+
+```bash
+urich create-app myapp
+cd myapp
+urich add-context orders --dir .
+urich add-aggregate orders Order --dir .
+# In main.py: from orders.module import orders_module; app.register(orders_module)
+```
+
+## Module structure (DomainModule)
+
+- **domain** — aggregate (AggregateRoot), domain events (DomainEvent).
+- **application** — commands/queries (Command/Query), handlers (one per command/query).
+- **infrastructure** — repository interface and implementation (e.g. in-memory for prototypes).
+- **module.py** — one object `DomainModule("orders").aggregate(...).repository(...).command(...).query(...).on_event(...)`; register in the app with `app.register(orders_module)`.
+
+## Other modules
+
+- **EventBusModule** — `.adapter(impl)` or `.in_memory()`; in container as EventBus.
+- **OutboxModule** — `.storage(...)` and `.publisher(...)`; contracts in core.
+- **DiscoveryModule** — `.static({"svc": "http://..."})` or `.adapter(impl)`; ServiceDiscovery protocol.
+- **RpcModule** — `.server(path="/rpc")` and `.client(discovery=..., transport=...)`; optional JsonHttpRpcTransport (requires httpx).
+
+Full composition example: `examples/ecommerce/main.py`.

urich-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "urich"
+version = "0.1.0"
+description = "Async DDD framework for microservices on Starlette"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "starlette>=0.41.0",
+    "pydantic>=2.0",
+]
+keywords = ["asgi", "ddd", "microservices", "starlette", "cqrs"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio", "httpx", "uvicorn"]
+cli = ["typer>=0.9.0"]
+
+[project.urls]
+Homepage = "https://github.com/KashN9sh/urich"
+Repository = "https://github.com/KashN9sh/urich"
+
+[project.scripts]
+urich = "urich.cli.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

urich-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

urich-0.1.0/src/urich/__init__.py

@@ -0,0 +1,13 @@
+"""
+Urich — async DDD framework for microservices.
+Application is composed from module objects via app.register(module).
+"""
+from urich.core import Application, Container, Module, HttpModule, Config
+
+__all__ = [
+    "Application",
+    "Container",
+    "Module",
+    "HttpModule",
+    "Config",
+]

urich-0.1.0/src/urich/cli/__init__.py

@@ -0,0 +1,3 @@
+from urich.cli.main import app
+
+__all__ = ["app"]

urich-0.1.0/src/urich/cli/main.py

@@ -0,0 +1,109 @@
+"""
+CLI for prototyping: create-app, add-context, add-aggregate.
+Generated code composes a DomainModule and registers via app.register(module).
+"""
+from pathlib import Path
+
+try:
+    import typer
+except ImportError:
+    typer = None  # type: ignore
+
+from urich.cli import templates as T
+
+app = typer.Typer(help="Urich CLI: create app and bounded context.")
+
+
+def _ensure_typer():
+    if typer is None:
+        raise SystemExit("CLI requires typer: pip install 'urich[cli]' or pip install typer")
+
+
+def _snake(name: str) -> str:
+    return "".join("_" + c.lower() if c.isupper() else c for c in name).lstrip("_")
+
+
+@app.command()
+def create_app(
+    name: str = typer.Argument(..., help="App name (folder)"),
+    directory: Path = typer.Option(Path("."), "--dir", "-d", help="Parent directory"),
+) -> None:
+    """Create app skeleton: folder, main.py, config.py."""
+    _ensure_typer()
+    root = directory / name
+    root.mkdir(parents=True, exist_ok=True)
+    (root / "main.py").write_text(T.MAIN_PY.format(first_context="orders"), encoding="utf-8")
+    (root / "config.py").write_text(
+        '"""Config (env/file)."""\n# from dataclasses import dataclass\n# settings = ...\n',
+        encoding="utf-8",
+    )
+    typer.echo(f"Created: {root}/ (main.py, config.py). Add context: urich add-context <name> --dir {root}")
+
+
+@app.command()
+def add_context(
+    name: str = typer.Argument(..., help="Bounded context name (e.g. orders)"),
+    directory: Path = typer.Option(Path("."), "--dir", "-d", help="App root directory"),
+) -> None:
+    """Add bounded context: folder with domain, application, infrastructure, module (skeleton)."""
+    _ensure_typer()
+    ctx_dir = directory / name
+    ctx_dir.mkdir(parents=True, exist_ok=True)
+    ctx_dir.joinpath("domain.py").write_text(
+        T.CONTEXT_SKELETON.format(context=name),
+        encoding="utf-8",
+    )
+    ctx_dir.joinpath("application.py").write_text(
+        T.CONTEXT_APPLICATION_SKELETON.format(context=name),
+        encoding="utf-8",
+    )
+    ctx_dir.joinpath("infrastructure.py").write_text(
+        T.CONTEXT_INFRASTRUCTURE_SKELETON.format(context=name),
+        encoding="utf-8",
+    )
+    ctx_dir.joinpath("module.py").write_text(
+        T.CONTEXT_MODULE_SKELETON.format(context=name),
+        encoding="utf-8",
+    )
+    typer.echo(f"Context «{name}»: {ctx_dir}/. Add aggregate: urich add-aggregate {name} <AggregateName> --dir {directory}")
+
+
+@app.command()
+def add_aggregate(
+    context: str = typer.Argument(..., help="Context name (folder)"),
+    aggregate: str = typer.Argument(..., help="Aggregate name (PascalCase, e.g. Order)"),
+    directory: Path = typer.Option(Path("."), "--dir", "-d", help="App root directory"),
+) -> None:
+    """Add aggregate to context: domain, application, infrastructure, module (DomainModule with command/query)."""
+    _ensure_typer()
+    ctx_dir = directory / context
+    if not ctx_dir.is_dir():
+        typer.echo(f"Context folder not found: {ctx_dir}. Run first: urich add-context {context} --dir {directory}", err=True)
+        raise typer.Exit(1)
+    agg_lower = _snake(aggregate)
+    ctx_dir.joinpath("domain.py").write_text(
+        T.DOMAIN_PY.format(context=context, aggregate=aggregate, aggregate_lower=agg_lower),
+        encoding="utf-8",
+    )
+    ctx_dir.joinpath("application.py").write_text(
+        T.APPLICATION_PY.format(context=context, aggregate=aggregate, aggregate_lower=agg_lower),
+        encoding="utf-8",
+    )
+    ctx_dir.joinpath("infrastructure.py").write_text(
+        T.INFRASTRUCTURE_PY.format(context=context, aggregate=aggregate, aggregate_lower=agg_lower),
+        encoding="utf-8",
+    )
+    ctx_dir.joinpath("module.py").write_text(
+        T.MODULE_PY.format(context=context, aggregate=aggregate, aggregate_lower=agg_lower),
+        encoding="utf-8",
+    )
+    typer.echo(f"Aggregate «{aggregate}» in «{context}»: {ctx_dir}/. In main.py: from {context}.module import {context}_module; app.register({context}_module)")
+
+
+def main() -> None:
+    """Entry point for the urich console command."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

urich-0.1.0/src/urich/cli/templates.py

@@ -0,0 +1,151 @@
+"""Skeleton templates for generating bounded context and aggregate."""
+
+DOMAIN_PY = '''"""Domain {context}: aggregate and events."""
+from dataclasses import dataclass
+from urich.domain import AggregateRoot, DomainEvent
+
+
+@dataclass
+class {aggregate}Created(DomainEvent):
+    """Event: {aggregate} created."""
+    {aggregate_lower}_id: str
+    # add fields
+
+
+class {aggregate}(AggregateRoot):
+    def __init__(self, id: str):
+        super().__init__(id=id)
+        self.raise_event({aggregate}Created({aggregate_lower}_id=id))
+'''
+
+APPLICATION_PY = '''"""Application layer: commands, queries, handlers."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urich.ddd import Command, Query
+from urich.domain import EventBus
+
+from .domain import {aggregate}, {aggregate}Created
+from .infrastructure import I{aggregate}Repository
+
+
+@dataclass
+class Create{aggregate}(Command):
+    {aggregate_lower}_id: str
+    # add fields
+
+
+@dataclass
+class Get{aggregate}(Query):
+    {aggregate_lower}_id: str
+
+
+class Create{aggregate}Handler:
+    def __init__(self, repo: I{aggregate}Repository, event_bus: EventBus):
+        self._repo = repo
+        self._event_bus = event_bus
+
+    async def __call__(self, cmd: Create{aggregate}) -> str:
+        agg = {aggregate}(id=cmd.{aggregate_lower}_id)
+        await self._repo.add(agg)
+        for e in agg.collect_pending_events():
+            await self._event_bus.publish(e)
+        return agg.id
+
+
+class Get{aggregate}Handler:
+    def __init__(self, repo: I{aggregate}Repository):
+        self._repo = repo
+
+    async def __call__(self, query: Get{aggregate}):
+        agg = await self._repo.get(query.{aggregate_lower}_id)
+        if agg is None:
+            return None
+        return {{"id": agg.id}}
+'''
+
+INFRASTRUCTURE_PY = '''"""Infrastructure: repository implementation."""
+from __future__ import annotations
+
+from typing import Optional
+from urich.domain import Repository
+
+from .domain import {aggregate}
+
+
+class I{aggregate}Repository(Repository["{aggregate}"]):
+    pass
+
+
+class {aggregate}RepositoryImpl(I{aggregate}Repository):
+    def __init__(self):
+        self._store: dict[str, {aggregate}] = {{}}
+
+    async def get(self, id: str) -> Optional[{aggregate}]:
+        return self._store.get(id)
+
+    async def add(self, aggregate: {aggregate}) -> None:
+        self._store[aggregate.id] = aggregate
+
+    async def save(self, aggregate: {aggregate}) -> None:
+        self._store[aggregate.id] = aggregate
+'''
+
+MODULE_PY = '''"""One object = bounded context «{context}»."""
+from urich.ddd import DomainModule
+
+from .domain import {aggregate}, {aggregate}Created
+from .application import Create{aggregate}, Create{aggregate}Handler, Get{aggregate}, Get{aggregate}Handler
+from .infrastructure import I{aggregate}Repository, {aggregate}RepositoryImpl
+
+
+def on_{aggregate_lower}_created(event: {aggregate}Created) -> None:
+    """Handler: when {aggregate} is created."""
+    ...
+
+
+{context}_module = (
+    DomainModule("{context}")
+    .aggregate({aggregate})
+    .repository(I{aggregate}Repository, {aggregate}RepositoryImpl)
+    .command(Create{aggregate}, Create{aggregate}Handler)
+    .query(Get{aggregate}, Get{aggregate}Handler)
+    .on_event({aggregate}Created, on_{aggregate_lower}_created)
+)
+'''
+
+MAIN_PY = '''"""Entry point: app is composed from modules."""
+from urich import Application
+
+# from {first_context}.module import {first_context}_module
+
+app = Application()
+# app.register({first_context}_module)
+
+# Run: uvicorn main:app --reload
+'''
+
+CONTEXT_SKELETON = '''"""Domain {context}."""
+from urich.domain import AggregateRoot, DomainEvent
+
+# Add aggregates and events or run: urich add-aggregate {context} <AggregateName>
+'''
+
+CONTEXT_APPLICATION_SKELETON = '''"""Application layer for context {context}."""
+from urich.ddd import Command, Query
+
+# Add commands, queries and handlers (or generate via add-aggregate)
+'''
+
+CONTEXT_INFRASTRUCTURE_SKELETON = '''"""Infrastructure for context {context}."""
+from urich.domain import Repository
+
+# Add repository interfaces and implementations
+'''
+
+CONTEXT_MODULE_SKELETON = '''"""Bounded context «{context}» — no aggregates yet."""
+from urich.ddd import DomainModule
+
+# Add .aggregate(), .repository(), .command(), .query(), .on_event() after add-aggregate
+{context}_module = DomainModule("{context}")
+'''

urich-0.1.0/src/urich/core/__init__.py

@@ -0,0 +1,13 @@
+from urich.core.app import Application
+from urich.core.container import Container
+from urich.core.module import Module
+from urich.core.routing import HttpModule
+from urich.core.config import Config
+
+__all__ = [
+    "Application",
+    "Container",
+    "Module",
+    "HttpModule",
+    "Config",
+]

urich-0.1.0/src/urich/core/app.py

@@ -0,0 +1,107 @@
+"""Application — Starlette wrapper; app is composed from modules via app.register(module)."""
+from __future__ import annotations
+
+from typing import Any
+
+from starlette.applications import Starlette
+from starlette.routing import Route
+
+from urich.core.container import Container
+from urich.core.module import Module
+
+
+class Application:
+    """
+    Application. Composed from modules via register(module).
+    Each module is an object with register_into(app).
+    """
+
+    def __init__(self, config: Any = None) -> None:
+        self._starlette = Starlette(routes=[])
+        self._modules: list[Module] = []
+        self._container = Container()
+        self._route_schemas: dict[tuple[str, str], dict[str, Any]] = {}  # (path, method) -> OpenAPI op extras
+        if config is not None:
+            self._container.register_instance(type(config), config)
+            self._container.register_instance("config", config)
+
+    def register(self, module: Module) -> Application:
+        """Register a module (DomainModule, EventBusModule, routes, etc.). Returns self for chaining."""
+        module.register_into(self)
+        self._modules.append(module)
+        return self
+
+    def add_route(
+        self,
+        path: str,
+        endpoint: Any,
+        methods: list[str] | None = None,
+        *,
+        openapi_body_schema: dict[str, Any] | None = None,
+        openapi_parameters: list[dict[str, Any]] | None = None,
+    ) -> None:
+        """Add an HTTP route. Optional openapi_body_schema / openapi_parameters for Swagger."""
+        if methods is None:
+            methods = ["GET"]
+        route = Route(path, endpoint, methods=methods)
+        self._starlette.routes.append(route)
+        for method in methods:
+            key = (path, method.lower())
+            if key not in self._route_schemas:
+                self._route_schemas[key] = {}
+            if method.lower() == "get" and openapi_parameters is not None:
+                self._route_schemas[key]["parameters"] = openapi_parameters
+            if method.lower() == "post" and openapi_body_schema is not None:
+                self._route_schemas[key]["requestBody"] = {
+                    "required": True,
+                    "content": {"application/json": {"schema": openapi_body_schema}},
+                }
+
+    def mount(self, path: str, app: Starlette) -> None:
+        """Mount a sub-app at prefix. Called by modules from register_into."""
+        from starlette.routing import Mount
+        self._starlette.routes.append(Mount(path, app=app))
+
+    def openapi(
+        self,
+        *,
+        title: str = "API",
+        version: str = "0.1.0",
+        docs_path: str = "/docs",
+        openapi_path: str = "/openapi.json",
+    ) -> Application:
+        """Add OpenAPI spec and Swagger UI. Call after all modules are registered. Returns self."""
+        from urich.core.openapi import build_openapi_spec, SWAGGER_UI_HTML
+        from starlette.responses import HTMLResponse, JSONResponse
+
+        spec = build_openapi_spec(
+            self._starlette.routes,
+            title=title,
+            version=version,
+            route_schemas=self._route_schemas,
+        )
+        self._openapi_spec = spec  # type: ignore[attr-defined]
+
+        async def openapi_endpoint(request: Any) -> Any:
+            return JSONResponse(spec)
+
+        async def docs_endpoint(request: Any) -> Any:
+            return HTMLResponse(SWAGGER_UI_HTML.replace("/openapi.json", openapi_path))
+
+        self.add_route(openapi_path, openapi_endpoint, methods=["GET"])
+        self.add_route(docs_path, docs_endpoint, methods=["GET"])
+        return self
+
+    @property
+    def container(self) -> Container:
+        """DI container: registration and resolution of dependencies."""
+        return self._container
+
+    @property
+    def starlette(self) -> Starlette:
+        """Underlying Starlette ASGI app (e.g. for middleware)."""
+        return self._starlette
+
+    async def __call__(self, scope: dict, receive: Any, send: Any) -> None:
+        """ASGI: uvicorn.run(app) works directly."""
+        await self._starlette(scope, receive, send)

urich-0.1.0/src/urich/core/config.py

@@ -0,0 +1,20 @@
+"""Single config object: user passes it when creating the app; available via DI."""
+import os
+from typing import Any
+
+
+class Config:
+    """
+    Application config. User creates their own class or instance
+    and passes to Application(config=...); then available via container.resolve(Config).
+    """
+
+    @classmethod
+    def load_from_env(cls, prefix: str = "APP_", **defaults: Any) -> dict[str, Any]:
+        """Load from os.environ with prefix and defaults. Returns dict for MyConfig(**Config.load_from_env())."""
+        result = dict(defaults)
+        for key, value in os.environ.items():
+            if key.startswith(prefix):
+                name = key[len(prefix):].lower()
+                result[name] = value
+        return result