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

python_ddd_framework/services/arbitration.py

@@ -47,6 +47,29 @@ class _ArbitrationResult:
     drafts: tuple[_RegistrationDraft, ...]
     ordered_entries: tuple[_ContributionEntry, ...]
 
+    def single_factory(self, key: DependencyKey) -> Factory | None:
+        """沿最终获选的原生 alias 查询构造事实，不实例化服务、不重复仲裁。"""
+        visited: set[DependencyKey] = set()
+        while key not in visited:
+            visited.add(key)
+            draft = next(
+                (
+                    item
+                    for item in self.drafts
+                    if item.key == key
+                    and item.decision is RegistrationDecision.ACCEPTED
+                    and item.contribution.kind is not RegistrationKind.MULTI
+                    and not item.is_collection
+                ),
+                None,
+            )
+            if draft is None or draft.factory is None:
+                return None
+            if draft.alias is None:
+                return draft.factory
+            key = draft.factory.dependencies[0]
+        return None
+
 
 class _ServiceArbitrator:
     """拥有一次 service policy decision；只修改尚未发布的 registration drafts。"""

python_ddd_framework/services/binding.py

@@ -6,7 +6,6 @@ from typing import Annotated
 
 from dishka import BaseScope, FromComponent, Provider
 
-from ..application_services.contracts import ApplicationService
 from ..diagnostics import SourceLocation
 from ..errors import RegistrationConflictError
 from .registration import RegistrationKind
@@ -49,12 +48,12 @@ def _registration_providers(
     kind = RegistrationKind.OVERRIDE if override else RegistrationKind.EXPLICIT
     provider = Provider(scope=scope, component=component)
     concrete = implementation or service
-    if issubclass(concrete, ApplicationService):
+    if any(role.__dict__.get("_requires_convention", False) for role in concrete.__mro__):
         raise RegistrationConflictError(
             key=None,
             sources=(source,),
             reason=(
-                "ApplicationService registration requires convention discovery "
+                f"{concrete.__qualname__} registration requires convention discovery "
                 "and its contract proxy"
             ),
         )

python_ddd_framework/services/composition.py

@@ -0,0 +1,108 @@
+"""能力模块参与最终服务图解释的扩展契约；容器仍由 Dishka 唯一创建。"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from dishka import AsyncContainer, Provider
+
+from ..configuration import ConfigurationRoot
+from ..diagnostics.source import caller_source
+from ..errors import ServiceContributorClosedError
+from ..modularity import ModuleDescriptor, ModuleKey, ModuleRegistry
+from ..modularity.discovery import _DiscoveredType
+from ..options import OptionsSnapshot
+from .convention_contracts import ConventionDiscoveryKind, _ServiceDefinition
+from .provider import _NativeProviderInspector, _ProviderSignature
+from .registration import RegistrationKind
+
+if TYPE_CHECKING:
+    from ..application import Application
+    from ..application.build_spec import _ApplicationBuildSpec
+    from .arbitration import _ArbitrationResult
+    from .contribution import ServiceContributionRegistry, _ContributionEntry
+    from .native_graph import _NativeServiceGraph
+
+
+@dataclass(frozen=True, slots=True)
+class ServiceConvention:
+    definition: _ServiceDefinition
+    kind: ConventionDiscoveryKind
+    reason: str
+
+
+@dataclass(frozen=True, slots=True)
+class ServiceDiscoveryContext:
+    modules: ModuleRegistry
+    discoveries: tuple[_DiscoveredType, ...]
+    services: ServiceContributionRegistry
+    conventions: dict[tuple[ModuleKey, type[object]], ServiceConvention]
+
+
+@dataclass(slots=True)
+class _ProviderRegistrationState:
+    closed: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class ServiceBindingContext:
+    descriptor: ModuleDescriptor
+    modules: ModuleRegistry
+    configuration: ConfigurationRoot
+    options: OptionsSnapshot
+    arbitration: _ArbitrationResult
+    _providers: list[Provider]
+    _provider_checks: list[
+        tuple[ModuleDescriptor, _NativeProviderInspector, Provider, _ProviderSignature]
+    ]
+    _decorators: list[Provider]
+    application: Application
+    build_spec: _ApplicationBuildSpec
+    _provider_registration: _ProviderRegistrationState = field(
+        default_factory=_ProviderRegistrationState
+    )
+
+    def add_provider(self, provider: Provider) -> None:
+        """派生目录只能增加绑定；替换必须在仲裁前经过正式 owner、依赖和原因校验。"""
+        if self._provider_registration.closed:
+            raise ServiceContributorClosedError(stage="final binding")
+        inspector = _NativeProviderInspector(
+            source=caller_source(str(self.descriptor.key), depth=2),
+            kind=RegistrationKind.EXPLICIT,
+        )
+        signature = inspector.inspect(provider).signature
+        self._providers.append(provider)
+        self._provider_checks.append((self.descriptor, inspector, provider, signature))
+
+    def _add_method_decorator(self, provider: Provider) -> None:
+        """仅供调用能力生成的同 scope 装饰；与普通贡献分别记录并核对指纹。"""
+        inspector = _NativeProviderInspector(
+            source=caller_source(str(self.descriptor.key), depth=2),
+            kind=RegistrationKind.EXPLICIT,
+            method_decorators=True,
+        )
+        signature = inspector.inspect(provider).signature
+        self._providers.append(provider)
+        self._decorators.append(provider)
+        self._provider_checks.append((self.descriptor, inspector, provider, signature))
+
+
+@dataclass(frozen=True, slots=True)
+class ServiceValidationContext:
+    binding: ServiceBindingContext
+    container: AsyncContainer
+    native_graph: _NativeServiceGraph
+
+
+@dataclass(frozen=True, slots=True)
+class ServiceComposition:
+    """只登记模块实际需要的阶段；回调及其捕获状态属于本次 build。"""
+
+    discover: Callable[[ServiceDiscoveryContext], None] | None = None
+    before_binding: Callable[[tuple[_ContributionEntry, ...]], None] | None = None
+    bind: Callable[[ServiceBindingContext], None] | None = None
+    finalize: Callable[[ServiceBindingContext], None] | None = None
+    decorate: Callable[[ServiceBindingContext], None] | None = None
+    validate: Callable[[ServiceValidationContext], None] | None = None

python_ddd_framework/services/contribution.py

@@ -2,25 +2,16 @@
 
 from __future__ import annotations
 
-import inspect
-from collections.abc import Callable
 from dataclasses import dataclass
 
 from dishka import BaseScope, Provider, Scope
 
-from ..application_services.catalog import ApplicationServiceMethod
-from ..application_services.errors import ApplicationServiceDefinitionError
-from ..application_services.interceptors import (
-    InterceptionStage,
-    Interceptor,
-    InterceptorRegistration,
-    _InterceptorRule,
-)
 from ..diagnostics import LifecycleStage, SourceLocation
 from ..diagnostics.source import caller_source
 from ..errors import RegistrationConflictError, ServiceContributorClosedError
 from ..modularity import ModuleDescriptor, ModuleKey
 from .binding import _collection_provider, _registration_providers
+from .composition import ServiceComposition
 from .provider import _NativeProviderInspector, _ProviderSignature
 from .registration import ProviderContribution, ProviderContributionView, RegistrationKind
 
@@ -67,6 +58,18 @@ class ServiceContributor:
             source=caller_source(str(self._descriptor.key), depth=2),
         )
 
+    def add_composition(self, composition: ServiceComposition) -> None:
+        """在 configure 登记最终绑定解释；不能从 post_configure 新增组装参与者。"""
+        if not self._active:
+            raise ServiceContributorClosedError(stage=self._stage.value)
+        if self._stage is not LifecycleStage.CONFIGURE:
+            raise RegistrationConflictError(
+                key=None,
+                sources=(caller_source(str(self._descriptor.key), depth=2),),
+                reason="service composition must be contributed during configure",
+            )
+        self._registry.add_composition(self._descriptor, composition)
+
     def add_singleton(
         self,
         service: type[object],
@@ -183,67 +186,54 @@ class ServiceContributor:
     def _close(self) -> None:
         self._active = False
 
-    def add_interceptor(
-        self,
-        interceptor: type[Interceptor],
-        *,
-        match: Callable[[ApplicationServiceMethod], bool],
-        before: InterceptionStage = InterceptionStage.METHOD,
-    ) -> None:
-        """只贡献匹配事实；类型及依赖仍通过原生 services 注册。"""
+    def require_active(self) -> None:
+        """能力扩展复用当前 hook 的有效期，不能持有 context 在屏障后继续贡献。"""
         if not self._active:
             raise ServiceContributorClosedError(stage=self._stage.value)
-        if (
-            not isinstance(interceptor, type)
-            or not issubclass(interceptor, Interceptor)
-            or inspect.isabstract(interceptor)
-            or not inspect.iscoroutinefunction(interceptor.intercept)
-        ):
-            raise ApplicationServiceDefinitionError(
-                symbol=str(interceptor), reason="interceptor must implement async intercept"
-            )
-        if (
-            not callable(match)
-            or inspect.iscoroutinefunction(match)
-            or not isinstance(before, InterceptionStage)
-        ):
-            raise ApplicationServiceDefinitionError(
-                symbol=interceptor.__qualname__,
-                reason="interceptor requires a synchronous match and valid position",
-            )
-        self._registry.add_interceptor_rule(
-            _InterceptorRule(
-                InterceptorRegistration(
-                    interceptor,
-                    before,
-                    self._descriptor.key,
-                    caller_source(str(self._descriptor.key), depth=2),
-                ),
-                match,
-            )
-        )
 
 
 class ServiceContributionRegistry:
     """一次 build 的 append-only collector；freeze 后只由仲裁流程读取。"""
 
-    __slots__ = ("_collections", "_declaration_counts", "_entries", "_frozen", "_interceptor_rules")
+    __slots__ = (
+        "_collections",
+        "_compositions",
+        "_declaration_counts",
+        "_entries",
+        "_frozen",
+    )
 
     def __init__(self) -> None:
         self._entries: list[_ContributionEntry] = []
         self._declaration_counts: dict[ModuleKey, int] = {}
         self._frozen = False
         self._collections: set[type[object]] = set()
-        self._interceptor_rules: list[_InterceptorRule] = []
+        self._compositions: list[tuple[ModuleDescriptor, ServiceComposition]] = []
 
-    def add_interceptor_rule(self, rule: _InterceptorRule) -> None:
+    def add_composition(
+        self, descriptor: ModuleDescriptor, composition: ServiceComposition
+    ) -> None:
         if self._frozen:
-            raise ServiceContributorClosedError(stage="interceptor")
-        self._interceptor_rules.append(rule)
+            raise ServiceContributorClosedError(stage="composition")
+        if not isinstance(composition, ServiceComposition):
+            raise TypeError("composition must be ServiceComposition")
+        callbacks = (
+            composition.discover,
+            composition.before_binding,
+            composition.bind,
+            composition.finalize,
+            composition.decorate,
+            composition.validate,
+        )
+        if not any(callback is not None for callback in callbacks):
+            raise ValueError("service composition must contribute at least one callback")
+        if any(callback is not None and not callable(callback) for callback in callbacks):
+            raise TypeError("service composition callbacks must be callable")
+        self._compositions.append((descriptor, composition))
 
     @property
-    def interceptor_rules(self) -> tuple[_InterceptorRule, ...]:
-        return tuple(self._interceptor_rules)
+    def compositions(self) -> tuple[tuple[ModuleDescriptor, ServiceComposition], ...]:
+        return tuple(self._compositions)
 
     def add_registration(
         self,

python_ddd_framework/services/convention.py

@@ -1,28 +1,17 @@
-"""受 Module-owned metadata 控制且完整可诊断的 Convention discovery。"""
+"""有界类型扫描及通用 DI 约定；能力规则由已启用模块贡献。"""
 
 from __future__ import annotations
 
 import inspect
 from collections.abc import Mapping
-from typing import cast
 
 from dishka import Provider, Scope
 
-from ..application_services.catalog import _DiscoveredApplicationService
-from ..application_services.contracts import (
-    _APPLICATION_SERVICE_DEFINITION_ATTRIBUTE,
-    ApplicationService,
-    _ApplicationServiceDefinition,
-)
-from ..application_services.contracts import (
-    _definition_for as _application_service_definition,
-)
-from ..application_services.errors import ApplicationServiceDefinitionError
-from ..diagnostics import SourceLocation
 from ..errors import ConventionScanError, InvalidConventionDefinitionError
 from ..modularity import ModuleKey, ModuleRegistry
 from ..modularity.discovery import _DiscoveredType, _is_concrete_implementation
 from .arbitration import _RegistrationDraft
+from .composition import ServiceConvention
 from .contribution import ServiceContributionRegistry
 from .convention_contracts import (
     _LIFETIME_MARKERS,
@@ -40,34 +29,20 @@ from .repository import _repository_contract
 
 
 class _ConventionScanner:
-    """拥有一次 Application scan 的顺序、去重状态和 candidate diagnostics。"""
-
-    __slots__ = (
-        "_application_services",
-        "_contributions",
-        "_discoveries",
-        "_event_handler_scopes",
-        "_lifetime_conflicts",
-        "_records",
-        "_registry",
-        "_scan_packages",
-    )
-
     def __init__(
         self,
         registry: ModuleRegistry,
         contributions: ServiceContributionRegistry,
         scan_packages: Mapping[ModuleKey, tuple[str, ...]],
         discoveries: tuple[_DiscoveredType, ...],
-        event_handler_scopes: Mapping[type[object], Scope],
+        conventions: Mapping[tuple[ModuleKey, type[object]], ServiceConvention],
     ) -> None:
-        self._discoveries = discoveries
-        self._event_handler_scopes = event_handler_scopes
         self._registry = registry
         self._contributions = contributions
         self._scan_packages = scan_packages
+        self._discoveries = discoveries
+        self._conventions = conventions
         self._records: list[ConventionCandidate] = []
-        self._application_services: list[_DiscoveredApplicationService] = []
         self._lifetime_conflicts: set[type[object]] = set()
 
     def validate_lifetimes(self, drafts: tuple[_RegistrationDraft, ...]) -> None:
@@ -86,6 +61,7 @@ class _ConventionScanner:
                 )
 
     def discover(self) -> tuple[ConventionCandidate, ...]:
+        self._registry.assert_declarations_unchanged()
         for descriptor in self._registry.dependency_order:
             if descriptor.module_type.scan_packages != self._scan_packages[descriptor.key]:
                 raise ConventionScanError(
@@ -95,160 +71,65 @@ class _ConventionScanner:
                     reason="scan_packages metadata was mutated after the Application snapshot",
                     original_error=None,
                 )
-        seen: dict[ModuleKey, set[type[object]]] = {}
+        seen: set[tuple[ModuleKey, type[object]]] = set()
         for discovery in self._discoveries:
-            self._record_candidate(discovery, seen.setdefault(discovery.owner, set()))
-        return tuple(self._records)
-
-    @property
-    def application_services(self) -> tuple[_DiscoveredApplicationService, ...]:
-        return tuple(self._application_services)
-
-    def _record_candidate(self, discovery: _DiscoveredType, seen_types: set[type[object]]) -> None:
-        candidate = discovery.candidate
-        source = discovery.source
-        owner = discovery.owner
-        package_name = discovery.package
-        definition, application_definition, discovered_by, reason = (
-            self._definition(candidate)
-            if _is_concrete_implementation(candidate)
-            else (None, None, ConventionDiscoveryKind.NONE, "not a concrete closed implementation")
-        )
-        if candidate in seen_types:
-            self._append_record(
-                owner,
-                package_name,
-                source,
-                discovered_by,
-                ConventionCandidateDecision.DUPLICATE,
-                "candidate already interpreted from an earlier scan package",
+            candidate = discovery.candidate
+            definition, kind, reason = (
+                self._definition(discovery)
+                if _is_concrete_implementation(candidate)
+                else (None, ConventionDiscoveryKind.NONE, "not a concrete closed implementation")
             )
-            return
-        seen_types.add(candidate)
-        if definition is None:
-            self._append_record(
-                owner,
-                package_name,
-                source,
-                discovered_by,
-                ConventionCandidateDecision.REJECTED,
-                reason,
-            )
-            return
-        provider = Provider(scope=definition.scope)
-        provider.provide(
-            candidate,
-            provides=definition.provides if definition.provides is not None else candidate,
-            scope=definition.scope,
-            cache=definition.cache,
-        )
-        if definition.provides is None:
-            for interface in _business_interfaces(candidate):
-                provider.alias(candidate, provides=interface, cache=False)
-        self._contributions.add_convention(
-            provider=provider,
-            owner=owner,
-            source=source,
-            reason=reason,
-        )
-        if application_definition is not None:
-            # 分层模块的公开契约由实际扫描它的 Module 拥有；实现 DI 的 owner 仍由上面的
-            # contribution 保留。HTTP 因此可只依赖 Contracts，不反向引用应用实现。
-            declarations = {
-                item.owner: item
-                for item in self._discoveries
-                if item.candidate is application_definition.contract
-            }
-            if len(declarations) > 1:
-                raise ApplicationServiceDefinitionError(
-                    symbol=str(application_definition.contract),
-                    reason="application service contract is scanned by multiple Modules",
+            key = (discovery.owner, candidate)
+            if key in seen:
+                decision = ConventionCandidateDecision.DUPLICATE
+                reason = "candidate already interpreted from an earlier scan package"
+            elif definition is None:
+                decision = ConventionCandidateDecision.REJECTED
+            else:
+                provider = Provider(scope=definition.scope)
+                provider.provide(
+                    candidate,
+                    provides=definition.provides if definition.provides is not None else candidate,
+                    scope=definition.scope,
+                    cache=definition.cache,
                 )
-            declaration = next(iter(declarations.values()), discovery)
-            self._application_services.append(
-                _DiscoveredApplicationService(
-                    service_type=cast(type[ApplicationService], candidate),
-                    definition=application_definition,
-                    owner=declaration.owner,
-                    source=declaration.source,
-                    declaration_index=len(self._application_services),
+                if definition.provides is None:
+                    for interface in _business_interfaces(candidate):
+                        provider.alias(candidate, provides=interface, cache=False)
+                self._contributions.add_convention(
+                    provider=provider,
+                    owner=discovery.owner,
+                    source=discovery.source,
+                    reason=reason,
+                )
+                decision = ConventionCandidateDecision.ACCEPTED
+            seen.add(key)
+            self._records.append(
+                ConventionCandidate(
+                    owner=discovery.owner,
+                    package=discovery.package,
+                    source=discovery.source,
+                    discovered_by=kind,
+                    decision=decision,
+                    reason=reason,
+                    ordinal=len(self._records),
                 )
             )
-        self._append_record(
-            owner,
-            package_name,
-            source,
-            discovered_by,
-            ConventionCandidateDecision.ACCEPTED,
-            reason,
-        )
-
-    def _append_record(
-        self,
-        owner: ModuleKey,
-        package: str,
-        source: SourceLocation,
-        discovered_by: ConventionDiscoveryKind,
-        decision: ConventionCandidateDecision,
-        reason: str,
-    ) -> None:
-        self._records.append(
-            ConventionCandidate(
-                owner=owner,
-                package=package,
-                source=source,
-                discovered_by=discovered_by,
-                decision=decision,
-                reason=reason,
-                ordinal=len(self._records),
-            )
-        )
+        return tuple(self._records)
 
     def _definition(
         self,
-        candidate: type[object],
-    ) -> tuple[
-        _ServiceDefinition | None,
-        _ApplicationServiceDefinition | None,
-        ConventionDiscoveryKind,
-        str,
-    ]:
+        discovery: _DiscoveredType,
+    ) -> tuple[_ServiceDefinition | None, ConventionDiscoveryKind, str]:
+        candidate = discovery.candidate
         _validate_fixed_lifetime(candidate)
         repository_contract = _repository_contract(candidate)
         if repository_contract is not None:
             return (
                 _ServiceDefinition(provides=repository_contract, scope=Scope.REQUEST),
-                None,
                 ConventionDiscoveryKind.FRAMEWORK_MARKER,
                 "accepted from unique inherited RepositoryContract",
             )
-        application_definition = _application_service_definition(candidate)
-        if application_definition is not None:
-            if _SERVICE_DEFINITION_ATTRIBUTE in candidate.__dict__:
-                raise ApplicationServiceDefinitionError(
-                    symbol=f"{candidate.__module__}.{candidate.__qualname__}",
-                    reason="application_service and service metadata cannot be combined",
-                )
-            decorated = _APPLICATION_SERVICE_DEFINITION_ATTRIBUTE in candidate.__dict__
-            discovered_by = (
-                ConventionDiscoveryKind.APPLICATION_SERVICE_DECORATOR
-                if decorated
-                else ConventionDiscoveryKind.FRAMEWORK_MARKER
-            )
-            reason = (
-                "accepted from immutable application_service decorator metadata"
-                if decorated
-                else "accepted from unique inherited ApplicationService contract"
-            )
-            return (
-                _ServiceDefinition(
-                    provides=application_definition.contract or candidate,
-                    scope=Scope.ACTION,
-                ),
-                application_definition,
-                discovered_by,
-                reason,
-            )
         metadata = candidate.__dict__.get(_SERVICE_DEFINITION_ATTRIBUTE)
         if metadata is not None:
             if not isinstance(metadata, _ServiceDefinition):
@@ -258,17 +139,12 @@ class _ConventionScanner:
                 )
             return (
                 metadata,
-                None,
                 ConventionDiscoveryKind.DECORATOR_METADATA,
                 "accepted from immutable service decorator metadata",
             )
-        if candidate in self._event_handler_scopes:
-            return (
-                _ServiceDefinition(provides=candidate, scope=self._event_handler_scopes[candidate]),
-                None,
-                ConventionDiscoveryKind.DECORATOR_METADATA,
-                "accepted from immutable local_event_handler metadata",
-            )
+        convention = self._conventions.get((discovery.owner, candidate))
+        if convention is not None:
+            return convention.definition, convention.kind, convention.reason
         lifetimes = tuple(
             (marker, scope, cache)
             for marker, scope, cache in _LIFETIME_MARKERS
@@ -276,25 +152,21 @@ class _ConventionScanner:
         )
         if lifetimes and not inspect.isabstract(candidate):
             if len(lifetimes) != 1:
-                # 冲突先挂起到统一仲裁后；若约定 factory 胜出，容器构建前必定拒绝。
-                # 显式覆盖链可以让它退让，扫描阶段不自行挑选有效注册。
+                # 冲突等最终仲裁确认：显式注册可替代约定，约定本身胜出则必须拒绝。
                 self._lifetime_conflicts.add(candidate)
             marker, scope, cache = lifetimes[0]
             return (
                 _ServiceDefinition(provides=None, scope=scope, cache=cache),
-                None,
                 ConventionDiscoveryKind.FRAMEWORK_MARKER,
                 f"accepted from {marker.__name__} marker",
             )
         if issubclass(candidate, ConventionalService) and candidate is not ConventionalService:
             return (
                 _ServiceDefinition(provides=candidate, scope=Scope.APP),
-                None,
                 ConventionDiscoveryKind.FRAMEWORK_MARKER,
                 "accepted from ConventionalService marker",
             )
         return (
-            None,
             None,
             ConventionDiscoveryKind.NONE,
             "rejected because no service decorator metadata or framework marker exists",

python_ddd_framework/services/fixed_lifetime.py

@@ -2,32 +2,29 @@
 
 from dishka import Scope
 
-from ..application_services.contracts import ApplicationService
-from ..background_jobs.contracts import BackgroundJobHandler
-from ..background_workers.contracts import BackgroundWorker
 from ..errors import InvalidConventionDefinitionError
-from ..hosted_services.contracts import HostedService
 from .convention_contracts import (
     _LIFETIME_MARKERS,
     _SERVICE_DEFINITION_ATTRIBUTE,
     _ServiceDefinition,
 )
-from .repository import RepositoryContract
 
 
 def _fixed_scope(candidate: object) -> Scope | None:
     if not isinstance(candidate, type):
         return None
-    for role, scope in (
-        (ApplicationService, Scope.ACTION),
-        (RepositoryContract, Scope.REQUEST),
-        (HostedService, Scope.APP),
-        (BackgroundJobHandler, Scope.ACTION),
-        (BackgroundWorker, Scope.ACTION),
-    ):
-        if role in candidate.__mro__:
-            return scope
-    return None
+    # 生命周期由角色自身声明，内核不维护能力类型的第二份名单。
+    scopes = {
+        scope
+        for role in candidate.__mro__
+        if (scope := role.__dict__.get("_fixed_service_scope")) is not None
+    }
+    if len(scopes) > 1 or any(not isinstance(scope, Scope) for scope in scopes):
+        raise InvalidConventionDefinitionError(
+            symbol=candidate.__qualname__,
+            reason="conflicting fixed role lifetimes",
+        )
+    return next(iter(scopes), None)
 
 
 def _validate_fixed_lifetime(candidate: type[object]) -> None: