quadkit 0.0.44__tar.gz → 0.0.45__tar.gz

{quadkit-0.0.44 → quadkit-0.0.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quadkit
-Version: 0.0.44
+Version: 0.0.45
 Summary: Async-first DI/IoC framework for Python — core package
 Project-URL: Homepage, https://dbtinoy-.github.io/quadkit/
 Project-URL: Repository, https://github.com/dbtinoy-/quadkit
@@ -251,10 +251,10 @@ report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.44` in the `0.x` series, released in lockstep with the
+Version `0.0.45` in the `0.x` series, released in lockstep with the
 other four distributions; APIs may change between minor versions until
 1.0 — pin an exact version
-(`quadkit==0.0.44`) or a tight range (`>=0.0.44,<0.1.0`). Full policy:
+(`quadkit==0.0.45`) or a tight range (`>=0.0.45,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit-0.0.44 → quadkit-0.0.45}/README.md

@@ -199,10 +199,10 @@ report vulnerabilities privately per
 
 ## Stability
 
-Version `0.0.44` in the `0.x` series, released in lockstep with the
+Version `0.0.45` in the `0.x` series, released in lockstep with the
 other four distributions; APIs may change between minor versions until
 1.0 — pin an exact version
-(`quadkit==0.0.44`) or a tight range (`>=0.0.44,<0.1.0`). Full policy:
+(`quadkit==0.0.45`) or a tight range (`>=0.0.45,<0.1.0`). Full policy:
 [stability and compatibility](https://dbtinoy-.github.io/quadkit/reference/stability/).
 
 ## Links

{quadkit-0.0.44 → quadkit-0.0.45}/pyproject.toml

@@ -29,7 +29,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quadkit"
-version = "0.0.44"
+version = "0.0.45"
 description = "Async-first DI/IoC framework for Python — core package"
 readme = "README.md"
 requires-python = ">=3.11"

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/app/base.py

@@ -29,6 +29,7 @@ if TYPE_CHECKING:
     from collections.abc import AsyncIterator
 
     from quadkit.di.module.dynamic import DynamicModule
+    from quadkit.di.module.graph import CompiledModuleGraph
     from quadkit.di.provider import Provider
     from quadkit.logging import LoggerProtocol
 
@@ -73,7 +74,7 @@ class Application(SecretsMixin, HealthProbeMixin):
         self._state = AppState.CREATED
         self._container = Container()
         self._container.singleton(type(self), self)
-        self._orchestrator = ProviderOrchestrator(self._container)
+        self._orchestrator: ProviderOrchestrator = ProviderOrchestrator(self._container)
 
         self._config = config or QuadkitConfig.from_env_profile()
         self._container.singleton(QuadkitConfig, self._config)
@@ -136,6 +137,23 @@ class Application(SecretsMixin, HealthProbeMixin):
         """DI container."""
         return self._container
 
+    @property
+    def module_graph(self) -> CompiledModuleGraph | None:
+        """The compiled module graph, or ``None`` before compilation.
+
+        Read-only view of what the boot sequence compiled: every module with
+        its providers, imports, and fully expanded exports. It exists so
+        boot-time guards can assert that what a module *declares* it exports is
+        what the container can actually resolve — the failure this graph is
+        otherwise blind to, because an export that nothing resolves during
+        boot only fails later, at ``QK_ERR_DI_004`` on first use, or never.
+
+        Returns:
+            The compiled graph, or ``None`` when the application has not been
+            compiled yet.
+        """
+        return self._orchestrator.compiled_graph
+
     @property
     def providers(self) -> list[Provider]:
         """Get all registered providers."""

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/concurrency/channels/channel.py

@@ -65,6 +65,12 @@ class BoundedChannel(Generic[T]):
         )
         self._closed = False
         self._lock = asyncio.Lock()
+        #: Set whenever something a waiting receiver cares about happened:
+        #: an item arrived or the channel closed. Receivers clear it before
+        #: they wait. They never dequeue from a helper task, so an item is
+        #: either in the queue or in the consumer's hands — there is no tick
+        #: in between where ``is_empty`` lies.
+        self._wakeup = asyncio.Event()
 
     async def send(self, item: T) -> None:
         """Send an item, blocking if the channel is full.
@@ -91,6 +97,7 @@ class BoundedChannel(Generic[T]):
             # full, but that means the item was never actually enqueued.
             with suppress(asyncio.QueueFull):
                 self._queue.put_nowait(wrapped)
+                self._wakeup.set()
             raise
         except asyncio.QueueFull:
             msg = "Channel is full"
@@ -98,6 +105,7 @@ class BoundedChannel(Generic[T]):
                 msg,
                 capacity=self.capacity,
             ) from None
+        self._wakeup.set()
 
     def send_nowait(self, item: T) -> None:
         """Send an item without blocking.
@@ -128,6 +136,7 @@ class BoundedChannel(Generic[T]):
         except asyncio.QueueFull:
             msg = "Channel is full"
             raise ChannelFullError(msg, capacity=self.capacity) from None
+        self._wakeup.set()
 
     async def receive(self) -> T:
         """Receive an item, blocking if the channel is empty.
@@ -138,29 +147,40 @@ class BoundedChannel(Generic[T]):
         Raises:
             ChannelClosedError: If the channel is closed and empty.
         """
-        try:
-            wrapped: _ContextualItem[T] = await self._queue.get()
-        except asyncio.CancelledError:
-            # If cancelled after the queue internally dequeued an item,
-            # put it back so it is not lost.  get_nowait will raise
-            # QueueEmpty if nothing was actually dequeued yet.
-            try:
-                item_back = self._queue.get_nowait()
-                self._queue.put_nowait(item_back)
-            except asyncio.QueueEmpty:
-                pass
-            raise
-        except asyncio.QueueEmpty:
-            if self._closed:
-                msg = "Channel is closed"
-                raise ChannelClosedError(msg) from None
-            raise
+        wrapped = await self._next_item()
         # Restore sender's context variables so OTel trace spans and other
         # context state are propagated to the consumer.
         for var, value in wrapped.ctx.items():
             var.set(value)
         return wrapped.item
 
+    async def _next_item(self) -> _ContextualItem[T]:
+        """Dequeue the next wrapped item, or raise once closed and drained.
+
+        The hot path — an item is already queued — is a plain
+        ``get_nowait``. Only an empty channel waits, and it waits on one
+        wake-up that both :meth:`send` and :meth:`close` raise. Without the
+        close half, ``close()`` could not end an ``async for`` over an empty
+        channel, and every consumer loop would outlive the thing it consumed.
+
+        The dequeue itself is always synchronous in the consumer's own task.
+        Pulling the item inside a helper task would open a window where the
+        queue is already empty but the consumer has not resumed yet — a
+        caller polling ``is_empty`` (the event bus's ``flush``) would
+        conclude the work was done one tick before it started.
+        """
+        while True:
+            try:
+                return self._queue.get_nowait()
+            except asyncio.QueueEmpty:
+                if self._closed:
+                    msg = "Channel is closed"
+                    raise ChannelClosedError(msg) from None
+            # Nothing queued and not closed: both facts were read without an
+            # intervening await, so clearing here cannot swallow a wake-up.
+            self._wakeup.clear()
+            await self._wakeup.wait()
+
     def receive_nowait(self) -> T:
         """Receive an item without blocking.
 
@@ -183,9 +203,15 @@ class BoundedChannel(Generic[T]):
         return wrapped.item
 
     async def close(self) -> None:
-        """Close the channel. Remaining items can still be received."""
+        """Close the channel. Remaining items can still be received.
+
+        Receivers blocked on an empty channel are woken and get
+        :class:`ChannelClosedError` (``StopAsyncIteration`` under
+        ``async for``), so a consumer loop ends when its producer does.
+        """
         async with self._lock:
             self._closed = True
+            self._wakeup.set()
 
     @property
     def is_closed(self) -> bool:

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/di/orchestrator/orchestrator.py

@@ -110,6 +110,24 @@ class ProviderOrchestrator:
         """
         self._registry._compiled_graph = graph
 
+    @property
+    def compiled_graph(self) -> CompiledModuleGraph | None:
+        """The compiled module graph, or ``None`` before compilation.
+
+        The public companion to :meth:`set_compiled_graph`. The graph is what
+        knows which module declares which export, and the code that needs to
+        answer that question lives outside this class: health probes, boot-time
+        assertions, and test guards. Without a reader the only way to ask was
+        the private ``_compiled_graph``, so every such caller reached into the
+        orchestrator's internals — and a rename would have broken them without
+        a test to notice.
+
+        Returns:
+            The graph produced by :class:`ModuleCompiler`, or ``None`` when the
+            application has not been compiled yet.
+        """
+        return self._registry._compiled_graph
+
     def add(self, provider: Provider) -> None:
         """Add a provider to be orchestrated.
 

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/di/resolution/resolver.py

@@ -187,6 +187,26 @@ class ServiceResolver:
 
             return instance
 
+    async def resolve_optional(self, service_type: Any) -> Any | None:
+        """Resolve a service, returning ``None`` when it is not registered.
+
+        ``ContainerResolverProtocol`` has declared this method all along, and
+        the container implements it, but the resolver handed to provider
+        factories did not: a provider asking for an optional dependency had to
+        pair ``has()`` with ``resolve()`` and hope nothing moved in between.
+        Absent means absent — a registered service whose construction raises
+        still raises.
+
+        Args:
+            service_type: The type to resolve.
+
+        Returns:
+            The resolved instance, or ``None`` when nothing is registered for it.
+        """
+        if not self.can_resolve(service_type):
+            return None
+        return await self.resolve(service_type)
+
     async def _create_instance(self, descriptor: ServiceDescriptor) -> Any:
         """Create a service instance from its descriptor."""
         impl = descriptor.implementation

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/domain/models/base.py

@@ -14,9 +14,9 @@ from typing import (
     get_type_hints,
 )
 
-from quadkit.domain.models.coercion import coerce_and_build, resolve_type_hints
+from quadkit.domain.models.coercion import coerce_and_build
 from quadkit.identity import ambient as identity_ambient
-from quadkit.primitives.typing import type_allows_none
+from quadkit.primitives.typing import resolve_type_hints, type_allows_none
 
 # Infrastructure imports (new locations)
 from quadkit.serialization.domain import (
@@ -116,6 +116,113 @@ def _convert_pydantic_fields_for_dataclass(cls: type) -> None:
             setattr(cls, attr_name, _dc.field(default=value.default, metadata=meta))
 
 
+_GUARD_DONE_ATTR = "_quadkit_guard_done"
+
+
+def run_field_guard(model: Any) -> None:
+    """Coerce and validate a dataclass-built model, once per instance.
+
+    ``@dataclass`` regenerates ``__init__`` on the subclass, so
+    ``DomainModel.__init__`` — the only place scalar coercion, ``Field(...)``
+    constraints and field validators ran — never executed for the documented
+    pattern::
+
+        @dataclass
+        class Product(DomainModel):
+            name: str = Field(default="", min_length=3)
+
+    A ``Field(min_length=3)`` there was documentation rather than a check, and
+    an ISO timestamp handed to the constructor stayed a string. Dataclasses
+    always call ``__post_init__``, so the guard is installed there (see
+    ``_install_field_guard``) and this function is what runs.
+
+    Idempotent by instance marker: ``DomainModel.__init__`` does this work
+    itself and then calls ``__post_init__``, so it marks the instance first.
+
+    Args:
+        model: The instance to coerce and validate in place.
+    """
+    if getattr(model, _GUARD_DONE_ATTR, False):
+        return
+    object.__setattr__(model, _GUARD_DONE_ATTR, True)
+
+    cls = type(model)
+    dc_fields = getattr(cls, "__dataclass_fields__", None)
+    if not dc_fields:
+        return
+
+    try:
+        type_hints = cls._cached_type_hints or resolve_type_hints(cls)
+    except (NameError, AttributeError, TypeError):
+        type_hints = {}
+
+    field_validators = getattr(cls, "_field_validators", None) or {}
+    values: dict[str, Any] = {}
+    for fname, f in dc_fields.items():
+        if not hasattr(model, fname):
+            continue
+        current = getattr(model, fname)
+        value = current
+
+        # `mode="before"` runs on the raw value: `@dataclass` has already
+        # assigned it, but coercion has not touched it yet, and a validator that
+        # declares the storage shape of a column (an epoch integer, a JSON
+        # document in a Text column) has to see that raw value.
+        # `DomainModel.__init__` dispatches the same mode the same way, and the
+        # two paths have to agree: one model, one behaviour.
+        for mode, vfn in field_validators.get(fname, []):
+            if mode == "before":
+                value = vfn(cls, value)
+
+        value = _coerce_value(fname, value, type_hints, f)
+        if value is not current:
+            object.__setattr__(model, fname, value)
+        values[fname] = value
+
+    cls._validate_field_constraints(dc_fields, values)
+
+    for fname, fval in list(values.items()):
+        for mode, vfn in field_validators.get(fname, []):
+            if mode == "after":
+                new_val = vfn(cls, fval)
+                if new_val is not None:
+                    object.__setattr__(model, fname, new_val)
+                    values[fname] = new_val
+
+    # ``getattr(..., None)`` is ``Any | None``, so the default has to be applied
+    # before the ``.get`` rather than inside it.
+    model_validators = getattr(cls, "_model_validators", None) or {}
+    for validator_fn in model_validators.get("after", []):
+        result = validator_fn(model)
+        if result is not None and result is not model:
+            for attr_k, attr_v in result.__dict__.items():
+                object.__setattr__(model, attr_k, attr_v)
+
+
+def _install_field_guard(cls: type) -> None:
+    """Chain :func:`run_field_guard` onto the class's ``__post_init__``.
+
+    ``__post_init__`` is the one hook a generated ``__init__`` always calls, so
+    it is where a ``@dataclass`` subclass gets the same coercion and validation
+    a ``DomainModel``-initialised model does. A user-defined ``__post_init__``
+    is preserved and runs after the guard.
+
+    Args:
+        cls: The subclass being created.
+    """
+    existing = cls.__dict__.get("__post_init__")
+    if getattr(existing, "_quadkit_field_guard", False):
+        return
+
+    def __post_init__(self: Any) -> None:  # noqa: N807 — the hook name is fixed by dataclasses
+        run_field_guard(self)
+        if existing is not None:
+            existing(self)
+
+    __post_init__._quadkit_field_guard = True  # type: ignore[attr-defined]
+    cls.__post_init__ = __post_init__  # type: ignore[attr-defined]
+
+
 class DomainModel:
     """Mixin providing dataclass-like helpers for easy serialization.
 
@@ -155,6 +262,10 @@ class DomainModel:
         hints = resolve_type_hints(cls)
         cls._cached_type_hints = hints if hints else None
 
+        # `@dataclass` replaces `__init__`, so the coercion, constraint and
+        # validator work below has to be reachable from the generated one.
+        _install_field_guard(cls)
+
     @staticmethod
     def _ensure_dataclass(target_cls: type) -> None:
         """Auto-apply @dataclass if annotations have unconverted Field objects.
@@ -237,6 +348,9 @@ class DomainModel:
         for k in extra_keys:
             object.__setattr__(self, k, kwargs.pop(k))
 
+        # The guard has already run on this path; the marker keeps the chained
+        # `__post_init__` from repeating (and re-applying) the same work.
+        object.__setattr__(self, _GUARD_DONE_ATTR, True)
         if hasattr(self, "__post_init__"):
             self.__post_init__()
 
@@ -270,9 +384,13 @@ class DomainModel:
                 val = _coerce_value(fname, val, type_hints, f)
                 values[fname] = val
             elif f.default is not MISSING:
-                values[fname] = f.default
+                # Coerced like a provided value: the guard path (a generated
+                # `__init__` followed by `__post_init__`) coerces whatever the
+                # default left on the instance, so this path has to as well or
+                # the two disagree about a defaulted field's type.
+                values[fname] = _coerce_value(fname, f.default, type_hints, f)
             elif f.default_factory is not MISSING:
-                values[fname] = f.default_factory()
+                values[fname] = _coerce_value(fname, f.default_factory(), type_hints, f)
             elif fname == "id":
                 values[fname] = None
             else:
@@ -314,7 +432,18 @@ class DomainModel:
         dc_fields: dict[str, Any],
         values: dict[str, Any],
     ) -> None:
-        """Validate field values against metadata constraints."""
+        """Validate field values against metadata constraints.
+
+        **A default is not exempt.** ``name: str = Field(default="", min_length=3)``
+        is a contradiction the *declaration* contains, and the framework answers
+        it by refusing to construct the model — for a caller who omits the field
+        exactly as for one who passes the same value. Silently accepting the
+        default would let a constraint the model documents be violated by the
+        value the model itself supplies, which is how a `ge=0` counter ends up
+        negative in production. The failure is loud and points at the
+        declaration, and the two construction paths agree on it because both
+        check whatever value the field ended up holding.
+        """
         for fname, f in dc_fields.items():
             meta = getattr(f, "metadata", None)
             if not meta:

quadkit-0.0.45/src/quadkit/domain/models/coercion.py

@@ -0,0 +1,67 @@
+"""Scalar-coercion helpers for domain models.
+
+Hosts the implementation of ``DomainModel.model_validate`` (extracted from
+:mod:`quadkit.domain.models.base`). The annotation resolver it relies on lives
+in :mod:`quadkit.primitives.typing` and is re-exported here for the call sites
+that have always imported it from this module.
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+# The annotation resolver lives in `quadkit.primitives.typing` because it is not
+# a domain concern: `quadkit.mapping` needs the same answer ("what types does
+# this model declare") to match a source object's fields against a dataclass
+# destination, and two resolvers would eventually disagree.
+from quadkit.primitives.typing import resolve_type_hints as resolve_type_hints
+
+__all__ = ["coerce_and_build", "resolve_type_hints"]
+
+
+def coerce_and_build(cls: type[Any], data: dict[str, Any]) -> Any:
+    """Build *cls* from *data* through the same guard as direct construction.
+
+    ``model_validate`` — the hydration path ``GenericRepository`` and every
+    ``from_dict``-shaped caller goes through — used to run a narrow coercion
+    table of its own (int/float/str/bool) and then ``cls(**coerced)``. On a
+    plain ``@dataclass`` subclass that bypasses everything ``DomainModel``
+    promises:
+
+    * a row's ISO timestamp stayed a ``str``, because ``datetime`` was never in
+      the table;
+    * an unknown column raised a bare ``TypeError: unexpected keyword
+      argument`` instead of landing in ``model_extra``;
+    * ``Field(...)`` constraints and the field/model validators never ran, so a
+      ``Field(min_length=...)`` declaration was documentation, not a check.
+
+    Delegating to ``DomainModel.__init__`` — the path a directly constructed
+    model already takes — fixes all three by deleting the second
+    implementation rather than extending it. One guard, one behaviour:
+    ``Model.model_validate(row)`` and ``Model(**row)`` now agree.
+
+    Args:
+        cls: The domain model class being validated.
+        data: Raw field values (e.g. a database row or a decoded JSON body).
+
+    Returns:
+        A new instance of *cls*.
+
+    Raises:
+        ValidationError: If required fields are missing or a declared
+            constraint or field validator rejects a value.
+    """
+    import dataclasses as _dc
+
+    if not _dc.is_dataclass(cls):
+        return cls(**data)
+
+    # Imported here: ``base`` imports this module at class-creation time.
+    from quadkit.domain.models.base import DomainModel
+
+    instance = cls.__new__(cls)
+    # ``cls`` is only known to be a dataclass here, so the freshly allocated
+    # instance has to be named as the ``DomainModel`` it is about to be
+    # initialised as before its ``__init__`` can be called directly.
+    DomainModel.__init__(cast("DomainModel", instance), **data)
+    return instance

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/identity/ambient.py

@@ -66,6 +66,23 @@ def install(implementation: IdGeneratorProtocol) -> None:
     _ambient.set(implementation)
 
 
+def current() -> IdGeneratorProtocol:
+    """Return the active identity generator.
+
+    The counterpart of ``quadkit.primitives.clock.current()``: an application
+    that publishes the ambient capability on its DI container binds *this*
+    resolver, not a captured instance, so ``install()`` and ``use()`` stay
+    visible to every consumer. Binding a snapshot would make a test's
+    ``use(...)`` override reach the code that calls ``new_uuid()`` directly
+    while missing the code that resolves the protocol — one process, two
+    generators.
+
+    Returns:
+        The ``IdGeneratorProtocol`` implementation currently installed.
+    """
+    return _ambient.get()
+
+
 def generate_for(entity_type: str) -> str:
     """Generate a time-ordered ID for the given entity type.
 
@@ -120,6 +137,7 @@ def use(implementation: IdGeneratorProtocol) -> Iterator[None]:
 
 
 __all__ = [
+    "current",
     "generate_for",
     "install",
     "new_uuid",

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/logging/processors.py

@@ -6,11 +6,24 @@ per-logger level filtering, and deterministic log sampling.
 
 from __future__ import annotations
 
+from collections.abc import Callable, MutableMapping
 from dataclasses import dataclass, field
 import hashlib
 import threading
 from typing import Any
 
+#: A structlog processor that takes and returns a mapping.
+#:
+#: ``structlog.typing.Processor`` is deliberately not used: its return union
+#: also admits ``str``/``bytes``/``tuple``, none of which support the ``.items()``
+#: this module performs on the result. The parameter and return are
+#: ``MutableMapping`` rather than ``dict`` because that is what structlog's own
+#: processors declare -- ``dict`` is invariant, so narrowing here would reject
+#: every real processor, ``CallsiteParameterAdder`` included.
+_MappingProcessor = Callable[
+    [Any, str, MutableMapping[str, Any]], MutableMapping[str, Any]
+]
+
 import structlog
 
 from quadkit.logging import get_logger
@@ -18,6 +31,13 @@ from quadkit.logging.redaction import get_redactor
 
 logger = get_logger(__name__)
 _otel_warned = [False]
+
+#: Sentinel for "the opentelemetry import has not been attempted yet". Kept
+#: distinct from ``None`` (import attempted, not available) so the negative
+#: result is remembered instead of re-searched on every log event.
+_OTEL_UNRESOLVED = object()
+_otel_state: list[Any] = [_OTEL_UNRESOLVED]
+
 from quadkit.logging.types import _LOGLEVEL_TO_INT, LogLevel
 
 # ---------------------------------------------------------------------------
@@ -78,24 +98,37 @@ def _redact_processor(
     return get_redactor().redact_dict(event_dict)
 
 
+def _resolve_otel_trace() -> Any | None:
+    """Return ``opentelemetry.trace`` once, or ``None`` when it is absent.
+
+    Resolution happens once per process and the answer — including "not
+    installed" — is remembered. A failed import is *not* cached by the import
+    system: every retry re-searches ``sys.path`` on disk, which measured as
+    roughly a third of the per-request cost of the health endpoint because
+    this processor runs for every log event. Losing the trace context is a
+    degraded mode, not a reason to stat the filesystem on each log line.
+    """
+    if _otel_state[0] is _OTEL_UNRESOLVED:
+        try:
+            # Dotted import: opentelemetry is a PEP-420 namespace package, so
+            # ``from opentelemetry import trace`` does not type-check against
+            # its stubs; PLR0402 prefers the from-form.
+            import opentelemetry.trace as trace  # noqa: PLR0402
+
+            _otel_state[0] = trace
+        except ImportError:
+            _otel_state[0] = None
+    return _otel_state[0]
+
+
 def _otel_processor(
     logger: Any,
     method_name: str,
     event_dict: dict[str, Any],
 ) -> dict[str, Any]:
     """Inject OpenTelemetry trace and span IDs into the event dict."""
-    try:
-        # Dotted import: opentelemetry is a PEP-420 namespace package, so
-        # ``from opentelemetry import trace`` does not type-check against its
-        # stubs; PLR0402 prefers the from-form.
-        import opentelemetry.trace as trace  # noqa: PLR0402
-
-        span = trace.get_current_span()
-        if span and span.get_span_context().is_valid:
-            ctx = span.get_span_context()
-            event_dict["trace_id"] = format(ctx.trace_id, "032x")
-            event_dict["span_id"] = format(ctx.span_id, "016x")
-    except ImportError:
+    trace = _resolve_otel_trace()
+    if trace is None:
         if not _otel_warned[0]:
             _otel_warned[0] = True
             # No kwargs here: this warning can be the first log call of the
@@ -105,6 +138,13 @@ def _otel_processor(
                 "opentelemetry_not_installed; install opentelemetry-api for "
                 "trace_id/span_id injection into log events"
             )
+        return event_dict
+
+    span = trace.get_current_span()
+    if span and span.get_span_context().is_valid:
+        ctx = span.get_span_context()
+        event_dict["trace_id"] = format(ctx.trace_id, "032x")
+        event_dict["span_id"] = format(ctx.span_id, "016x")
     return event_dict
 
 
@@ -135,7 +175,7 @@ class _NamespacedCallsiteAdder:
     #: Keys structlog's adder may consult on the stdlib-bridge path.
     _PASSTHROUGH = ("_record", "_from_structlog")
 
-    def __init__(self, inner: Any) -> None:
+    def __init__(self, inner: _MappingProcessor) -> None:
         self._inner = inner
 
     def __call__(

{quadkit-0.0.44 → quadkit-0.0.45}/src/quadkit/mapping/config.py

@@ -27,7 +27,25 @@ class MappingConfig(BaseConfig):
     )
     auto_map: bool = Field(
         default=True,
-        description="Fall back to auto-mapping when no explicit mapper is registered.",
+        description=(
+            "Fall back to auto-mapping in map_or_auto() when no explicit mapper "
+            "is registered."
+        ),
+    )
+    ignore_unknown: bool = Field(
+        default=True,
+        description=(
+            "Drop source fields the destination does not declare. Set False to "
+            "raise MappingExecutionError instead, so a shape mismatch on either "
+            "side of the mapping fails loudly."
+        ),
+    )
+    case_sensitive: bool = Field(
+        default=True,
+        description=(
+            "Match source keys to destination fields case-sensitively. Set "
+            "False to match `Name` to `name`."
+        ),
     )