python-platform 0.1.1__py3-none-any.whl

python_platform/settings/refresh.py

@@ -0,0 +1,140 @@
+"""单进程 Settings 刷新 owner：合并读取、串行应用、失败后按周期重试。"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+from pydantic import ConfigDict, Field
+
+from ..application_services.invocation import _InvocationRuntime
+from ..hosted_services import HostedService, HostedServiceContext
+from ..lifecycle import ShutdownReason
+from ..observability.context import capture_trace_context, invocation_span
+from ..options import BaseOptions, Options
+from .contracts import SettingDefinition
+from .handlers import SettingApplicationStatus, SettingHandler
+from .provider import SettingProvider
+from .values import SettingSnapshot, SettingValueSource
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SettingsRefreshOptions(BaseOptions):
+    model_config = ConfigDict(extra="forbid")
+
+    reconciliation_interval_seconds: float = Field(default=30.0, gt=0)
+
+
+@dataclass(slots=True)
+class _ApplicationRecord:
+    handler: SettingHandler[Any]
+    last_applied: SettingSnapshot[Any] | None = None
+    error_type: str | None = None
+
+
+class SettingsRefreshRuntime(HostedService):
+    run_in_background_processes: ClassVar[bool] = True
+
+    def __init__(
+        self,
+        settings: SettingProvider,
+        options: Options[SettingsRefreshOptions],
+        runtime: _InvocationRuntime,
+    ) -> None:
+        self._settings = settings
+        self._options = options.value
+        self._runtime = runtime
+        self._definitions: dict[str, SettingDefinition[Any]] = {}
+        self._records: dict[str, list[_ApplicationRecord]] = {}
+        self._dirty: dict[str, dict[str, str]] = {}
+        self._wakeup = asyncio.Event()
+        self._task: asyncio.Task[None] | None = None
+
+    def _register(self, definition: SettingDefinition[Any], handler: SettingHandler[Any]) -> None:
+        self._definitions[definition.name] = definition
+        self._records.setdefault(definition.name, []).append(_ApplicationRecord(handler))
+
+    def request_refresh(self, name: str | None = None) -> None:
+        if name is None:
+            for key in self._definitions:
+                self._dirty.setdefault(key, {})
+        elif name in self._definitions:
+            self._dirty[name] = capture_trace_context(self._runtime.tracer)
+        if self._dirty:
+            self._wakeup.set()
+
+    @property
+    def statuses(self) -> tuple[SettingApplicationStatus, ...]:
+        return tuple(
+            SettingApplicationStatus(
+                name,
+                f"{type(record.handler).__module__}.{type(record.handler).__qualname__}",
+                record.last_applied,
+                record.error_type,
+            )
+            for name, records in self._records.items()
+            for record in records
+        )
+
+    async def start(self, context: HostedServiceContext) -> None:
+        self.request_refresh()
+        self._task = asyncio.create_task(self._run(), name=context.name)
+
+    async def stop(self, reason: ShutdownReason) -> None:
+        if self._task is not None:
+            self._task.cancel()
+            with suppress(asyncio.CancelledError):
+                await self._task
+
+    async def _run(self) -> None:
+        if not self._definitions:
+            await asyncio.Future[None]()
+        while True:
+            try:
+                await asyncio.wait_for(
+                    self._wakeup.wait(), timeout=self._options.reconciliation_interval_seconds
+                )
+            except TimeoutError:
+                self.request_refresh()
+            # 取走本轮名字后立即清理；await 期间到达的新请求进入下一轮，不能被误清除。
+            requests = tuple(self._dirty.items())
+            self._dirty.clear()
+            self._wakeup.clear()
+            for name, carrier in requests:
+                with invocation_span(
+                    self._runtime.tracer, f"refresh setting {name}", carrier=carrier
+                ):
+                    await self._refresh(name)
+
+    async def _refresh(self, name: str) -> None:
+        try:
+            latest = await self._settings.snapshot(self._definitions[name])
+        except Exception as error:
+            for record in self._records[name]:
+                record.error_type = type(error).__name__
+            _LOGGER.error("Settings refresh failed for %s: %s", name, type(error).__name__)
+            return
+        for record in self._records[name]:
+            previous = record.last_applied
+            if (
+                previous is not None
+                and record.error_type is None
+                and previous.value == latest.value
+                and (previous.source is SettingValueSource.UNSET)
+                == (latest.source is SettingValueSource.UNSET)
+            ):
+                continue
+            try:
+                with invocation_span(self._runtime.tracer, f"apply setting {name}"):
+                    await record.handler.apply(latest)
+            except Exception as error:
+                # 失败不能覆盖成功记录，下一次校对仍会按最后成功应用的值决定重试。
+                record.error_type = type(error).__name__
+                _LOGGER.error("Settings handler failed for %s: %s", name, record.error_type)
+            else:
+                record.last_applied = latest
+                record.error_type = None

python_platform/settings/refresh_module.py

@@ -0,0 +1,45 @@
+"""只组装正式 handler 与刷新运行时；组件应用规则由 handler 自己拥有。"""
+
+from __future__ import annotations
+
+from dishka import DEFAULT_COMPONENT, DependencyKey
+
+from python_platform import ConfigureContext
+
+from ..lifecycle import PreInitializeContext, ShutdownContext
+from ..modularity import AppModule
+from .catalog import SettingCatalog
+from .manager import SettingManager
+from .refresh import SettingsRefreshOptions, SettingsRefreshRuntime
+
+
+class SettingsRefreshModule(AppModule):
+    def __init__(self) -> None:
+        self._manager: SettingManager | None = None
+
+    def configure(self, context: ConfigureContext) -> None:
+        context.configure(SettingsRefreshOptions, section="settings_refresh")
+
+    hosted_services = (SettingsRefreshRuntime,)
+
+    async def pre_initialize(self, context: PreInitializeContext) -> None:
+        catalog = await context.container.get(SettingCatalog)
+        refresh = await context.container.get(SettingsRefreshRuntime)
+        for definition in catalog.handlers:
+            handler = await context.container.get(definition.handler_type)
+            refresh._register(definition.setting, handler)
+        # Manager 固定归 APP；查询最终原生图，含 alias，不构造服务或维护第二清单。
+        # 无存储仍应用只读值；已注册服务由原生 get 解析，构造失败不能降级。
+        if (
+            context.container.registry.get_factory(DependencyKey(SettingManager, DEFAULT_COMPONENT))
+            is not None
+        ):
+            settings = await context.container.get(SettingManager)
+            settings._refresh = refresh
+            self._manager = settings
+
+    async def shutdown(self, context: ShutdownContext) -> None:
+        # 只解除本实例完成的接线；启动部分失败后的关闭不得重新构造依赖。
+        if self._manager is not None:
+            self._manager._refresh = None
+            self._manager = None

python_platform/settings/sqlalchemy/__init__.py

@@ -0,0 +1,5 @@
+"""Global Runtime Settings 的 SQLAlchemy provider。"""
+
+from .module import SqlAlchemyRuntimeSettingsModule
+
+__all__ = ("SqlAlchemyRuntimeSettingsModule",)

python_platform/settings/sqlalchemy/migrations/0001_platform_settings.py

@@ -0,0 +1,31 @@
+"""Create the independent platform settings migration branch."""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "platform_settings_0001"
+down_revision = None
+branch_labels = ("platform_settings",)
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "platform_runtime_settings",
+        sa.Column("setting_name", sa.String(length=200), nullable=False),
+        sa.Column("value_json", sa.Text(), nullable=False),
+        sa.Column("revision", sa.BigInteger(), nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("created_by", sa.Uuid(), nullable=True),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("updated_by", sa.Uuid(), nullable=True),
+        sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column("deleted_by", sa.Uuid(), nullable=True),
+        sa.PrimaryKeyConstraint("setting_name"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("platform_runtime_settings")

python_platform/settings/sqlalchemy/migrations/0002_physical_delete.py

@@ -0,0 +1,32 @@
+"""Settings 重置物理删除覆盖值；历史软删除数据必须先由操作者处理。"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+from python_platform.sqlalchemy.errors import SoftDeleteMigrationBlockedError
+
+revision = "platform_settings_0002"
+down_revision = "platform_settings_0001"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    connection = op.get_bind()
+    connection.execute(sa.text("LOCK TABLE platform_runtime_settings IN ACCESS EXCLUSIVE MODE"))
+    count = int(
+        connection.scalar(
+            sa.text("SELECT count(*) FROM platform_runtime_settings WHERE deleted_at IS NOT NULL")
+        )
+        or 0
+    )
+    if count:
+        raise SoftDeleteMigrationBlockedError((("platform_runtime_settings", count),))
+    op.drop_column("platform_runtime_settings", "deleted_at")
+    op.drop_column("platform_runtime_settings", "deleted_by")
+
+
+def downgrade() -> None:
+    raise RuntimeError("physical deletion cannot restore historical deleted records")

python_platform/settings/sqlalchemy/migrations/0003_version_tokens.py

@@ -0,0 +1,39 @@
+"""重置后保留版本令牌，覆盖值仍物理删除。"""
+
+from __future__ import annotations
+
+from uuid import uuid4
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "platform_settings_0003"
+down_revision = "platform_settings_0002"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    connection = op.get_bind()
+    connection.execute(sa.text("LOCK TABLE platform_runtime_settings IN ACCESS EXCLUSIVE MODE"))
+    versions = op.create_table(
+        "platform_runtime_setting_versions",
+        sa.Column("setting_name", sa.String(200), primary_key=True),
+        sa.Column("version", sa.Uuid(), nullable=False),
+    )
+    # 不导入当前 ORM model：历史 revision 的结构独立冻结，不随未来模型变化。
+    names = connection.execute(sa.text("SELECT setting_name FROM platform_runtime_settings"))
+    for (name,) in names:
+        connection.execute(versions.insert().values(setting_name=name, version=uuid4()))
+    op.create_foreign_key(
+        "fk_runtime_setting_version",
+        "platform_runtime_settings",
+        "platform_runtime_setting_versions",
+        ["setting_name"],
+        ["setting_name"],
+    )
+    op.drop_column("platform_runtime_settings", "revision")
+
+
+def downgrade() -> None:
+    raise RuntimeError("removing version tokens would allow stale settings writes")

python_platform/settings/sqlalchemy/migrations/__init__.py

@@ -0,0 +1 @@
+"""Platform settings Alembic branch。"""

python_platform/settings/sqlalchemy/models.py

@@ -0,0 +1,36 @@
+"""Global Runtime Settings 的独立 metadata owner。"""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from sqlalchemy import ForeignKey, String, Text, Uuid
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+from ...sqlalchemy import AuditedEntityMixin
+
+
+class RuntimeSettingsBase(DeclarativeBase):
+    pass
+
+
+class RuntimeSettingRow(AuditedEntityMixin, RuntimeSettingsBase):
+    __tablename__ = "platform_runtime_settings"
+
+    setting_name: Mapped[str] = mapped_column(
+        String(200), ForeignKey("platform_runtime_setting_versions.setting_name"), primary_key=True
+    )
+    value_json: Mapped[str] = mapped_column(Text, nullable=False)
+
+
+class RuntimeSettingVersionRow(RuntimeSettingsBase):
+    __tablename__ = "platform_runtime_setting_versions"
+
+    setting_name: Mapped[str] = mapped_column(String(200), primary_key=True)
+    version: Mapped[UUID] = mapped_column(Uuid, nullable=False)
+
+    # 重置只删除覆盖值；版本行保留，原生 ORM 比较令牌以拒绝过期写入。
+    __mapper_args__ = {  # noqa: RUF012 -- SQLAlchemy 原生声明属性，基类不允许 ClassVar。
+        "version_id_col": version,
+        "version_id_generator": False,
+    }

python_platform/settings/sqlalchemy/module.py

@@ -0,0 +1,36 @@
+"""Host 显式选择的 Global Runtime Settings SQLAlchemy provider Module。"""
+
+from __future__ import annotations
+
+from dishka import Provider, Scope
+
+from ...lifecycle import ConfigureContext
+from ...modularity import AppModule
+from ...sqlalchemy import (
+    SqlAlchemyModelRegistration,
+    SqlAlchemyPersistenceModule,
+    contributes_sqlalchemy_models,
+)
+from ..store import RuntimeSettingStore
+from .models import RuntimeSettingsBase
+from .store import SqlAlchemyRuntimeSettingStore
+
+
+@contributes_sqlalchemy_models(
+    SqlAlchemyModelRegistration(
+        metadata=RuntimeSettingsBase.metadata,
+        migrations_package="python_platform.settings.sqlalchemy.migrations",
+        branch_label="platform_settings",
+    )
+)
+class SqlAlchemyRuntimeSettingsModule(AppModule):
+    dependencies = (SqlAlchemyPersistenceModule,)
+
+    def configure(self, context: ConfigureContext) -> None:
+        provider = Provider()
+        provider.provide(
+            SqlAlchemyRuntimeSettingStore,
+            provides=RuntimeSettingStore,
+            scope=Scope.APP,
+        )
+        context.services.contribute(provider, reason="SQLAlchemy Global Runtime Settings")

python_platform/settings/sqlalchemy/store.py

@@ -0,0 +1,86 @@
+"""Global Runtime Settings 的独立短事务 store。"""
+
+from __future__ import annotations
+
+from uuid import UUID, uuid4
+
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+from sqlalchemy.orm.exc import StaleDataError
+
+from ...application_services.invocation import _InvocationRuntime
+from ...errors.base import ResourceConflictError
+from ...sqlalchemy import PlatformAsyncSession
+from ...sqlalchemy.auditing import _bind_current_user
+from ...sqlalchemy.runtime import _SqlAlchemyEngineRegistry
+from ..errors import RuntimeSettingError
+from ..values import StoredSetting
+from .models import RuntimeSettingRow, RuntimeSettingVersionRow
+
+
+class SqlAlchemyRuntimeSettingStore:
+    __slots__ = ("_engines", "_runtime")
+
+    def __init__(
+        self,
+        engines: _SqlAlchemyEngineRegistry,
+        runtime: _InvocationRuntime,
+    ) -> None:
+        self._engines = engines
+        self._runtime = runtime
+
+    async def read(self, name: str) -> StoredSetting:
+        try:
+            async with self._session() as session:
+                row = (
+                    await session.execute(
+                        select(RuntimeSettingVersionRow.version, RuntimeSettingRow.value_json)
+                        .outerjoin(RuntimeSettingRow)
+                        .where(RuntimeSettingVersionRow.setting_name == name)
+                    )
+                ).one_or_none()
+                return StoredSetting(None, None) if row is None else StoredSetting(row[1], row[0])
+        except SQLAlchemyError as original_error:
+            raise _setting_error(name, "get", original_error) from None
+
+    async def write(
+        self, name: str, value_json: str | None, *, expected_version: UUID | None
+    ) -> StoredSetting:
+        version = uuid4()
+        try:
+            async with self._session() as session, session.begin():
+                state = await session.get(RuntimeSettingVersionRow, name)
+                if (None if state is None else state.version) != expected_version:
+                    raise ResourceConflictError("Setting version conflict")
+                if state is None:
+                    session.add(RuntimeSettingVersionRow(setting_name=name, version=version))
+                else:
+                    state.version = version
+                # 先由原生 version_id_col 抢占版本，再改覆盖值；两者只在同一短事务提交。
+                await session.flush()
+                row = await session.get(RuntimeSettingRow, name)
+                if value_json is None:
+                    if row is not None:
+                        await session.delete(row)
+                elif row is None:
+                    session.add(RuntimeSettingRow(setting_name=name, value_json=value_json))
+                else:
+                    row.value_json = value_json
+            return StoredSetting(value_json, version)
+        except (IntegrityError, StaleDataError):
+            raise ResourceConflictError("Setting version conflict") from None
+        except SQLAlchemyError as original_error:
+            raise _setting_error(name, "write", original_error) from None
+
+    def _session(self) -> PlatformAsyncSession:
+        session = PlatformAsyncSession(self._engines.get("default"), expire_on_commit=False)
+        _bind_current_user(session, self._runtime.current_user())
+        return session
+
+
+def _setting_error(name: str, operation: str, error: SQLAlchemyError) -> RuntimeSettingError:
+    return RuntimeSettingError(
+        setting=name,
+        operation=operation,
+        error_type=type(error).__name__,
+    )

python_platform/settings/store.py

@@ -0,0 +1,16 @@
+"""运行期设置持久化边界；实现负责独立短事务与版本条件写入。"""
+
+from __future__ import annotations
+
+from typing import Protocol
+from uuid import UUID
+
+from .values import StoredSetting
+
+
+class RuntimeSettingStore(Protocol):
+    async def read(self, name: str) -> StoredSetting: ...
+
+    async def write(
+        self, name: str, value_json: str | None, *, expected_version: UUID | None
+    ) -> StoredSetting: ...

python_platform/settings/values.py

@@ -0,0 +1,39 @@
+"""设置存储与有效值的不可变快照；版本只表达数据库保存状态。"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, TypeVar
+from uuid import UUID
+
+from ..notifications import NotificationPublishStatus
+
+_T = TypeVar("_T")
+
+
+class SettingValueSource(str, Enum):
+    RUNTIME = "runtime"
+    CONFIGURATION = "configuration"
+    DEFINITION = "definition"
+    UNSET = "unset"
+
+
+@dataclass(frozen=True, slots=True)
+class StoredSetting:
+    value_json: str | None
+    version: UUID | None
+
+
+@dataclass(frozen=True, slots=True)
+class SettingSnapshot(Generic[_T]):
+    name: str
+    value: _T | None
+    source: SettingValueSource
+    version: UUID | None
+
+
+@dataclass(frozen=True, slots=True)
+class SettingWriteOutcome(Generic[_T]):
+    snapshot: SettingSnapshot[_T]
+    notification: NotificationPublishStatus

python_platform/sqlalchemy/__init__.py

@@ -0,0 +1,51 @@
+"""Optional SQLAlchemy/PostgreSQL persistence capability。"""
+
+from .auditing import (
+    AuditedEntityMixin,
+    PlatformAsyncSession,
+)
+from .errors import (
+    MigrationHeadsMismatchError,
+    SqlAlchemyConnectionError,
+    SqlAlchemyMetadataChangedError,
+    SqlAlchemyMigrationError,
+    SqlAlchemyModelRegistrationError,
+    UnknownSqlAlchemyConnectionError,
+)
+from .metadata import (
+    SqlAlchemyMigrationContribution,
+    SqlAlchemyMigrationRegistration,
+    SqlAlchemyModelCatalog,
+    SqlAlchemyModelContribution,
+    SqlAlchemyModelRegistration,
+    contributes_sqlalchemy_migrations,
+    contributes_sqlalchemy_models,
+)
+from .migration import SqlAlchemyMigrator
+from .module import SqlAlchemyPersistenceModule
+from .options import ConnectionStringsOptions
+from .repository import SqlAlchemyRepository
+from .session_provider import SqlAlchemySessionProvider
+
+__all__ = (
+    "AuditedEntityMixin",
+    "ConnectionStringsOptions",
+    "MigrationHeadsMismatchError",
+    "PlatformAsyncSession",
+    "SqlAlchemyConnectionError",
+    "SqlAlchemyMetadataChangedError",
+    "SqlAlchemyMigrationContribution",
+    "SqlAlchemyMigrationError",
+    "SqlAlchemyMigrationRegistration",
+    "SqlAlchemyMigrator",
+    "SqlAlchemyModelCatalog",
+    "SqlAlchemyModelContribution",
+    "SqlAlchemyModelRegistration",
+    "SqlAlchemyModelRegistrationError",
+    "SqlAlchemyPersistenceModule",
+    "SqlAlchemyRepository",
+    "SqlAlchemySessionProvider",
+    "UnknownSqlAlchemyConnectionError",
+    "contributes_sqlalchemy_migrations",
+    "contributes_sqlalchemy_models",
+)

python_platform/sqlalchemy/alembic_runtime/__init__.py

@@ -0,0 +1 @@
+"""Alembic runtime environment package；revision files remain Module-owned。"""

python_platform/sqlalchemy/alembic_runtime/env.py

@@ -0,0 +1,27 @@
+"""Alembic environment using a Host-injected synchronous connection bridge."""
+
+from __future__ import annotations
+
+from alembic import context
+from sqlalchemy import Connection, MetaData
+
+config = context.config
+connection = config.attributes.get("connection")
+target_metadata = config.attributes.get("target_metadata")
+
+if not isinstance(connection, Connection):
+    raise RuntimeError("Alembic runtime requires Config.attributes['connection']")
+if not isinstance(target_metadata, tuple) or not all(
+    isinstance(item, MetaData) for item in target_metadata
+):
+    raise RuntimeError("Alembic runtime requires immutable target_metadata")
+
+context.configure(
+    connection=connection,
+    target_metadata=target_metadata,
+    include_schemas=True,
+    version_table="alembic_version",
+    include_name=config.attributes.get("include_name"),
+)
+with context.begin_transaction():
+    context.run_migrations()

python_platform/sqlalchemy/alembic_runtime/script.py.mako

@@ -0,0 +1,14 @@
+"""${message}；请人工复核数据库变更与数据迁移。"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

python_platform/sqlalchemy/auditing.py

@@ -0,0 +1,48 @@
+"""SQLAlchemy native events 维护审计字段；删除遵循原生 ORM 与外键语义。"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from uuid import UUID
+
+from sqlalchemy import DateTime, Uuid, event
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, Session, mapped_column
+
+from ..authorization import CurrentUser
+
+_CURRENT_USER_INFO_KEY = "python_platform_current_user"
+
+
+class AuditedEntityMixin:
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    created_by: Mapped[UUID | None] = mapped_column(Uuid, nullable=True)
+    updated_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    updated_by: Mapped[UUID | None] = mapped_column(Uuid, nullable=True)
+
+
+class _PlatformSyncSession(Session):
+    """Listener 仅绑定 Platform 自有 Session class，不污染进程中的其他 SQLAlchemy usage。"""
+
+
+class PlatformAsyncSession(AsyncSession):
+    sync_session_class = _PlatformSyncSession
+
+
+@event.listens_for(_PlatformSyncSession, "before_flush")
+def _apply_audit_fields(session: Session, flush_context: object, instances: object) -> None:
+    current_user = session.info.get(_CURRENT_USER_INFO_KEY)
+    user_id = current_user.user_id if isinstance(current_user, CurrentUser) else None
+    now = datetime.now(UTC)
+    for entity in tuple(session.new):
+        if isinstance(entity, AuditedEntityMixin):
+            entity.created_at = now
+            entity.created_by = user_id
+    for entity in tuple(session.dirty):
+        if isinstance(entity, AuditedEntityMixin) and entity not in session.new:
+            entity.updated_at = now
+            entity.updated_by = user_id
+
+
+def _bind_current_user(session: PlatformAsyncSession, current_user: CurrentUser) -> None:
+    session.sync_session.info[_CURRENT_USER_INFO_KEY] = current_user