python-ddd-framework 0.3.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

python_ddd_framework/services/framework_provider.py

@@ -1,178 +1,23 @@
-"""组装平台自有依赖与 scoped proxy；业务贡献仍由原生 Dishka 管理。"""
+"""通用组装事实进入原生 Dishka；具体能力的注册由模块拥有。"""
 
-from __future__ import annotations
+from dishka import Provider, Scope
 
-from dishka import (
-    Provider,
-    Scope,
-)
-
-from ..application_services import ApplicationServiceCatalog
-from ..application_services.dispatcher import _ApplicationServiceDispatcher, _proxy_factory
-from ..application_services.invocation import (
-    _InvocationRuntime,
-    _ScopedApplicationServiceInvoker,
-)
-from ..auditing.control import AuditingControl
-from ..authorization import CurrentUser, PermissionCatalog
-from ..background_jobs import BackgroundJobCatalog
-from ..background_workers import BackgroundWorkerCatalog
-from ..background_workers.runtime import _BackgroundCoordinator
-from ..caching import CacheCatalog
 from ..configuration import ConfigurationRoot
-from ..events import AggregateEventCollector, LocalEventBus, LocalEventCatalog
-from ..hosted_services import HostedServiceCatalog
-from ..hosted_services.runtime import _HostedServiceCoordinator
-from ..invocation import ApplicationInvocationContext, BackgroundSystemCaller
-from ..invocation.interception import _EntryInterceptionCatalog
 from ..modularity import ModuleRegistry
-from ..notifications import NotificationCatalog
 from ..options import Options, OptionsSnapshot
-from ..settings import SettingCatalog
-from ..unit_of_work import UnitOfWork, UnitOfWorkManager, UnitOfWorkOptions
-from ..unit_of_work.contracts import _UnitOfWorkFactory
 
 
 def _framework_provider(
     *,
     registry: ModuleRegistry,
-    has_unit_of_work_factory: bool,
-    entry_interceptors: _EntryInterceptionCatalog,
     configuration: ConfigurationRoot,
     options: OptionsSnapshot,
-    invocation_runtime: _InvocationRuntime,
-    application_service_catalog: ApplicationServiceCatalog,
-    event_catalog: LocalEventCatalog,
-    permission_catalog: PermissionCatalog,
-    cache_catalog: CacheCatalog,
-    setting_catalog: SettingCatalog,
-    notification_catalog: NotificationCatalog,
-    background_worker_catalog: BackgroundWorkerCatalog,
-    background_job_catalog: BackgroundJobCatalog,
-    background_coordinator: _BackgroundCoordinator,
-    hosted_service_catalog: HostedServiceCatalog,
-    hosted_service_coordinator: _HostedServiceCoordinator,
 ) -> Provider:
-    """框架自身 contract 直接进入 Dishka；不写入业务 ServiceCatalog 第二清单。"""
     provider = Provider()
-    provider.provide(
-        lambda: entry_interceptors, provides=_EntryInterceptionCatalog, scope=Scope.APP
-    )
-    provider.provide(AuditingControl, scope=Scope.APP)
-    _provide_unit_of_work(provider, has_unit_of_work_factory)
     provider.provide(lambda: registry, provides=ModuleRegistry, scope=Scope.APP)
     provider.provide(lambda: configuration, provides=ConfigurationRoot, scope=Scope.APP)
     provider.provide(lambda: options, provides=OptionsSnapshot, scope=Scope.APP)
-    # Dishka 原生 context binding 直接发布已冻结实例，保持每个 Application 的唯一 snapshot。
+    # 已冻结 Options 是唯一配置解释结果；容器仅发布实例，不再绑定或建立配置旁路。
     for model_type in options.values:
         provider.from_context(provides=Options[model_type], scope=Scope.APP)  # type: ignore[valid-type]
-    provider.provide(
-        lambda: invocation_runtime,
-        provides=_InvocationRuntime,
-        scope=Scope.APP,
-    )
-    provider.provide(
-        lambda: application_service_catalog,
-        provides=ApplicationServiceCatalog,
-        scope=Scope.APP,
-    )
-    provider.provide(lambda: event_catalog, provides=LocalEventCatalog, scope=Scope.APP)
-    provider.provide(lambda: permission_catalog, provides=PermissionCatalog, scope=Scope.APP)
-    provider.provide(lambda: cache_catalog, provides=CacheCatalog, scope=Scope.APP)
-    provider.provide(lambda: setting_catalog, provides=SettingCatalog, scope=Scope.APP)
-    provider.provide(lambda: notification_catalog, provides=NotificationCatalog, scope=Scope.APP)
-    provider.provide(
-        lambda: background_worker_catalog,
-        provides=BackgroundWorkerCatalog,
-        scope=Scope.APP,
-    )
-    provider.provide(
-        lambda: background_job_catalog,
-        provides=BackgroundJobCatalog,
-        scope=Scope.APP,
-    )
-    provider.provide(
-        lambda: background_coordinator,
-        provides=_BackgroundCoordinator,
-        scope=Scope.APP,
-    )
-    provider.provide(
-        lambda: hosted_service_catalog,
-        provides=HostedServiceCatalog,
-        scope=Scope.APP,
-    )
-    provider.provide(
-        lambda: hosted_service_coordinator,
-        provides=_HostedServiceCoordinator,
-        scope=Scope.APP,
-    )
-    provider.provide(
-        lambda: background_coordinator.system_caller,
-        provides=BackgroundSystemCaller,
-        scope=Scope.APP,
-    )
-    provider.provide(
-        _current_user,
-        provides=CurrentUser,
-        scope=Scope.REQUEST,
-    )
-    provider.from_context(provides=ApplicationInvocationContext, scope=Scope.ACTION)
-    provider.provide(
-        _ApplicationServiceDispatcher,
-        provides=_ApplicationServiceDispatcher,
-        scope=Scope.REQUEST,
-    )
-    provider.provide(
-        _ScopedApplicationServiceInvoker,
-        provides=_ScopedApplicationServiceInvoker,
-        scope=Scope.APP,
-    )
-    for registration in application_service_catalog.registrations:
-        if not registration.is_public_service:
-            continue
-        provider.provide(
-            _proxy_factory(application_service_catalog._for_registration(registration)),
-            provides=registration.contract,
-            scope=Scope.REQUEST,
-        )
-    provider.provide(LocalEventBus, provides=LocalEventBus, scope=Scope.REQUEST)
-    provider.provide(
-        AggregateEventCollector,
-        provides=AggregateEventCollector,
-        scope=Scope.ACTION,
-    )
-    for worker_type in {item.worker_type for item in background_worker_catalog.definitions}:
-        if isinstance(worker_type, type):
-            provider.provide(worker_type, provides=worker_type, scope=Scope.ACTION)
-    for handler_type in {item.handler_type for item in background_job_catalog.definitions}:
-        if isinstance(handler_type, type):
-            provider.provide(handler_type, provides=handler_type, scope=Scope.ACTION)
     return provider
-
-
-def _current_user(invocation_runtime: _InvocationRuntime) -> CurrentUser:
-    # CurrentUser 只来自当前 Application 的 task-local request context。
-    return invocation_runtime.current_user()
-
-
-def _unit_of_work_manager(
-    runtime: _InvocationRuntime,
-    factory: _UnitOfWorkFactory,
-    options: Options[UnitOfWorkOptions],
-    catalog: LocalEventCatalog,
-) -> UnitOfWorkManager:
-    return UnitOfWorkManager(runtime, factory, options.value, catalog)
-
-
-def _current_unit_of_work(manager: UnitOfWorkManager) -> UnitOfWork:
-    return manager.require_current()
-
-
-def _provide_unit_of_work(
-    provider: Provider,
-    has_unit_of_work_factory: bool,
-) -> None:
-    if not has_unit_of_work_factory:
-        provider.provide(_UnitOfWorkFactory, scope=Scope.APP)
-    provider.provide(_unit_of_work_manager, provides=UnitOfWorkManager, scope=Scope.APP)
-    provider.provide(_current_unit_of_work, provides=UnitOfWork, scope=Scope.ACTION, cache=False)

python_ddd_framework/services/native_graph.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Iterator, Mapping
 from dataclasses import dataclass
 from typing import get_origin
 
@@ -11,16 +11,12 @@ from dishka import (
     AsyncContainer,
     BaseScope,
     DependencyKey,
-    Scope,
+    Provider,
 )
 from dishka.dependency_source import Factory
 from dishka.entities.factory_type import FactoryType
 
-from ..application_services import ApplicationService, ApplicationServiceCatalog
-from ..application_services.errors import ApplicationServiceDefinitionError
-from ..application_services.interceptors import InterceptionStage
 from ..errors import CatalogNativeGraphMismatchError, InvalidConventionDefinitionError
-from ..invocation.interception import _EntryInterceptionCatalog
 from .arbitration import (
     _RegistrationDraft,
 )
@@ -41,9 +37,14 @@ class _NativeGraphRegistration:
 class _NativeServiceGraph:
     """只读投影 Dishka 已构建图，用于证明 catalog 与真实容器一致。"""
 
-    __slots__ = ("_rows",)
+    __slots__ = ("_method_decorators", "_rows")
 
-    def __init__(self, container: AsyncContainer) -> None:
+    def __init__(self, container: AsyncContainer, decorators: tuple[Provider, ...] = ()) -> None:
+        self._method_decorators = {
+            id(decorator.factory.source)
+            for provider in decorators
+            for decorator in provider.decorators
+        }
         rows: list[_NativeGraphRegistration] = []
         native_registry = container.registry
         while True:
@@ -61,6 +62,26 @@ class _NativeServiceGraph:
             native_registry = child_registry
         self._rows = tuple(rows)
 
+    def __iter__(self) -> Iterator[_NativeGraphRegistration]:
+        return iter(self._rows)
+
+    def effective_factory(self, row: _NativeGraphRegistration) -> Factory:
+        factory = self._undecorated_factory(row.factory)
+        # Alias 自身不缓存；只沿 Dishka 已验证的链读取实际实例 owner。
+        while factory.type is FactoryType.ALIAS:
+            factory = self._undecorated_factory(
+                next(item.factory for item in self._rows if item.key == factory.dependencies[0])
+            )
+        return factory
+
+    def _undecorated_factory(self, factory: Factory) -> Factory:
+        # 注册核对保留 alias 身份；实例 owner 核对才继续追踪 alias。
+        while id(factory.source) in self._method_decorators:
+            factory = next(
+                item.factory for item in self._rows if item.key == factory.dependencies[0]
+            )
+        return factory
+
     def differences(self, drafts: tuple[_RegistrationDraft, ...]) -> tuple[str, ...]:
         return tuple(
             f"missing accepted {draft.contribution.kind.value} registration for {draft.key}"
@@ -77,18 +98,10 @@ class _NativeServiceGraph:
                 if scope is None or not isinstance(candidate, type):
                     continue
                 _validate_fixed_lifetime(candidate)
-                if (
-                    issubclass(candidate, ApplicationService)
-                    and row.key.component == DEFAULT_COMPONENT
-                ):
-                    # 公开 REQUEST proxy 由框架提供；其实际实现已移入私有 ACTION component。
-                    continue
-                factory = row.factory
-                # Alias 自身不缓存；沿 Dishka 已验证的链核对真正创建实例的 factory。
-                while factory.type is FactoryType.ALIAS:
-                    factory = next(
-                        item.factory for item in self._rows if item.key == factory.dependencies[0]
-                    )
+                if candidate is row.key.type_hint and row.key.component == DEFAULT_COMPONENT:
+                    # 具有代理的角色分别声明公开入口与实际实现的生命周期。
+                    scope = getattr(candidate, "_public_service_scope", scope)
+                factory = self.effective_factory(row)
                 if row.scope is not scope or not factory.cache:
                     raise InvalidConventionDefinitionError(
                         symbol=str(row.key.type_hint),
@@ -115,17 +128,6 @@ class _NativeServiceGraph:
             None,
         )
 
-    def implementation_for(self, target: type[object]) -> type[object]:
-        key = DependencyKey(target, DEFAULT_COMPONENT)
-        while True:
-            factory = next(row.factory for row in self._rows if row.key == key)
-            if factory.type is FactoryType.ALIAS:
-                # 原生图已验证 alias 链及循环；沿真实依赖取得最终 class factory。
-                key = factory.dependencies[0]
-                continue
-            # 动态工厂只承诺注册契约，不能在 build 执行它来猜测运行实例。
-            return factory.source if isinstance(factory.source, type) else target
-
     def _matches(self, draft: _RegistrationDraft) -> bool:
         if draft.is_collection:
             return any(
@@ -144,45 +146,18 @@ class _NativeServiceGraph:
             return any(
                 row.key.type_hint == draft.key.type_hint
                 and row.key.component == draft.key.component
-                and row.factory.source is draft.factory.source
+                and self._undecorated_factory(row.factory).source is draft.factory.source
                 and row.scope is draft.scope
                 for row in self._rows
             )
         return any(
             row.key == draft.key
-            and row.factory.source is draft.factory.source
+            and self._undecorated_factory(row.factory).source is draft.factory.source
             and row.scope is draft.scope
             for row in self._rows
         )
 
 
-def _validate_interceptors(
-    graph: _NativeServiceGraph,
-    catalog: ApplicationServiceCatalog,
-    entries: _EntryInterceptionCatalog,
-) -> None:
-    # 匹配结果和实际入口 scope 来自同一编译 catalog，不另建后台类型或规则清单。
-    requirements = (
-        (
-            registration,
-            Scope.ACTION if registration.before is InterceptionStage.METHOD else Scope.REQUEST,
-        )
-        for service in catalog.registrations
-        for method in service.methods
-        for registration in method.interceptors
-    )
-    for registration, available in (*requirements, *entries.interceptor_scopes):
-        scope = graph.interceptor_scope(registration.interceptor)
-        if scope not in (Scope.APP, Scope.REQUEST, Scope.ACTION) or scope > available:
-            raise ApplicationServiceDefinitionError(
-                symbol=registration.interceptor.__qualname__,
-                reason=(
-                    f"interceptor scope is unavailable before {registration.before.value}; "
-                    f"owner={registration.owner}"
-                ),
-            )
-
-
 def _accepted_single_service_scopes(
     drafts: tuple[_RegistrationDraft, ...],
     native_graph: _NativeServiceGraph,

python_ddd_framework/services/provider.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from types import MethodType
+from typing import TypeVar, get_origin
 
 from dishka import BaseScope, DependencyKey, Provider
 from dishka.dependency_source import Alias, Factory, FactoryUnionMode
@@ -12,6 +13,7 @@ from dishka.entities.marker import BoolMarker
 
 from ..diagnostics import SourceLocation
 from ..errors import RegistrationConflictError
+from ..modularity.contracts import ModuleDeclaration, _module_declarations
 from .registration import SUPPORTED_SCOPE_LABEL, SUPPORTED_SCOPES, RegistrationKind
 
 
@@ -27,6 +29,7 @@ class _FactorySignature:
     allow_static_evaluation: bool
     is_to_bind: bool
     native_override: bool
+    declarations: tuple[tuple[object, tuple[tuple[str, ModuleDeclaration], ...]], ...]
 
 
 @dataclass(frozen=True, slots=True)
@@ -42,6 +45,7 @@ class _CollectionSignature:
 class _ProviderSignature:
     factories: tuple[_FactorySignature, ...]
     collections: tuple[_CollectionSignature, ...]
+    decorators: tuple[tuple[object, ...], ...]
 
 
 @dataclass(frozen=True, slots=True)
@@ -71,14 +75,17 @@ class _ValidatedProvider:
 class _NativeProviderInspector:
     """隔离 Dishka private dependency-source shape，返回框架拥有的稳定事实。"""
 
-    __slots__ = ("_kind", "_source")
+    __slots__ = ("_kind", "_method_decorators", "_source")
 
-    def __init__(self, *, source: SourceLocation, kind: RegistrationKind) -> None:
+    def __init__(
+        self, *, source: SourceLocation, kind: RegistrationKind, method_decorators: bool = False
+    ) -> None:
         self._source = source
         self._kind = kind
+        self._method_decorators = method_decorators
 
     def inspect(self, provider: Provider) -> _ValidatedProvider:
-        if provider.decorators or provider.activators:
+        if (provider.decorators and not self._method_decorators) or provider.activators:
             raise RegistrationConflictError(
                 key=None,
                 sources=(self._source,),
@@ -93,6 +100,7 @@ class _NativeProviderInspector:
             or provider.factory_union_mode
             or provider.aliases
             or provider.context_vars
+            or provider.decorators
         ):
             raise RegistrationConflictError(
                 key=None,
@@ -127,6 +135,7 @@ class _NativeProviderInspector:
                     allow_static_evaluation=item.factory.allow_static_evaluation,
                     is_to_bind=item.factory.is_to_bind,
                     native_override=item.native_override,
+                    declarations=self._declarations(item.key.type_hint, item.factory.source),
                 )
                 for item in factories
             ),
@@ -140,9 +149,55 @@ class _NativeProviderInspector:
                 )
                 for item in collections
             ),
+            decorators=tuple(self._decorator_signature(item) for item in provider.decorators),
         )
         return _ValidatedProvider(factories, collections, signature)
 
+    def _decorator_signature(self, decorator: object) -> tuple[object, ...]:
+        from dishka.dependency_source.decorator import Decorator
+
+        assert isinstance(decorator, Decorator)
+        factory = decorator.factory
+        if (
+            decorator.scope is not None
+            or decorator.when is not None
+            or decorator.allow_static_evaluation
+            or (
+                decorator.generic
+                and (
+                    isinstance(decorator.provides.type_hint, TypeVar)
+                    or bool(getattr(decorator.provides.type_hint, "__parameters__", ()))
+                )
+            )
+            or factory.type is not FactoryType.FACTORY
+        ):
+            self._conflict(
+                decorator.provides, "managed method decorators must retain native scope/cache"
+            )
+        return (
+            decorator.provides,
+            self.source_identity(factory.source),
+            tuple(factory.dependencies),
+            tuple(sorted(factory.kw_dependencies.items())),
+            factory.provides,
+            factory.is_to_bind,
+        )
+
+    @staticmethod
+    def _declarations(
+        *candidates: object,
+    ) -> tuple[tuple[object, tuple[tuple[str, ModuleDeclaration], ...]], ...]:
+        result = []
+        for candidate in candidates:
+            candidate = get_origin(candidate) or candidate
+            if isinstance(candidate, type):
+                result.append((candidate, tuple(_module_declarations(candidate).items())))
+        return tuple(result)
+
+    def assert_unchanged(self, provider: Provider, signature: _ProviderSignature) -> None:
+        if self.inspect(provider).signature != signature:
+            self._conflict(None, "native Provider was mutated after contribution")
+
     def _inspect_factory(
         self,
         provider: Provider,
@@ -192,7 +247,7 @@ class _NativeProviderInspector:
             self._conflict(key, f"collection scope must be {SUPPORTED_SCOPE_LABEL}")
         return _CollectionDefinition(collection, source_key, key, collection.scope)
 
-    def _conflict(self, key: DependencyKey, reason: str) -> None:
+    def _conflict(self, key: DependencyKey | None, reason: str) -> None:
         raise RegistrationConflictError(key=key, sources=(self._source,), reason=reason)
 
     @staticmethod

python_ddd_framework/services/repository.py

@@ -2,6 +2,8 @@
 
 from typing import Protocol
 
+from dishka import Scope
+
 from ..errors import InvalidConventionDefinitionError
 from .convention_contracts import _SERVICE_DEFINITION_ATTRIBUTE, _ServiceDefinition
 from .exposure import _business_interfaces
@@ -11,6 +13,10 @@ class RepositoryContract(Protocol):
     """仓储接口的正式角色；实例由选中 Module 的 REQUEST scope 缓存。"""
 
 
+# 这是框架发现元数据，不是仓储实例的结构化成员契约。
+setattr(RepositoryContract, "_fixed_service_scope", Scope.REQUEST)  # noqa: B010 -- 不扩充 Protocol 成员
+
+
 def _repository_contract(candidate: type[object]) -> type[object] | None:
     if RepositoryContract not in candidate.__mro__:
         return None