loom-kernel 0.2.0__tar.gz → 0.2.1__tar.gz

loom_kernel-0.2.1/CHANGELOG.md

@@ -0,0 +1,105 @@
+# 🚀 Release 0.2.1 ([#12](https://github.com/the-reacher-data/loom-py/pull/12)) ([`87f7d1f`](https://github.com/the-reacher-data/loom-py/commit/87f7d1f1eb1ccde71d0aca1c5584b83317e30707))
+
+
+## ✨ Features
+### logger
+- **logger:** support per-logger levels from config
+
+### repository
+- **repository:** generalize main repo registration for loom structs
+
+
+## 🐛 Fixes
+### rest
+- **rest:** serialize pagination envelopes in camel case
+- **rest:** support loom structs in autocrud tests
+
+### prometheus
+- **prometheus:** expose metrics at exact path
+
+### review
+- **review:** apply quick-fix pass from code review
+
+
+## 📖 Documentation
+### repository
+- **repository:** align custom repo examples
+
+
+
+## ♻️ Refactor
+### repository
+- **repository:** clarify sqlalchemy registration builder
+- **repository:** inject default repository builder
+- **repository:** simplify registration module
+
+
+
+
+
+
+
+# 🚀 Release 0.2.0 ([#9](https://github.com/the-reacher-data/loom-py/pull/9)) ([`2f669ab`](https://github.com/the-reacher-data/loom-py/commit/2f669ab205c7255eb6494e4cdb8ab8092817af62))
+
+## ✨ Features
+
+### cache
+- **cache:** aiocache gateway with auto-inferred invalidation specs<br>
+  > CachedRepository wraps any repository with read-through/write-through caching. ONE_TO_MANY depends_on specs are auto-generated from field annotations — no explicit declaration needed. Explicit depends_on always wins.
+
+### celery
+- **celery:** production-ready Celery integration layer<br>
+  > CeleryJobService, persistent worker event loop, trace propagation, eager fallback, and task_default_queue routing so callbacks land on the correct consumed queue. bootstrap_worker compiles use cases, repositories, and registers Celery tasks in a single call.
+
+- **celery:** worker job discovery from modules or manifest<br>
+  > bootstrap_worker discovers and registers Job classes automatically from module include paths (mode: modules) or from a typed WorkerManifest (mode: manifest). WorkerManifest replaces scattered JOBS/USE_CASES/INTERFACES module attributes with a single typed contract.
+
+- **celery:** interfaces= and use_cases= on bootstrap_worker<br>
+  > Callbacks that call ApplicationInvoker need matching use-case keys compiled in the worker. interfaces= extracts use-case types from RestInterface route declarations (including AutoCRUD-generated ones). use_cases= handles non-AutoCRUD scenarios. Both can be combined with discovery mode.
+
+### core
+- **core:** typed repository abstractions and SQLAlchemy backend<br>
+  > Async repository protocol (RepositoryRead, RepositoryWrite, RepoFor) backed by SQLAlchemy 2.0 async session. Struct-based model system using msgspec.Struct as the single source of truth — models compile to SA mapped classes at startup via compile_all(). count() and UPDATE RETURNING included as first-class operations.
+
+- **core:** use-case DSL with field refs, compute, rules and typed markers<br>
+  > Declarative use-case definition via Input, Load, LoadById, Exists, Compute and Rule markers. Signature inspection runs once at compile time; RuntimeExecutor drives execution from an immutable ExecutionPlan. No per-request reflection.
+
+- **core:** ApplicationInvoker and named use-case registry<br>
+  > Use cases and job callbacks invoke other use cases by type through ApplicationInvoker without direct coupling. A named registry maps use-case keys to compiled instances at bootstrap, providing a stable cross-invocation contract.
+
+- **core:** compiled model artifact and cache entity keys<br>
+  > compile_all() produces a typed CompiledCore artifact exposing stable entity keys used by the cache layer for deterministic repository-level invalidation across reads and writes.
+
+- **core:** executor skips UoW for read-only use cases and GET routes<br>
+  > UseCase.read_only=True and all GET routes bypass UoW.begin/commit, removing at minimum one BEGIN+COMMIT round-trip from every read request on PostgreSQL.
+
+### job
+- **job:** async job domain model and orchestration primitives<br>
+  > Job[ResultT] base class with Celery routing ClassVars. JobHandle / JobGroup with dual-mode waiting (Celery + inline). JobCallback lifecycle with on_success/on_failure. Dispatch is transactionally safe — jobs flush on UoW commit and are cleared on rollback.
+
+### observability
+- **observability:** trace_id propagation and Prometheus adapter<br>
+  > trace_id injected into every request context and propagated to job callbacks. MetricsAdapter protocol emits execution events; PrometheusAdapter records latency histograms and error counters with low cardinality labels.
+
+### projection
+- **projection:** compiler-driven memory/SQL routing<br>
+  > Projections are source-agnostic at declaration time. The backend compiler decides at compile_all() whether each projection runs in-memory (relation already loaded in the active profile) or via SQL. Users declare only CountLoader, ExistsLoader, or JoinFieldsLoader — no source= parameter. Internal _Memory* and _Sql* loaders are synthesized at compile time.
+
+### rest
+- **rest:** AutoCRUD and FastAPI adapter<br>
+  > RestInterface.auto=True generates full CRUD routes at class definition time via build_auto_routes(). OpenAPI contracts expose query params, pagination defaults, and decoupled CreateInput/UpdateInput write DTOs. Discovery engine mounts all declared interfaces at bootstrap.
+
+## 📖 Documentation
+
+- Sphinx documentation platform with full public guides<br>
+  > Quickstart, use-case DSL reference, AutoCRUD guide, Celery integration guide (job definition, dispatch, callbacks, YAML reference, bootstrap options, ApplicationInvoker, Docker-compose stack), and dummy-loom examples-repo walkthrough. Deployed to Read the Docs.
+
+## ⚡ Performance
+
+### engine
+- **engine:** UPDATE RETURNING replaces SELECT + flush + refresh<br>
+  > SQLAlchemyUpdateMixin.update() issues a single UPDATE ... RETURNING round-trip. Server-side onupdate expressions are pre-computed at init time and injected into the SET clause automatically.
+
+### repository
+- **repository:** single-query total count for offset pagination<br>
+  > list_with_query with PaginationMode.OFFSET issues a single SELECT COUNT(*) instead of a separate full-table scan, eliminating one round-trip per paginated list operation.

loom_kernel-0.2.1/CHANGELOG_RELEASE.md

@@ -0,0 +1,39 @@
+# 🚀 Release 0.2.1 ([#12](https://github.com/the-reacher-data/loom-py/pull/12)) ([`87f7d1f`](https://github.com/the-reacher-data/loom-py/commit/87f7d1f1eb1ccde71d0aca1c5584b83317e30707))
+
+
+## ✨ Features
+### logger
+- **logger:** support per-logger levels from config
+
+### repository
+- **repository:** generalize main repo registration for loom structs
+
+
+## 🐛 Fixes
+### rest
+- **rest:** serialize pagination envelopes in camel case
+- **rest:** support loom structs in autocrud tests
+
+### prometheus
+- **prometheus:** expose metrics at exact path
+
+### review
+- **review:** apply quick-fix pass from code review
+
+
+## 📖 Documentation
+### repository
+- **repository:** align custom repo examples
+
+
+
+## ♻️ Refactor
+### repository
+- **repository:** clarify sqlalchemy registration builder
+- **repository:** inject default repository builder
+- **repository:** simplify registration module
+
+
+
+
+

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loom-kernel
-Version: 0.2.0
+Version: 0.2.1
 Summary: Loom Python project
 License-File: LICENSE
 Requires-Python: >=3.11
@@ -33,11 +33,9 @@ Provides-Extra: sqlalchemy
 Requires-Dist: sqlalchemy<3.0,>=2.0; extra == 'sqlalchemy'
 Description-Content-Type: text/markdown
 
-<div style="width:100%;background:#fff;padding:4px 0;box-sizing:border-box;">
-  <p align="center" style="margin:0;">
-    <img src="docs/_static/logo-transparent.png" alt="loom-kernel" style="display:block;width:100%;max-width:none;max-height:220px;height:auto;object-fit:contain;margin:0 auto;" />
-  </p>
-</div>
+<p align="center">
+  <img src="docs/_static/logo-transparent.png" alt="loom-kernel" width="160" style="background:#ffffff;border-radius:6px;padding:8px 20px;" />
+</p>
 
 # loom-kernel
 

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/README.md

@@ -1,8 +1,6 @@
-<div style="width:100%;background:#fff;padding:4px 0;box-sizing:border-box;">
-  <p align="center" style="margin:0;">
-    <img src="docs/_static/logo-transparent.png" alt="loom-kernel" style="display:block;width:100%;max-width:none;max-height:220px;height:auto;object-fit:contain;margin:0 auto;" />
-  </p>
-</div>
+<p align="center">
+  <img src="docs/_static/logo-transparent.png" alt="loom-kernel" width="160" style="background:#ffffff;border-radius:6px;padding:8px 20px;" />
+</p>
 
 # loom-kernel
 

loom_kernel-0.2.1/docs/_static/custom.css

@@ -0,0 +1,13 @@
+.loom-hero {
+  padding: 1rem 0 1.5rem;
+  text-align: center;
+}
+
+.loom-hero img {
+  display: inline-block;
+  width: 160px;
+  height: auto;
+  background: #ffffff;
+  border-radius: 6px;
+  padding: 8px 20px;
+}

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/docs/conf.py

@@ -80,12 +80,16 @@ intersphinx_mapping = {
 # Optional dependencies are mocked to keep docs builds lightweight and stable.
 autodoc_mock_imports = [
     "aiocache",
+    "celery",
     "fastapi",
+    "kombu",
     "omegaconf",
     "prometheus_client",
     "pydantic",
     "pyspark",
+    "redis",
     "sqlalchemy",
+    "starlette",
     "uvicorn",
 ]
 

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/docs/examples-repo/index.md

@@ -171,11 +171,9 @@ from typing import Protocol
 
 import msgspec
 
+from loom.core.repository import repository_for
 from loom.core.repository.abc import RepoFor
-from loom.core.repository.sqlalchemy import (
-    RepositorySQLAlchemy,
-    repository_for,
-)
+from loom.core.repository.sqlalchemy import RepositorySQLAlchemy
 
 
 class ProductRepo(RepoFor[Product], Protocol):
@@ -183,8 +181,8 @@ class ProductRepo(RepoFor[Product], Protocol):
         ...
 
 
-@repository_for(Product, contract=ProductRepo)
-class ProductRepository(RepositorySQLAlchemy[Product, int]):
+@repository_for(Product)
+class ProductRepository(RepositorySQLAlchemy[Product, int], ProductRepo):
     async def create(self, data: msgspec.Struct) -> Product:
         payload = msgspec.to_builtins(data)
         payload["name"] = str(payload["name"]).strip()
@@ -197,6 +195,173 @@ class CreateProductUseCase(UseCase[Product, Product]):
         return await self.main_repo.create(cmd)
 ```
 
+### Logical type with automatic `main_repo`
+
+`main_repo` can also be bound to a non-persistible logical type. Use
+`Response` when the returned object is part of your public API contract and you
+want the usual REST `camelCase` output.
+
+```python
+from typing import Protocol
+
+from loom.core.repository import repository_for
+from loom.core.response import Response
+from loom.core.use_case.use_case import UseCase
+
+
+class TaskView(Response):
+    task_id: str
+    state: str
+
+
+class TaskViewRepo(Protocol):
+    async def get_by_id(self, obj_id: str, profile: str = "default") -> TaskView | None:
+        ...
+
+
+@repository_for(TaskView)
+class TaskViewRepository(TaskViewRepo):
+    def __init__(self) -> None:
+        self._items = {"t-1": TaskView(task_id="t-1", state="done")}
+
+    async def get_by_id(self, obj_id: str, profile: str = "default") -> TaskView | None:
+        return self._items.get(obj_id)
+
+
+class GetTaskViewUseCase(UseCase[TaskView, TaskView | None, TaskViewRepo]):
+    async def execute(self, task_id: str) -> TaskView | None:
+        return await self.main_repo.get_by_id(task_id)
+```
+
+Use `LoomStruct` instead of `Response` when you want a logical type without
+REST-specific `camelCase` serialization.
+
+### Default repository builder and explicit builder override
+
+The framework now resolves the default repository through the
+`DefaultRepositoryBuilder` dependency. In the current SQLAlchemy stack, the
+bootstrap registers `SQLAlchemyDefaultRepositoryBuilder` as that default, and
+that builder keeps `SessionManager` inside the SQLAlchemy adapter layer.
+
+This means:
+
+- the core registry no longer depends on SQLAlchemy constructor details
+- SQLAlchemy keeps `SessionManager` as an infrastructure concern
+- applications can replace the default builder without changing `UseCase`
+
+Conceptually, the current SQLAlchemy fallback is:
+
+```python
+from dataclasses import dataclass
+
+from loom.core.repository import DefaultRepositoryBuilder, RepositoryBuildContext
+from loom.core.repository.sqlalchemy import RepositorySQLAlchemy
+from loom.core.repository.sqlalchemy.session_manager import SessionManager
+
+
+@dataclass(frozen=True)
+class SQLAlchemyDefaultRepositoryBuilder:
+    session_manager: SessionManager
+
+    def __call__(self, context: RepositoryBuildContext) -> object:
+        return RepositorySQLAlchemy(
+            session_manager=self.session_manager,
+            model=context.model,
+        )
+```
+
+An application that wants a different project-wide base repository can
+register another `DefaultRepositoryBuilder` implementation in the container.
+
+That is the extension point for replacing the default backend globally. For
+example, an application can swap the SQLAlchemy fallback for its own base
+repository while keeping `UseCase[Model, Result]` unchanged:
+
+```python
+from dataclasses import dataclass
+
+from loom.core.repository import DefaultRepositoryBuilder, RepositoryBuildContext
+
+
+@dataclass(frozen=True)
+class MyBaseRepositoryBuilder:
+    settings: AppSettings
+
+    def __call__(self, context: RepositoryBuildContext) -> object:
+        return MyBaseRepository(model=context.model, settings=self.settings)
+
+
+container.register_instance(
+    DefaultRepositoryBuilder,
+    MyBaseRepositoryBuilder(settings=settings),
+)
+```
+
+After that registration:
+
+- every model without an explicit `repository_for(...)` uses `MyBaseRepository`
+- `UseCase[Model, Result]` keeps working through `self.main_repo`
+- model-specific overrides still win when needed
+
+For per-model overrides that need extra dependencies, use `builder=` on
+`repository_for(...)`:
+
+```python
+from dataclasses import dataclass
+
+from loom.core.di.scope import Scope
+from loom.core.repository import RepositoryBuildContext, repository_for
+from loom.core.response import Response
+
+
+class TaskSnapshot(Response):
+    task_id: str
+    state: str
+
+
+class TaskSnapshotRepo(Protocol):
+    async def get_by_id(self, obj_id: str, profile: str = "default") -> TaskSnapshot | None:
+        ...
+
+
+@dataclass(frozen=True)
+class TaskRepoSettings:
+    state: str
+
+
+def build_task_snapshot_repository(context: RepositoryBuildContext) -> object:
+    settings = context.container.resolve(TaskRepoSettings)
+    return TaskSnapshotRepository(settings=settings)
+
+
+@repository_for(TaskSnapshot, builder=build_task_snapshot_repository)
+class TaskSnapshotRepository(TaskSnapshotRepo):
+    def __init__(self, settings: TaskRepoSettings) -> None:
+        self._settings = settings
+
+    async def get_by_id(self, obj_id: str, profile: str = "default") -> TaskSnapshot | None:
+        return TaskSnapshot(task_id=obj_id, state=self._settings.state)
+```
+
+The application bootstrap only has to register the extra dependency:
+
+```python
+container.register(
+    TaskRepoSettings,
+    lambda: TaskRepoSettings(state="from-builder"),
+    scope=Scope.APPLICATION,
+)
+```
+
+Resolution order is:
+
+1. explicit `repository_for(..., builder=...)`
+2. explicit `repository_for(...)` by class
+3. `DefaultRepositoryBuilder`
+
+Use the first two for per-model customization; use `DefaultRepositoryBuilder`
+to replace the project-wide backend.
+
 ---
 
 ## 4. Background jobs

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/docs/guides/fake-repo-examples.md

@@ -23,6 +23,23 @@ Useful files:
 Custom repository pattern:
 
 - Declare the custom contract as `RepoFor[Model]` plus only the extra methods.
-- Register the SQLAlchemy implementation with `@repository_for(Model, contract=...)`.
+- Import `repository_for` from `loom.core.repository`, not from the SQLAlchemy package.
+- Register the SQLAlchemy implementation with `@repository_for(Model)` and make the
+  repository class inherit the capability `Protocol` directly.
 - Keep CRUD-only use cases on `self.main_repo`; they automatically receive the custom implementation.
 - Reserve constructor-injected repository contracts for advanced cases where a use case or job needs a secondary repository dependency; the primary public example should stay on `main_repo`.
+- `repository_for(...)` also works for non-persistible logical types:
+  - use `LoomStruct` for neutral internal structs
+  - use `Response` for API-facing structs that should serialize in `camelCase`
+- The SQLAlchemy bootstrap module now registers `DefaultRepositoryBuilder` with
+  `SQLAlchemyDefaultRepositoryBuilder` as the current fallback for `BaseModel`.
+- That fallback keeps `SessionManager` inside the SQLAlchemy adapter, so SQLAlchemy
+  construction details do not leak into the core repository contract.
+- To replace the project-wide backend, register another `DefaultRepositoryBuilder`
+  implementation in the container; `UseCase[Model, Result]` will continue to
+  resolve `self.main_repo` through that new base repository.
+- Explicit `repository_for(...)` bindings still take precedence for both
+  persistible and non-persistible types.
+- When a custom repository needs more constructor dependencies than the default
+  class path supports, use `repository_for(..., builder=...)` and resolve those
+  dependencies from `RepositoryBuildContext.container`.

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/docs/guides/quickstart.md

@@ -100,11 +100,14 @@ def _name_must_not_be_blank(full_name: str) -> str | None:
 def _email_must_be_valid(email: str) -> str | None:
     return None if _EMAIL_RE.fullmatch(email) else "email must be valid"
 
+def _email_is_taken(cmd: CreateUser, fields_set: frozenset[str], email_exists: bool) -> bool:
+    return email_exists
+
 class CreateUserUseCase(UseCase[User, User]):
     rules = [
         Rule.check(F(CreateUser).full_name, via=_name_must_not_be_blank),
         Rule.check(F(CreateUser).email, via=_email_must_be_valid),
-        Rule.forbid(lambda _, __, exists: exists, message="email already exists").from_params("email_exists"),
+        Rule.forbid(_email_is_taken, message="email already exists").from_params("email_exists"),
     ]
 
     async def execute(
@@ -369,23 +372,38 @@ For compute-heavy write flows, declare field derivations and run them before rul
 ```python
 from loom.core.use_case import Compute, F
 
+def _normalize_email(email: str) -> str:
+    return email.strip().lower()
+
+def _compute_subtotal(unit_price: float, quantity: int) -> float:
+    return unit_price * quantity
+
+def _compute_tax(subtotal: float, tax_rate: float) -> float:
+    return subtotal * tax_rate
+
+def _unit_price_invalid(unit_price: float) -> bool:
+    return unit_price <= 0
+
+def _country_unsupported(country: str) -> bool:
+    return country not in TAX_RATES
+
 class PricingPreviewUseCase(UseCase[Record, PricingPreviewResponse]):
     computes = (
         Compute.set(F(PricingCommand).normalized_email).from_command(
-            F(PricingCommand).email, via=lambda v: v.strip().lower(),
+            F(PricingCommand).email, via=_normalize_email,
         ),
         Compute.set(F(PricingCommand).subtotal).from_command(
             F(PricingCommand).unit_price, F(PricingCommand).quantity,
-            via=lambda price, qty: price * qty,
+            via=_compute_subtotal,
         ),
         Compute.set(F(PricingCommand).tax_amount).from_command(
             F(PricingCommand).subtotal, F(PricingCommand).tax_rate,
-            via=lambda sub, rate: sub * rate,
+            via=_compute_tax,
         ),
     )
     rules = (
-        Rule.check(F(PricingCommand).unit_price, via=lambda v: v <= 0, message="unit_price must be > 0"),
-        Rule.check(F(PricingCommand).country, via=lambda v: v not in TAX_RATES, message="Unsupported country"),
+        Rule.check(F(PricingCommand).unit_price, via=_unit_price_invalid, message="unit_price must be > 0"),
+        Rule.check(F(PricingCommand).country, via=_country_unsupported, message="Unsupported country"),
     )
 
     async def execute(self, record_id: int, cmd: PricingCommand = Input()) -> PricingPreviewResponse:

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/docs/guides/use-case-dsl.md

@@ -186,11 +186,14 @@ CREATE_NORMALIZE_PRICE = Compute.set(F(CreateProduct).price).from_command(
 Computes can read multiple fields:
 
 ```python
+def _compute_subtotal(unit_price: float, quantity: int) -> float:
+    return unit_price * quantity
+
 # Derives subtotal from unit_price × quantity
 CREATE_SUBTOTAL = Compute.set(F(PricingCommand).subtotal).from_command(
     F(PricingCommand).unit_price,
     F(PricingCommand).quantity,
-    via=lambda price, qty: price * qty,
+    via=_compute_subtotal,
 )
 ```
 

loom_kernel-0.2.1/docs/index.rst

@@ -0,0 +1,68 @@
+loom-kernel documentation
+=========================
+
+.. raw:: html
+
+   <div class="loom-hero">
+     <img src="_static/logo-transparent.png" alt="loom-kernel logo" />
+   </div>
+   <p align="center" style="margin:0.5rem 0 1.5rem;">
+     <a href="https://github.com/the-reacher-data/loom-py/actions/workflows/ci-main.yml">
+       <img src="https://img.shields.io/github/actions/workflow/status/the-reacher-data/loom-py/ci-main.yml?branch=master&label=ci" alt="CI" />
+     </a>
+     &nbsp;
+     <a href="https://github.com/the-reacher-data/loom-py/actions/workflows/docs.yml">
+       <img src="https://img.shields.io/github/actions/workflow/status/the-reacher-data/loom-py/docs.yml?branch=master&label=docs" alt="Docs" />
+     </a>
+     &nbsp;
+     <a href="https://sonarcloud.io/summary/new_code?id=the-reacher-data_loom-py">
+       <img src="https://sonarcloud.io/api/project_badges/measure?project=the-reacher-data_loom-py&metric=alert_status" alt="Quality Gate" />
+     </a>
+     &nbsp;
+     <a href="https://sonarcloud.io/summary/new_code?id=the-reacher-data_loom-py">
+       <img src="https://sonarcloud.io/api/project_badges/measure?project=the-reacher-data_loom-py&metric=security_rating" alt="Security" />
+     </a>
+     &nbsp;
+     <a href="https://app.codecov.io/gh/the-reacher-data/loom-py/tree/master">
+       <img src="https://codecov.io/gh/the-reacher-data/loom-py/branch/master/graph/badge.svg" alt="Coverage" />
+     </a>
+     &nbsp;
+     <a href="https://pypi.org/project/loom-kernel/">
+       <img src="https://img.shields.io/pypi/v/loom-kernel" alt="PyPI" />
+     </a>
+     &nbsp;
+     <img src="https://img.shields.io/badge/python-3.11%2B-blue" alt="Python" />
+   </p>
+
+Framework-agnostic toolkit to build backend applications with typed use cases,
+repository contracts, and transport adapters.
+
+Official hosted documentation:
+`loom-py.readthedocs.io <https://loom-py.readthedocs.io/en/latest/>`_.
+Companion demo application:
+`dummy-loom <https://github.com/the-reacher-data/dummy-loom>`_.
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Guides
+
+   guides/autocrud
+   guides/quickstart
+   examples-repo/index
+   guides/use-case-dsl
+   guides/celery
+   guides/fake-repo-examples
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Architecture
+
+   architecture/overview
+   architecture/clean-architecture
+   architecture/adr/README
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Reference
+
+   reference/index

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "loom-kernel"
-version = "0.2.0"
+version = "0.2.1"
 description = "Loom Python project"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -144,7 +144,7 @@ log_cli_format = "%(asctime)s %(levelname)s %(name)s %(message)s"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.2.0"
+version = "0.2.1"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:project.version",

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/src/loom/celery/bootstrap.py

@@ -77,7 +77,7 @@ from loom.core.engine.compilable import Compilable
 from loom.core.job.job import Job
 from loom.core.logger import LoggerConfig, configure_logging_from_values
 from loom.core.model import BaseModel
-from loom.core.repository.sqlalchemy import build_repository_registration_module
+from loom.core.repository.sqlalchemy import build_sqlalchemy_repository_registration_module
 from loom.core.repository.sqlalchemy.session_manager import SessionManager
 from loom.core.repository.sqlalchemy.uow import SQLAlchemyUnitOfWorkFactory
 from loom.core.uow.abc import UnitOfWorkFactory
@@ -547,7 +547,7 @@ def _register_repositories(
     models: Sequence[type[BaseModel]],
 ) -> Callable[[LoomContainer], None]:
     """Build a container module that registers SQLAlchemy repositories."""
-    return build_repository_registration_module(session_manager, models)
+    return build_sqlalchemy_repository_registration_module(session_manager, models)
 
 
 def _compile_models(models: Sequence[type[BaseModel]]) -> tuple[type[BaseModel], ...]:
@@ -577,6 +577,7 @@ def _configure_logging(raw: DictConfig) -> None:
         renderer=logger_cfg.renderer,
         colors=logger_cfg.colors,
         level=logger_cfg.level,
+        named_levels=logger_cfg.named_levels,
         handlers=logger_cfg.handlers,
     )
 

{loom_kernel-0.2.0 → loom_kernel-0.2.1}/src/loom/core/di/container.py

@@ -102,6 +102,32 @@ class LoomContainer:
         factory = provider
         self._bindings[interface] = _Binding(provider=factory, scope=scope)
 
+    def register_instance(self, interface: BindingKey, instance: Any) -> None:
+        """Register an already-constructed singleton instance.
+
+        Equivalent to ``register(interface, lambda: instance,
+        scope=Scope.APPLICATION)`` but skips the factory indirection — the
+        instance is stored directly and returned on every :meth:`resolve` call.
+
+        Use this when the caller owns the lifecycle of the object (e.g. a
+        ``SessionManager`` created by the bootstrap) and the container should
+        treat it as an application-scope singleton without constructing it.
+
+        Args:
+            interface: A hashable DI key used as the resolution key.
+            instance: The singleton instance to bind.
+
+        Example::
+
+            container.register_instance(SessionManager, session_manager)
+            assert container.resolve(SessionManager) is session_manager
+        """
+        self._bindings[interface] = _Binding(
+            provider=lambda: instance,
+            scope=Scope.APPLICATION,
+            _instance=instance,
+        )
+
     def resolve(self, interface: BindingKey) -> Any:
         """Return an instance bound to ``interface``.