fastlib-py 0.5.2__tar.gz → 0.5.4__tar.gz

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.5.2
+Version: 0.5.4
 Summary: Fastlib, high performance, easy to use, fast to code, ready for production
 Author-email: tyvekZhang <tyvekzhang@gmail.com>
 Maintainer-email: tyvekZhang <tyvekzhang@gmail.com>

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/fastlib/exception/exception_handler.py

@@ -179,19 +179,21 @@ async def custom_exception_handler(request: Request, exc: BaseException):
     log_exception(exc, request_info)
     error_info = exc.code
     error_code = error_info.code
+    error_payload: dict = {
+        "code": error_code,
+        "message": exc.message,
+    }
+    if getattr(exc, "details", None) is not None:
+        error_payload["details"] = exc.details
+
     if is_auth_errors_code(error_code):
         return JSONResponse(
             status_code=HTTPStatus.UNAUTHORIZED.value,
-            content={"code": error_code, "message": exc.message},
+            content=error_payload,
         )
 
     return JSONResponse(
-        content={
-            "error": {
-                "code": error_code,
-                "message": exc.message,
-            }
-        }
+        content={"error": error_payload}
     )
 
 

fastlib_py-0.5.4/fastlib/logging/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: MIT
+"""Export logging module"""
+
+from .handlers import Logger
+
+__all__ = [
+    "Logger",
+    "logger",
+]
+
+
+def __getattr__(name: str) -> Logger:
+    if name == "logger":
+        return Logger.initialize()
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/fastlib/logging/handlers.py

@@ -14,7 +14,7 @@ from fastlib.config.manager import ConfigManager
 
 class Logger:
     """
-    Enhanced logging tool support structured logging.
+    Enhanced logging tool with loguru-compatible ``str.format`` messages.
     """
 
     _instances: dict[str, "Logger"] = {}
@@ -137,30 +137,53 @@ class Logger:
 
         return config.default_format
 
-    # Convenience methods for logging
-    def debug(self, message: str, **kwargs) -> None:
-        """Log debug message."""
-        logger.bind(logger_name=self.name).debug(message, **kwargs)
+    def _bound(self):
+        """Return a loguru logger bound to this instance.
 
-    def info(self, message: str, **kwargs) -> None:
-        """Log info message."""
-        logger.bind(logger_name=self.name).info(message, **kwargs)
+        ``opt(depth=1)`` skips this wrapper so ``{name}:{function}:{line}``
+        points at the caller, matching loguru's own logging methods.
+        """
+        return logger.bind(logger_name=self.name).opt(depth=1)
+
+    def bind(self, **kwargs):
+        """Bind extra fields onto the loguru ``extra`` dict, like ``logger.bind()``."""
+        return logger.bind(logger_name=self.name, **kwargs)
+
+    def trace(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with severity ``TRACE``."""
+        self._bound().trace(message, *args, **kwargs)
+
+    def debug(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with severity ``DEBUG``."""
+        self._bound().debug(message, *args, **kwargs)
+
+    def info(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with severity ``INFO``."""
+        self._bound().info(message, *args, **kwargs)
+
+    def success(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with severity ``SUCCESS``."""
+        self._bound().success(message, *args, **kwargs)
+
+    def warning(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with severity ``WARNING``."""
+        self._bound().warning(message, *args, **kwargs)
 
-    def warning(self, message: str, **kwargs) -> None:
-        """Log warning message."""
-        logger.bind(logger_name=self.name).warning(message, **kwargs)
+    def error(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with severity ``ERROR``."""
+        self._bound().error(message, *args, **kwargs)
 
-    def error(self, message: str, **kwargs) -> None:
-        """Log error message."""
-        logger.bind(logger_name=self.name).error(message, **kwargs)
+    def critical(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with severity ``CRITICAL``."""
+        self._bound().critical(message, *args, **kwargs)
 
-    def critical(self, message: str, **kwargs) -> None:
-        """Log critical message."""
-        logger.bind(logger_name=self.name).critical(message, **kwargs)
+    def exception(self, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` as ``ERROR`` with traceback."""
+        self._bound().exception(message, *args, **kwargs)
 
-    def exception(self, message: str, **kwargs) -> None:
-        """Log exception with traceback."""
-        logger.bind(logger_name=self.name).exception(message, **kwargs)
+    def log(self, level, message: str, *args, **kwargs) -> None:
+        """Log ``message.format(*args, **kwargs)`` with the given severity."""
+        self._bound().log(level, message, *args, **kwargs)
 
     @classmethod
     def reset(cls) -> None:

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/fastlib/middleware/db_session.py

@@ -7,12 +7,7 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.engine.url import URL
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlmodel.ext.asyncio.session import AsyncSession
-from starlette.middleware.base import (
-    BaseHTTPMiddleware,
-    RequestResponseEndpoint,
-)
-from starlette.requests import Request
-from starlette.types import ASGIApp
+from starlette.types import ASGIApp, Receive, Scope, Send
 
 try:
     from sqlalchemy.ext.asyncio import async_sessionmaker
@@ -25,8 +20,15 @@ def create_middleware_and_session_proxy():
     _Session: async_sessionmaker | None = None
     _session: ContextVar[AsyncSession | None] = ContextVar("_session", default=None)
 
-    class SQLAlchemyMiddleware(BaseHTTPMiddleware):
-        """Middleware for managing SQLAlchemy sessions in FastAPI applications."""
+    class SQLAlchemyMiddleware:
+        """
+        Pure ASGI middleware that keeps one AsyncSession alive for the full
+        request — including StreamingResponse / SSE body iteration.
+
+        BaseHTTPMiddleware closes the session as soon as response.start is
+        sent, which races with generators still using db.session (SQLAlchemy
+        isce: close() while _connection_for_bind() is in progress).
+        """
 
         def __init__(
             self,
@@ -38,7 +40,7 @@ def create_middleware_and_session_proxy():
             commit_on_exit: bool = True,
         ):
             """Initialize the middleware with database configuration."""
-            super().__init__(app)
+            self.app = app
             self.commit_on_exit = commit_on_exit
             engine_args = engine_args or {}
             session_args = session_args or {}
@@ -60,10 +62,13 @@ def create_middleware_and_session_proxy():
                 **session_args,
             )
 
-        async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
-            """Manage database session for each request."""
+        async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+            if scope["type"] != "http":
+                await self.app(scope, receive, send)
+                return
+
             async with DBSession(commit_on_exit=self.commit_on_exit):
-                return await call_next(request)
+                await self.app(scope, receive, send)
 
     class DBSessionMeta(type):
         """Metaclass for DBSession providing session property."""
@@ -86,6 +91,7 @@ def create_middleware_and_session_proxy():
         def __init__(self, session_args: dict = None, commit_on_exit: bool = False):
             """Initialize session context manager."""
             self.token = None
+            self._owned_session: AsyncSession | None = None
             self.session_args = session_args or {}
             self.commit_on_exit = commit_on_exit
 
@@ -94,12 +100,19 @@ def create_middleware_and_session_proxy():
             if _Session is None:
                 raise RuntimeError("Session is not initialised")
 
-            self.token = _session.set(_Session(**self.session_args))  # type: ignore
+            self._owned_session = _Session(**self.session_args)  # type: ignore
+            self.token = _session.set(self._owned_session)
             return type(self)
 
         async def __aexit__(self, exc_type, exc_value, traceback):
             """Exit session context, handling commit/rollback."""
-            session = _session.get()
+            # Always close the session this context created — never the nested
+            # current ContextVar value (which may belong to an inner async with db()).
+            session = self._owned_session
+            if session is None:
+                if self.token is not None:
+                    _session.reset(self.token)
+                return
 
             try:
                 if exc_type is not None:
@@ -108,7 +121,9 @@ def create_middleware_and_session_proxy():
                     await session.commit()
             finally:
                 await session.close()
-                _session.reset(self.token)
+                if self.token is not None:
+                    _session.reset(self.token)
+                self._owned_session = None
 
     return SQLAlchemyMiddleware, DBSession
 

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/fastlib/migrate.py

@@ -15,10 +15,13 @@ for parent in current_path.parents:
 if not src_parent:
     raise FileNotFoundError("Can not found src dir")
 
-model_path = src_parent / "src" / "main" / "app" / "model"
+# Legacy layout: src/main/app/model
+# Domain layout (ginvest): src/main/app/domains/*/model
+legacy_model_path = src_parent / "src" / "main" / "app" / "model"
+domains_model_path = src_parent / "src" / "main" / "app" / "domains"
 
 # List of directories to scan for model files
-MODEL_PACKAGES = [model_path]
+MODEL_PACKAGES = [legacy_model_path, domains_model_path]
 
 
 def import_sql_models(

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/fastlib/utils/snowflake_util.py

@@ -75,10 +75,14 @@ def generator(
 
 
 global_generator = generator()
+# A generator can't be resumed by two threads at once ("generator already executing");
+# the lock inside generator() only guards its body, so serialize next() here.
+_global_lock = threading.Lock()
 
 
 def snowflake_id() -> int:
     """
-    Returns a unique snowflake ID.
+    Returns a unique snowflake ID. Thread-safe.
     """
-    return next(global_generator)
+    with _global_lock:
+        return next(global_generator)

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/fastlib_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.5.2
+Version: 0.5.4
 Summary: Fastlib, high performance, easy to use, fast to code, ready for production
 Author-email: tyvekZhang <tyvekzhang@gmail.com>
 Maintainer-email: tyvekZhang <tyvekzhang@gmail.com>

{fastlib_py-0.5.2 → fastlib_py-0.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastlib-py"
-version = "0.5.2"
+version = "0.5.4"
 description = "Fastlib, high performance, easy to use, fast to code, ready for production"
 readme = "README.md"
 keywords = ["fastapi", "library", "sqlmodel", "web"]

fastlib_py-0.5.2/fastlib/logging/__init__.py

@@ -1,10 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Export logging module"""
-
-from .handlers import Logger
-
-logger = Logger.initialize()
-
-__all__ = [
-    "logger",
-]