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

python_ddd_framework/services/runtime.py

@@ -1,228 +1,104 @@
-"""Dishka container 构建、native graph 核对与 catalog 发布。"""
+"""模块贡献、最终绑定仲裁与原生容器构建；不枚举具体能力。"""
 
 from __future__ import annotations
 
 from collections.abc import Mapping
-from dataclasses import dataclass
-from typing import get_origin
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, get_origin
 
-from dishka import (
-    DEFAULT_COMPONENT,
-    STRICT_VALIDATION,
-    AsyncContainer,
-    DependencyKey,
-    make_async_container,
-)
+from dishka import STRICT_VALIDATION, AsyncContainer, make_async_container
 
-from ..application_services import ApplicationServiceCatalog
-from ..application_services.catalog import (
-    _build_application_service_catalog,
-)
-from ..application_services.invocation import (
-    _InvocationRuntime,
-)
-from ..authorization import 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 ..errors import CatalogNativeGraphMismatchError, ContainerValidationError
-from ..events import LocalEventCatalog
-from ..events.catalog import _build_event_catalog, _validate_event_scopes
-from ..events.contribution import EventContributionRegistry
-from ..events.discovery import _discover_event_handlers
-from ..hosted_services import HostedServiceCatalog
-from ..hosted_services.catalog import (
-    _validate_hosted_service_drafts,
-    _validate_hosted_service_entries,
-)
-from ..hosted_services.runtime import _HostedServiceCoordinator
-from ..invocation.entries import _validate_callable_entries
-from ..invocation.interception import _EntryInterceptionCatalog
-from ..modularity import ModuleKey, ModuleRegistry
-from ..modularity.discovery import _DiscoveredType
-from ..notifications import NotificationCatalog
+from ..modularity import ModuleDescriptor, ModuleKey, ModuleRegistry
+from ..modularity.discovery import _DiscoveredType, _require_type_dependencies
 from ..options import Options, OptionsSnapshot
-from ..settings import SettingCatalog
-from ..settings.binding import _provide_settings
-from ..settings.store import RuntimeSettingStore
-from ..unit_of_work.contracts import _UnitOfWorkFactory
-from .application_bindings import (
-    _bind_application_services,
-    _runtime_providers,
-    _validate_application_service_dependencies,
-)
-from .arbitration import (
-    _RegistrationDraft,
-    _ServiceArbitrator,
+from .arbitration import _RegistrationDraft, _ServiceArbitrator
+from .composition import (
+    ServiceBindingContext,
+    ServiceComposition,
+    ServiceDiscoveryContext,
+    ServiceValidationContext,
 )
 from .contribution import ServiceContributionRegistry
 from .convention import _ConventionScanner
 from .convention_contracts import ConventionCandidate
-from .framework_provider import (
-    _framework_provider,
-)
-from .native_graph import (
-    _accepted_single_service_scopes,
-    _NativeServiceGraph,
-    _validate_interceptors,
-)
-from .registration import (
-    RegistrationDecision,
-    RegistrationKind,
-    ServiceCatalog,
-    ServiceRegistration,
-)
+from .framework_provider import _framework_provider
+from .native_graph import _NativeServiceGraph
+from .provider import _NativeProviderInspector
+from .registration import RegistrationDecision, ServiceCatalog, ServiceRegistration
+
+if TYPE_CHECKING:
+    from ..application import Application
+    from ..application.build_spec import _ApplicationBuildSpec
 
 
 @dataclass(frozen=True, slots=True)
 class _ServiceRuntime:
     catalog: ServiceCatalog
-    application_service_catalog: ApplicationServiceCatalog
-    event_catalog: LocalEventCatalog
     container: AsyncContainer
 
 
 class _ServiceRuntimeBuilder:
-    """完成一次 Application-local scan、仲裁、容器构建和诊断快照发布。"""
-
-    __slots__ = (
-        "_background_coordinator",
-        "_background_job_catalog",
-        "_background_worker_catalog",
-        "_cache_catalog",
-        "_configuration",
-        "_contributions",
-        "_discoveries",
-        "_event_contributions",
-        "_hosted_service_catalog",
-        "_hosted_service_coordinator",
-        "_invocation_runtime",
-        "_notification_catalog",
-        "_options",
-        "_permission_catalog",
-        "_registry",
-        "_scan_packages",
-        "_setting_catalog",
-    )
-
     def __init__(
         self,
         registry: ModuleRegistry,
         contributions: ServiceContributionRegistry,
-        event_contributions: EventContributionRegistry,
         scan_packages: Mapping[ModuleKey, tuple[str, ...]],
         discoveries: tuple[_DiscoveredType, ...],
         configuration: ConfigurationRoot,
         options: OptionsSnapshot,
-        invocation_runtime: _InvocationRuntime,
-        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,
+        application: Application,
+        build_spec: _ApplicationBuildSpec,
     ) -> None:
         self._registry = registry
         self._contributions = contributions
-        self._event_contributions = event_contributions
         self._scan_packages = scan_packages
         self._discoveries = discoveries
         self._configuration = configuration
         self._options = options
-        self._invocation_runtime = invocation_runtime
-        self._permission_catalog = permission_catalog
-        self._cache_catalog = cache_catalog
-        self._setting_catalog = setting_catalog
-        self._notification_catalog = notification_catalog
-        self._background_worker_catalog = background_worker_catalog
-        self._background_job_catalog = background_job_catalog
-        self._background_coordinator = background_coordinator
-        self._hosted_service_catalog = hosted_service_catalog
-        self._hosted_service_coordinator = hosted_service_coordinator
+        self._application = application
+        self._build_spec = build_spec
 
     def build(self) -> _ServiceRuntime:
-        event_handler_scopes = _discover_event_handlers(
+        compositions = self._contributions.compositions
+        discovery = ServiceDiscoveryContext(
             self._registry,
             self._discoveries,
-            self._event_contributions,
+            self._contributions,
+            {},
         )
+        for _, composition in compositions:
+            if composition.discover is not None:
+                composition.discover(discovery)
         scanner = _ConventionScanner(
             self._registry,
             self._contributions,
             self._scan_packages,
             self._discoveries,
-            event_handler_scopes,
+            discovery.conventions,
         )
         convention_candidates = scanner.discover()
         entries = self._contributions.freeze()
-        _validate_hosted_service_entries(entries, self._hosted_service_catalog)
+        for _, composition in compositions:
+            if composition.before_binding is not None:
+                composition.before_binding(entries)
         arbitration = _ServiceArbitrator(self._registry).arbitrate(entries)
         scanner.validate_lifetimes(arbitration.drafts)
-        _validate_hosted_service_drafts(arbitration.drafts, self._hosted_service_catalog)
-        bound_application_services = _bind_application_services(
-            scanner.application_services,
-            arbitration.drafts,
-        )
-        _validate_application_service_dependencies(
-            self._registry, bound_application_services, arbitration.drafts
-        )
-        application_service_catalog = _build_application_service_catalog(
-            tuple(item.binding for item in bound_application_services),
-            self._permission_catalog,
-            self._contributions.interceptor_rules,
-        )
-        event_catalog = _build_event_catalog(
+        binding = ServiceBindingContext(
+            self._registry.dependency_order[-1],
             self._registry,
-            self._event_contributions,
-        )
-        entry_interceptors = _EntryInterceptionCatalog(
-            event_catalog,
-            self._contributions.interceptor_rules,
-            self._background_worker_catalog,
-            self._background_job_catalog,
-        )
-        framework_provider = _framework_provider(
-            entry_interceptors=entry_interceptors,
-            has_unit_of_work_factory=any(
-                draft.key.type_hint is _UnitOfWorkFactory for draft in arbitration.drafts
-            ),
-            registry=self._registry,
-            options=self._options,
-            invocation_runtime=self._invocation_runtime,
-            application_service_catalog=application_service_catalog,
-            event_catalog=event_catalog,
-            permission_catalog=self._permission_catalog,
-            cache_catalog=self._cache_catalog,
-            setting_catalog=self._setting_catalog,
-            notification_catalog=self._notification_catalog,
-            background_worker_catalog=self._background_worker_catalog,
-            background_job_catalog=self._background_job_catalog,
-            background_coordinator=self._background_coordinator,
-            hosted_service_catalog=self._hosted_service_catalog,
-            hosted_service_coordinator=self._hosted_service_coordinator,
-            configuration=self._configuration,
-        )
-        _provide_settings(
-            framework_provider,
-            self._setting_catalog,
             self._configuration,
-            # Alias 的 scope 由原生图解析，不能以 draft.scope 是否已知遗漏有效 binding。
-            has_store=any(
-                draft.key == DependencyKey(RuntimeSettingStore, DEFAULT_COMPONENT)
-                and draft.decision is RegistrationDecision.ACCEPTED
-                and draft.contribution.kind is not RegistrationKind.MULTI
-                and not draft.is_collection
-                for draft in arbitration.drafts
-            ),
+            self._options,
+            arbitration,
+            list(arbitration.providers),
+            [],
+            [],
+            self._application,
+            self._build_spec,
         )
-        runtime_providers = _runtime_providers(arbitration, bound_application_services)
+        self._bind_capabilities(binding, compositions)
         try:
-            # Options 的唯一 owner 是阶段绑定快照；手工 provider 也不能为未声明类型创建旁路。
             if any(
                 draft.key.type_hint is Options or get_origin(draft.key.type_hint) is Options
                 for draft in arbitration.drafts
@@ -231,8 +107,12 @@ class _ServiceRuntimeBuilder:
                     "Options bindings must come from Module configuration declarations"
                 )
             container = make_async_container(
-                *runtime_providers,
-                framework_provider,
+                *binding._providers,
+                _framework_provider(
+                    registry=self._registry,
+                    configuration=self._configuration,
+                    options=self._options,
+                ),
                 context={
                     Options[model_type]: Options(value)  # type: ignore[valid-type]
                     for model_type, value in self._options.values.items()
@@ -240,63 +120,97 @@ class _ServiceRuntimeBuilder:
                 validation_settings=STRICT_VALIDATION,
             )
         except Exception as original_error:
-            error = ContainerValidationError(
+            raise ContainerValidationError(
                 sources=tuple(entry.contribution.source for entry in arbitration.ordered_entries),
                 original_error=original_error,
-            )
-            raise error from original_error
-
-        native_graph = _NativeServiceGraph(container)
+            ) from original_error
+        native_graph = _NativeServiceGraph(container, tuple(binding._decorators))
         native_graph.validate_fixed_lifetimes()
-        _validate_event_scopes(
-            event_catalog,
-            _accepted_single_service_scopes(arbitration.drafts, native_graph),
-        )
-        _validate_interceptors(native_graph, application_service_catalog, entry_interceptors)
-        _validate_callable_entries(
-            container,
-            self._background_job_catalog,
-            self._background_worker_catalog,
-            event_catalog,
-            event_implementations={
-                item.handler_type: native_graph.implementation_for(item.handler_type)
-                for item in event_catalog.subscriptions
-                if isinstance(item.handler_type, type)
-            },
-        )
         differences = native_graph.differences(arbitration.drafts)
         if differences:
             raise CatalogNativeGraphMismatchError(differences=differences)
+        for descriptor, composition in compositions:
+            if composition.validate is not None:
+                composition.validate(
+                    ServiceValidationContext(
+                        replace(binding, descriptor=descriptor), container, native_graph
+                    )
+                )
         return _ServiceRuntime(
-            catalog=self._freeze_catalog(
-                arbitration.drafts,
-                native_graph,
-                convention_candidates,
-            ),
-            application_service_catalog=application_service_catalog,
-            event_catalog=event_catalog,
-            container=container,
+            self._freeze_catalog(arbitration.drafts, native_graph, convention_candidates),
+            container,
         )
 
+    @staticmethod
+    def _bind_capabilities(
+        binding: ServiceBindingContext,
+        compositions: tuple[tuple[ModuleDescriptor, ServiceComposition], ...],
+    ) -> None:
+        # 必须先裁决替换链，再解释能力的最终实现与 scope，避免 Catalog 保存落选事实。
+        for descriptor, composition in compositions:
+            if composition.bind is not None:
+                composition.bind(replace(binding, descriptor=descriptor))
+        # 入口来自所有能力的最终绑定；统一屏障后冻结，容器只消费已确定的事实。
+        for descriptor, composition in compositions:
+            if composition.finalize is not None:
+                composition.finalize(replace(binding, descriptor=descriptor))
+        # 所有派生绑定已完成后才装饰，不能漏掉后继能力 finalize 提供的服务。
+        # replace 生成的各 owner 视图共享准入状态，捕获旧 context 也不能迟到贡献。
+        binding._provider_registration.closed = True
+        for descriptor, composition in compositions:
+            if composition.decorate is not None:
+                composition.decorate(replace(binding, descriptor=descriptor))
+        _ServiceRuntimeBuilder._validate_final_contributions(binding)
+
+    @staticmethod
+    def _validate_final_contributions(binding: ServiceBindingContext) -> None:
+        # 回调不得在仲裁后修改原生贡献，也不得通过派生 Provider 偷渡 override。
+        for entry in binding.arbitration.ordered_entries:
+            contribution = entry.contribution
+            _NativeProviderInspector(
+                source=contribution.source, kind=contribution.kind
+            ).assert_unchanged(contribution.provider, entry.signature)
+        for draft in binding.arbitration.drafts:
+            if draft.decision is RegistrationDecision.ACCEPTED and draft.factory is not None:
+                for candidate in (draft.key.type_hint, draft.factory.source):
+                    _require_type_dependencies(
+                        binding.modules,
+                        draft.contribution.owner,
+                        candidate,
+                        source=draft.contribution.source,
+                    )
+        for descriptor, inspector, provider, signature in binding._provider_checks:
+            inspector.assert_unchanged(provider, signature)
+            for item in inspector.inspect(provider).factories:
+                for candidate in (item.key.type_hint, item.factory.source):
+                    _require_type_dependencies(
+                        binding.modules,
+                        descriptor.key,
+                        candidate,
+                        source=descriptor.declaration_source,
+                    )
+
     @staticmethod
     def _freeze_catalog(
         drafts: tuple[_RegistrationDraft, ...],
         native_graph: _NativeServiceGraph,
         convention_candidates: tuple[ConventionCandidate, ...],
     ) -> ServiceCatalog:
-        registrations = tuple(
-            ServiceRegistration(
-                key=draft.key,
-                scope=native_graph.scope_for(draft),
-                owner=draft.contribution.owner,
-                source=draft.contribution.source,
-                kind=draft.contribution.kind,
-                declaration_index=draft.contribution.declaration_index,
-                decision=draft.decision,
-                decision_reason=draft.decision_reason,
-                replaced_sources=draft.replaced_sources,
-                multi_ordinal=draft.multi_ordinal,
-            )
-            for draft in sorted(drafts, key=lambda item: item.sequence)
+        return ServiceCatalog(
+            tuple(
+                ServiceRegistration(
+                    key=draft.key,
+                    scope=native_graph.scope_for(draft),
+                    owner=draft.contribution.owner,
+                    source=draft.contribution.source,
+                    kind=draft.contribution.kind,
+                    declaration_index=draft.contribution.declaration_index,
+                    decision=draft.decision,
+                    decision_reason=draft.decision_reason,
+                    replaced_sources=draft.replaced_sources,
+                    multi_ordinal=draft.multi_ordinal,
+                )
+                for draft in sorted(drafts, key=lambda item: item.sequence)
+            ),
+            convention_candidates,
         )
-        return ServiceCatalog(registrations, convention_candidates)

python_ddd_framework/settings/catalog.py

@@ -10,6 +10,7 @@ from ..diagnostics import SourceLocation
 from ..modularity import ModuleRegistry
 from ..modularity.discovery import _DiscoveredType
 from .contracts import SettingDefinition
+from .declarations import SettingHandlers
 from .definition_discovery import _collect_setting_definitions
 from .errors import SettingDefinitionError
 from .handlers import SettingHandlerDefinition
@@ -87,8 +88,8 @@ def _build_setting_catalog(
 ) -> SettingCatalog:
     definitions, sources = _collect_setting_definitions(discoveries)
     handlers: list[SettingHandlerDefinition[Any]] = []
-    for descriptor in registry.dependency_order:
-        declared_handlers = descriptor.module_type.setting_handler_definitions
+    for descriptor, declaration in registry.declarations(SettingHandlers):
+        declared_handlers = declaration.definitions
         if not isinstance(declared_handlers, tuple):
             raise SettingDefinitionError(
                 setting=str(descriptor.key), reason="setting_handler_definitions must be a tuple"
@@ -105,8 +106,8 @@ def _contribute_setting_handler_defaults(
 
     # 声明只拥有 handler 与 setting 的关系；实例和依赖仍交给原生 Dishka APP binding。
     registered: set[type[object]] = set()
-    for descriptor in registry.dependency_order:
-        for definition in descriptor.module_type.setting_handler_definitions:
+    for descriptor, declaration in registry.declarations(SettingHandlers):
+        for definition in declaration.definitions:
             handler_type = definition.handler_type
             if handler_type in registered:
                 continue

python_ddd_framework/settings/declarations.py

@@ -0,0 +1,18 @@
+"""Settings handler 的关系声明；实例和生命周期仍由原生 DI 管理。"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..modularity import AppModule, ModuleDeclaration
+from .handlers import SettingHandlerDefinition
+
+
+@dataclass(frozen=True, slots=True)
+class SettingHandlers(ModuleDeclaration):
+    definitions: tuple[SettingHandlerDefinition[Any], ...]
+
+    @property
+    def required_module(self) -> type[AppModule]:
+        from .module import SettingsModule
+
+        return SettingsModule

python_ddd_framework/settings/definitions.py

@@ -6,11 +6,16 @@ from abc import ABC, abstractmethod
 from typing import Any
 
 from ..diagnostics import SourceLocation
+from ..modularity import ModuleRef, ModuleRequirement
 from .contracts import SettingDefinition
 from .errors import SettingDefinitionError
 
 
 class SettingDefinitionProvider(ABC):
+    __settings_module__ = ModuleRequirement(
+        ModuleRef("python_ddd_framework.settings.module:SettingsModule")
+    )
+
     @abstractmethod
     def define(self, context: SettingDefinitionContext) -> None:
         """向所属 Application 贡献定义；必须同步完成并返回 None。"""

python_ddd_framework/settings/manager.py

@@ -47,7 +47,7 @@ class SettingManager:
         await self.reset(definition, expected_version=current.version)
 
     async def update(
-        self, definition: SettingDefinition[_T], value: object, *, expected_version: UUID | None
+        self, definition: SettingDefinition[_T], value: _T, *, expected_version: UUID | None
     ) -> SettingWriteOutcome[_T]:
         self._catalog.require_owned(definition)
         try:

python_ddd_framework/settings/module.py

@@ -1,9 +1,58 @@
 """Provider-neutral 的 Settings 管理服务与权限贡献。"""
 
-from ..modularity import AppModule
+from dishka import DEFAULT_COMPONENT, DependencyKey, Provider, Scope
+
+from ..lifecycle import ConfigureContext
+from ..modularity import AppModule, ModuleRef
+from ..services.composition import (
+    ServiceBindingContext,
+    ServiceComposition,
+    ServiceDiscoveryContext,
+)
+from ..services.registration import RegistrationDecision, RegistrationKind
+from .binding import _provide_settings
+from .catalog import SettingCatalog, _build_setting_catalog, _contribute_setting_handler_defaults
+from .store import RuntimeSettingStore
+
+
+class SettingsModule(AppModule):
+    catalog: SettingCatalog
+
+    def configure(self, context: ConfigureContext) -> None:
+        self.catalog = _build_setting_catalog(context.modules, context.discoveries)
+        if self.catalog.definitions:
+            context.configure.section("settings")
+        context.services.add_composition(
+            ServiceComposition(discover=self._discover, bind=self._bind)
+        )
+
+    def _discover(self, context: ServiceDiscoveryContext) -> None:
+        _contribute_setting_handler_defaults(context.modules, context.services)
+
+    def _bind(self, context: ServiceBindingContext) -> None:
+        provider = Provider()
+        provider.provide(lambda: self.catalog, provides=SettingCatalog, scope=Scope.APP)
+        # 存储能力只由最终原生绑定决定；alias 也是有效绑定，不能按 provider 名称推断。
+        _provide_settings(
+            provider,
+            self.catalog,
+            context.configuration,
+            has_store=any(
+                draft.key == DependencyKey(RuntimeSettingStore, DEFAULT_COMPONENT)
+                and draft.decision is RegistrationDecision.ACCEPTED
+                and draft.contribution.kind is not RegistrationKind.MULTI
+                and not draft.is_collection
+                for draft in context.arbitration.drafts
+            ),
+        )
+        context.add_provider(provider)
 
 
 class SettingsManagementModule(AppModule):
+    dependencies = (
+        SettingsModule,
+        ModuleRef("python_ddd_framework.application_services.module:ApplicationServicesModule"),
+    )
     scan_packages = (
         "python_ddd_framework.settings.application",
         "python_ddd_framework.settings.permissions",

python_ddd_framework/settings/notifications.py

@@ -7,6 +7,8 @@ from contextlib import AsyncExitStack
 from ..lifecycle import PreInitializeContext, ShutdownContext
 from ..modularity import AppModule
 from ..notifications import Notifications
+from ..notifications.declarations import NotificationDefinitions
+from ..notifications.module import NotificationsModule
 from .changes import SETTINGS_CHANGED, SettingChanged
 from .manager import SettingManager
 from .refresh import SettingsRefreshRuntime
@@ -14,8 +16,8 @@ from .refresh_module import SettingsRefreshModule
 
 
 class SettingsNotificationsModule(AppModule):
-    dependencies = (SettingsRefreshModule,)
-    notification_definitions = (SETTINGS_CHANGED,)
+    dependencies = (SettingsRefreshModule, NotificationsModule)
+    notification_definitions = NotificationDefinitions((SETTINGS_CHANGED,))
 
     def __init__(self) -> None:
         self._subscriptions = AsyncExitStack()

python_ddd_framework/settings/refresh_module.py

@@ -6,21 +6,28 @@ from dishka import DEFAULT_COMPONENT, DependencyKey
 
 from python_ddd_framework import ConfigureContext
 
+from ..hosted_services.declarations import HostedServices
 from ..lifecycle import PreInitializeContext, ShutdownContext
-from ..modularity import AppModule
+from ..modularity import AppModule, ModuleRef
 from .catalog import SettingCatalog
 from .manager import SettingManager
+from .module import SettingsModule
 from .refresh import SettingsRefreshOptions, SettingsRefreshRuntime
 
 
 class SettingsRefreshModule(AppModule):
+    dependencies = (
+        SettingsModule,
+        ModuleRef("python_ddd_framework.hosted_services.module:HostedServicesModule"),
+    )
+
     def __init__(self) -> None:
         self._manager: SettingManager | None = None
 
     def configure(self, context: ConfigureContext) -> None:
         context.configure(SettingsRefreshOptions, section="settings_refresh")
 
-    hosted_services = (SettingsRefreshRuntime,)
+    hosted_services = HostedServices((SettingsRefreshRuntime,))
 
     async def pre_initialize(self, context: PreInitializeContext) -> None:
         catalog = await context.container.get(SettingCatalog)

python_ddd_framework/settings/sqlalchemy/module.py

@@ -11,6 +11,7 @@ from ...sqlalchemy import (
     SqlAlchemyPersistenceModule,
     contributes_sqlalchemy_models,
 )
+from ..module import SettingsModule
 from ..store import RuntimeSettingStore
 from .models import RuntimeSettingsBase
 from .store import SqlAlchemyRuntimeSettingStore
@@ -24,7 +25,7 @@ from .store import SqlAlchemyRuntimeSettingStore
     )
 )
 class SqlAlchemyRuntimeSettingsModule(AppModule):
-    dependencies = (SqlAlchemyPersistenceModule,)
+    dependencies = (SqlAlchemyPersistenceModule, SettingsModule)
 
     def configure(self, context: ConfigureContext) -> None:
         provider = Provider()

python_ddd_framework/sqlalchemy/__init__.py

@@ -12,6 +12,13 @@ from .errors import (
     SqlAlchemyModelRegistrationError,
     UnknownSqlAlchemyConnectionError,
 )
+from .extensions import (
+    ExtensionColumn,
+    SqlAlchemyExtensionMapping,
+    SqlAlchemyExtensionMigrations,
+    SqlAlchemyExtensionModel,
+    SqlAlchemyModelExtension,
+)
 from .metadata import (
     SqlAlchemyMigrationContribution,
     SqlAlchemyMigrationRegistration,
@@ -31,9 +38,13 @@ from .session_provider import SqlAlchemySessionProvider
 __all__ = (
     "AuditedEntityMixin",
     "ConnectionStringsOptions",
+    "ExtensionColumn",
     "FrameworkAsyncSession",
     "MigrationHeadsMismatchError",
     "SqlAlchemyConnectionError",
+    "SqlAlchemyExtensionMapping",
+    "SqlAlchemyExtensionMigrations",
+    "SqlAlchemyExtensionModel",
     "SqlAlchemyMetadataChangedError",
     "SqlAlchemyMigrationContribution",
     "SqlAlchemyMigrationError",
@@ -42,6 +53,7 @@ __all__ = (
     "SqlAlchemyMigrator",
     "SqlAlchemyModelCatalog",
     "SqlAlchemyModelContribution",
+    "SqlAlchemyModelExtension",
     "SqlAlchemyModelRegistration",
     "SqlAlchemyModelRegistrationError",
     "SqlAlchemyPersistenceModule",