chore: format

Author: RF-Tar-Railt

pdm.lock

@@ -53,12 +53,12 @@ includes = ["src/graia"]
 
 [tool.pdm.dev-dependencies]
 dev = [
-    "black<23.0.0,>=22.1.0",
+    "black>=25.0.0",
     "uvicorn>=0.23.2",
     "aiohttp>=3.9.1",
     "httpx>=0.26.0",
     "sqlalchemy>=2.0.25",
-    "isort>=5.13.2",
+    "isort==5.13.2",
     "pytest>=7.4.4",
 ]
 

pyproject.toml

@@ -238,11 +238,9 @@ class LifespanShutdownFailedEvent(TypedDict):
 
 
 class ASGI2Protocol(Protocol):
-    def __init__(self, scope: Scope) -> None:
-        ...
+    def __init__(self, scope: Scope) -> None: ...
 
-    async def __call__(self, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
-        ...
+    async def __call__(self, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None: ...
 
 
 ASGI2Application = Type[ASGI2Protocol]

src/graia/amnesia/builtins/asgi/asgitypes.py

@@ -28,10 +28,7 @@ def pacth_logger(log_level: str | int = "INFO", sqlalchemy_echo: bool = False) -
     levels = {
         "alembic": log_level,
         "sqlalchemy": log_level,
-        **{
-            _qual_logger_name_for_cls(cls): echo_log_level
-            for cls in set(get_subclasses(Identified))
-        },
+        **{_qual_logger_name_for_cls(cls): echo_log_level for cls in set(get_subclasses(Identified))},
     }
 
     for name, level in levels.items():

src/graia/amnesia/builtins/sqla/__init__.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, TYPE_CHECKING, ClassVar
+from typing import TYPE_CHECKING, Any, Callable, ClassVar
 
 from sqlalchemy import MetaData
 from sqlalchemy.ext.asyncio import AsyncAttrs

src/graia/amnesia/builtins/sqla/model.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import Literal, ClassVar, Any, TypeVar, cast
+from typing import Any, ClassVar, Literal, TypeVar, cast
 
 from launart import Launart, Service
 from loguru import logger
 from sqlalchemy import Table
-
+from sqlalchemy.engine.result import Result
+from sqlalchemy.engine.url import URL
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 from sqlalchemy.ext.asyncio.engine import AsyncEngine
+from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.sql.base import Executable
 from sqlalchemy.sql.selectable import TypedReturnsRows
-from sqlalchemy.engine.result import Result
-from sqlalchemy.engine.url import URL
-from sqlalchemy.orm import DeclarativeBase
 
 from .model import Base
 from .types import EngineOptions
@@ -34,7 +33,7 @@ def __init__(
         engine_options: EngineOptions | None = None,
         session_options: dict[str, Any] | None = None,
         binds: dict[str, str | URL] | None = None,
-        create_table_at: Literal["preparing", "prepared", "blocking"] = "preparing"
+        create_table_at: Literal["preparing", "prepared", "blocking"] = "preparing",
     ) -> None:
         if engine_options is None:
             engine_options = {"echo": "debug", "pool_pre_ping": True}
@@ -54,6 +53,7 @@ def stages(self) -> set[Literal["preparing", "blocking", "cleanup"]]:
         return {"preparing", "blocking", "cleanup"}
 
     async def initialize(self):
+        _binds = {}
         binds = {}
 
         for model in set(get_subclasses(self.base_class)):
@@ -62,41 +62,52 @@ async def initialize(self):
             if table is None or (bind_key := table.info.get("bind_key")) is None:
                 continue
 
-            binds[model] = self.engines.get(bind_key, self.engines[""])
+            if bind_key in self.engines:
+                _binds[model] = self.engines[bind_key]
+                binds.setdefault(bind_key, []).append(model)
+            else:
+                _binds[model] = self.engines[""]
+                binds.setdefault("", []).append(model)
 
-        self.session_factory = async_sessionmaker(self.engines[""], binds=binds, **self.session_options)
+        self.session_factory = async_sessionmaker(self.engines[""], binds=_binds, **self.session_options)
         return binds
 
     def get_session(self, **local_kw):
         return self.session_factory(**local_kw)
 
     async def launch(self, manager: Launart):
-        binds: dict[type[Base], AsyncEngine] = {}
+        binds: dict[str, list[type[Base]]] = {}
 
         async with self.stage("preparing"):
             logger.info("Initializing database...")
             if self.create_table_at == "preparing":
                 binds = await self.initialize()
                 logger.success("Database initialized!")
-                for model, engine in binds.items():
-                    async with engine.begin() as conn:
-                        await conn.run_sync(model.__table__.create, checkfirst=True)
+                for key, models in binds.items():
+                    async with self.engines[key].begin() as conn:
+                        await conn.run_sync(
+                            self.base_class.metadata.create_all, tables=[m.__table__ for m in models], checkfirst=True
+                        )
                 logger.success("Database tables created!")
 
         if self.create_table_at != "preparing":
             binds = await self.initialize()
             logger.success("Database initialized!")
         if self.create_table_at == "prepared":
-            for model, engine in binds.items():
-                async with engine.begin() as conn:
-                    await conn.run_sync(model.__table__.create, checkfirst=True)
+            for key, models in binds.items():
+                async with self.engines[key].begin() as conn:
+                    await conn.run_sync(
+                        self.base_class.metadata.create_all, tables=[m.__table__ for m in models], checkfirst=True
+                    )
             logger.success("Database tables created!")
 
         async with self.stage("blocking"):
             if self.create_table_at == "blocking":
-                for model, engine in binds.items():
-                    async with engine.begin() as conn:
-                        await conn.run_sync(model.__table__.create, checkfirst=True)
+                for key, models in binds.items():
+                    async with self.engines[key].begin() as conn:
+                        await conn.run_sync(
+                            self.base_class.metadata.create_all, tables=[m.__table__ for m in models], checkfirst=True
+                        )
                 logger.success("Database tables created!")
             await manager.status.wait_for_sigexit()
         async with self.stage("cleanup"):
@@ -145,4 +156,3 @@ async def delete_many_exist(self, rows: Sequence[Base]):
         async with self.get_session() as session:
             for row in rows:
                 await session.delete(row)
-

src/graia/amnesia/builtins/sqla/service.py

@@ -18,9 +18,7 @@ def emit(self, record: logging.LogRecord):
             frame = frame.f_back
             depth += 1
 
-        logger.opt(depth=depth, exception=record.exc_info).log(
-            level, record.getMessage()
-        )
+        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
 
 
 def get_subclasses(cls):

src/graia/amnesia/builtins/sqla/utils.py

@@ -174,16 +174,13 @@ def join(self, *chains: Self | Iterable[Self]) -> Self:
     __contains__ = has
 
     @overload
-    def __getitem__(self, item: type[E]) -> list[E]:
-        ...
+    def __getitem__(self, item: type[E]) -> list[E]: ...
 
     @overload
-    def __getitem__(self, item: int) -> Element:
-        ...
+    def __getitem__(self, item: int) -> Element: ...
 
     @overload
-    def __getitem__(self, item: slice) -> Self:
-        ...
+    def __getitem__(self, item: slice) -> Self: ...
 
     def __getitem__(self, item: type[Element] | int | slice) -> Any:
         """取出子消息链, 或元素.