fastlib-py 0.2.2__tar.gz → 0.2.3__tar.gz

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.2
+Version: 0.2.3
 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.2.2 → fastlib_py-0.2.3}/fastlib/config/utils.py

@@ -8,7 +8,7 @@ from urllib.parse import urlparse
 
 from loguru import logger
 
-from fastlib.enums.enum import DBTypeEnum
+from fastlib.enums.base import DBTypeEnum
 from fastlib.utils import file_util
 
 try:

fastlib_py-0.2.3/fastlib/decorator/base.py

@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: MIT
+"""Commonly used decorator modules"""
+import asyncio
+from functools import wraps
+import functools
+import hashlib
+import json
+import time
+from typing import Any, Callable, Optional
+from loguru import Logger
+
+from fastlib.cache.manager import get_cache_client
+
+
+def log_request_time(logger_name: Optional[str] = None):
+    """
+    Decorator to log API request execution time.
+
+    Args:
+        logger_name: Name of the logger instance to use. If None, uses default logger.
+
+    Returns:
+        Decorator function
+    """
+
+    def decorator(func: Callable):
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            return await _time_request_async(func, logger_name, *args, **kwargs)
+
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            return _time_request_sync(func, logger_name, *args, **kwargs)
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+
+    return decorator
+
+
+async def _time_request_async(func: Callable, logger_name: str, *args, **kwargs) -> Any:
+    """
+    Internal function to time and log async request execution.
+
+    Args:
+        func: The decorated function
+        logger_name: Logger instance name
+        *args: Function arguments
+        **kwargs: Function keyword arguments
+
+    Returns:
+        Result of the function execution
+    """
+    # Get logger instance
+    logger_instance = Logger.get_instance(logger_name)
+
+    # Record start time
+    start_time = time.time()
+
+    try:
+        # Execute the function
+        result = await func(*args, **kwargs)
+
+        # Calculate execution time
+        execution_time = time.time() - start_time
+
+        # Log success
+        logger_instance.info(
+            f"API endpoint {func.__name__} executed successfully",
+            execution_time_ms=round(execution_time * 1000, 2),
+            status="success",
+            endpoint=func.__name__,
+        )
+
+        return result
+
+    except Exception as e:
+        # Calculate execution time (even if error occurred)
+        execution_time = time.time() - start_time
+
+        # Log error
+        logger_instance.error(
+            f"API endpoint {func.__name__} execution failed: {str(e)}",
+            execution_time_ms=round(execution_time * 1000, 2),
+            status="error",
+            endpoint=func.__name__,
+            exc_info=e,
+        )
+
+        # Re-raise the exception
+        raise
+
+
+def _time_request_sync(func: Callable, logger_name: str, *args, **kwargs) -> Any:
+    """
+    Internal function to time and log synchronous request execution.
+
+    Args:
+        func: The decorated function
+        logger_name: Logger instance name
+        *args: Function arguments
+        **kwargs: Function keyword arguments
+
+    Returns:
+        Result of the function execution
+    """
+    # Get logger instance
+    logger_instance = Logger.get_instance(logger_name)
+
+    # Record start time
+    start_time = time.time()
+
+    try:
+        # Execute the function
+        result = func(*args, **kwargs)
+
+        # Calculate execution time
+        execution_time = time.time() - start_time
+
+        # Log success
+        logger_instance.info(
+            f"API endpoint {func.__name__} executed successfully",
+            execution_time_ms=round(execution_time * 1000, 2),
+            status="success",
+            endpoint=func.__name__,
+        )
+
+        return result
+
+    except Exception as e:
+        # Calculate execution time (even if error occurred)
+        execution_time = time.time() - start_time
+
+        # Log error
+        logger_instance.error(
+            f"API endpoint {func.__name__} execution failed: {str(e)}",
+            execution_time_ms=round(execution_time * 1000, 2),
+            status="error",
+            endpoint=func.__name__,
+            exc_info=e,
+        )
+
+        # Re-raise the exception
+        raise
+
+
+def prevent_duplicate_submission(
+    key_prefix: str = "duplicate_submission",
+    ttl: int = 60,
+    include_args: bool = True,
+    include_kwargs: bool = True,
+    custom_key_func: Optional[Callable] = None,
+):
+    """Decorator to prevent duplicate submissions within a specified time window.
+
+    Args:
+        key_prefix: Prefix for the cache key
+        ttl: Time to live in seconds for the duplicate check
+        include_args: Whether to include function args in the cache key
+        include_kwargs: Whether to include function kwargs in the cache key
+        custom_key_func: Optional custom function to generate cache key
+
+    Returns:
+        Decorated function that prevents duplicate submissions
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            # Generate cache key
+            if custom_key_func:
+                cache_key = custom_key_func(*args, **kwargs)
+            else:
+                key_parts = [key_prefix, func.__name__]
+
+                if include_args and args:
+                    # Skip 'self' for instance methods
+                    args_to_hash = (
+                        args[1:] if args and hasattr(args[0], "__class__") else args
+                    )
+                    key_parts.append(str(args_to_hash))
+
+                if include_kwargs and kwargs:
+                    # Sort kwargs for consistent key generation
+                    sorted_kwargs = json.dumps(kwargs, sort_keys=True)
+                    key_parts.append(sorted_kwargs)
+
+                # Create hash of the key parts for a shorter key
+                key_content = ":".join(key_parts)
+                cache_key = (
+                    f"{key_prefix}:{hashlib.md5(key_content.encode()).hexdigest()}"
+                )
+
+            # Get cache client
+            cache = await get_cache_client()
+
+            # Check if request is duplicate
+            existing = await cache.get(cache_key)
+            if existing is not None:
+                raise DuplicateSubmissionError(
+                    f"Duplicate submission detected. Please wait {ttl} seconds before retrying."
+                )
+
+            # Set lock in cache
+            await cache.set(cache_key, "locked", ttl=ttl)
+
+            try:
+                # Execute the original function
+                result = await func(*args, **kwargs)
+                return result
+            except Exception as e:
+                # On error, remove the lock to allow retry
+                await cache.delete(cache_key)
+                raise e
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            raise NotImplementedError(
+                "Synchronous functions are not supported. "
+                "Please use async functions with prevent_duplicate_submission decorator."
+            )
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator
+
+
+class DuplicateSubmissionError(Exception):
+    """Exception raised when a duplicate submission is detected."""
+
+    pass

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/enums/__init__.py

@@ -1,7 +1,7 @@
 """Enum for the application"""
 
+from .base import DBTypeEnum, MediaTypeEnum, SortEnum
 from .base_error_code import ExceptionCode
-from .enum import DBTypeEnum, MediaTypeEnum, SortEnum
 
 __all__ = [
     ExceptionCode,

fastlib_py-0.2.3/fastlib/enums/base.py

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: MIT
+"""Enumerations module. Contains commonly used enum types for the application."""
+
+from enum import Enum
+
+
+class SortEnum(str, Enum):
+    """Enumeration for sorting directions."""
+
+    ascending = "asc"
+    descending = "desc"
+
+
+class DBTypeEnum(str, Enum):
+    """Enumeration for supported database types."""
+
+    PGSQL = "postgresql"
+    MYSQL = "mysql"
+    SQLITE = "sqlite"
+
+
+class MediaTypeEnum(str, Enum):
+    """Enumeration for media/content types."""
+
+    # === Text Formats ===
+    JSON = "application/json"
+    JSON_PATCH = "application/json-patch+json"
+    XML = "application/xml"
+    HTML = "text/html"
+    TEXT = "text/plain"
+    CSS = "text/css"
+    JAVASCRIPT = "application/javascript"
+    CSV = "text/csv"
+    YAML = "application/yaml"
+    YML = "application/yaml"  # Alias
+
+    # === Form Data ===
+    FORM_URL_ENCODED = "application/x-www-form-urlencoded"
+    MULTIPART_FORM = "multipart/form-data"
+
+    # === Binary/Data Formats ===
+    PDF = "application/pdf"
+    ZIP = "application/zip"
+    GZIP = "application/gzip"
+    OCTET_STREAM = "application/octet-stream"
+
+    # === Images ===
+    PNG = "image/png"
+    JPEG = "image/jpeg"
+    JPG = "image/jpeg"  # Alias
+    GIF = "image/gif"
+    WEBP = "image/webp"
+    SVG = "image/svg+xml"
+
+    # === Audio ===
+    MP3 = "audio/mpeg"
+    WAV = "audio/wav"
+    WEBM_AUDIO = "audio/webm"
+
+    # === Video ===
+    MP4 = "video/mp4"
+    WEBM_VIDEO = "video/webm"
+    MPEG = "video/mpeg"
+
+    # === Protobuf & Other Binary Formats ===
+    PROTOBUF = "application/protobuf"
+    MSGPACK = "application/msgpack"
+    CBOR = "application/cbor"
+
+    def __str__(self) -> str:
+        return self.value

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/exception/__init__.py

@@ -1,6 +1,6 @@
 """Exception handling."""
 
-from .custom_exception import HTTPException
+from .base import HTTPException
 from .exception_manager import register_exception_handlers
 
 __all__ = [HTTPException, register_exception_handlers]

fastlib_py-0.2.2/fastlib/exception/custom_exception.py → fastlib_py-0.2.3/fastlib/exception/base.py

@@ -3,7 +3,15 @@
 
 from typing import Any, Optional
 
-from fastlib.enums import ExceptionCode
+from pydantic import BaseModel
+
+
+class ErrorDetail(BaseModel):
+    """Base class for error code.
+    """
+
+    code: int
+    message: str
 
 
 class HTTPException(Exception):
@@ -18,7 +26,7 @@ class HTTPException(Exception):
 
     def __init__(
         self,
-        code: ExceptionCode,
+        code: ErrorDetail,
         message: Optional[str] = None,
         details: Optional[Any] = None,
     ):

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/exception/exception_handler.py

@@ -16,7 +16,6 @@ from pydantic_core._pydantic_core import ValidationError  # noqa
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from fastlib import ConfigManager
-from fastlib.enums.enum import CommonErrorCode
 from fastlib.exception import HTTPException
 
 
@@ -69,9 +68,9 @@ def collect_request_info(request: Request) -> dict[str, Any]:
         "method": request.method,
         "query_params": dict(request.query_params),
         "headers": dict(request.headers),
-        "client": f"{request.client.host}:{request.client.port}"
-        if request.client
-        else None,
+        "client": (
+            f"{request.client.host}:{request.client.port}" if request.client else None
+        ),
     }
 
 
@@ -80,13 +79,15 @@ def log_exception(exc: Exception, request_info: dict[str, Any]) -> None:
     Log exception with full context information.
     """
     logger.error(
-        textwrap.dedent(f"""\
+        textwrap.dedent(
+            f"""\
     Unhandled exception,
     exception_type: {type(exc).__name__},
     exception_message: {str(exc)},
     traceback: {traceback.format_exc()},
     request: {request_info},
-    """)
+    """
+        )
     )
 
 
@@ -109,7 +110,7 @@ def build_error_response(
     return JSONResponse(
         content={
             "error": {
-                "code": CommonErrorCode.INTERNAL_SERVER_ERROR.code,
+                "code": -1,
                 "message": error_message,
             }
         }

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/exception/exception_manager.py

@@ -8,7 +8,7 @@ from pydantic_core._pydantic_core import ValidationError  # noqa
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from fastlib.exception import exception_handler
-from fastlib.exception.custom_exception import HTTPException
+from fastlib.exception.base import HTTPException
 
 
 def register_exception_handlers(app: FastAPI) -> None:

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/middleware/db_session.py

@@ -45,7 +45,7 @@ def create_middleware_and_session_proxy():
             session_args = session_args or {}
 
             if not custom_engine and not db_url:
-                raise ValueError(
+                raise RuntimeError(
                     "You need to pass a db_url or a custom_engine parameter."
                 )
             if not custom_engine:
@@ -73,11 +73,11 @@ def create_middleware_and_session_proxy():
         def session(self) -> AsyncSession:
             """Get the current async context session."""
             if _Session is None:
-                raise ValueError("Session is not initialised")
+                raise RuntimeError("Session is not initialised")
 
             session = _session.get()
             if session is None:
-                raise ValueError("Session is not initialised")
+                raise RuntimeError("Session is not initialised")
 
             return session
 
@@ -93,7 +93,7 @@ def create_middleware_and_session_proxy():
         async def __aenter__(self):
             """Enter session context."""
             if _Session is None:
-                raise ValueError("Session is not initialised")
+                raise RuntimeError("Session is not initialised")
 
             self.token = _session.set(_Session(**self.session_args))  # type: ignore
             return type(self)

fastlib_py-0.2.3/fastlib/middleware/i18n.py

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from fastlib.i18n.manager import reset_language, set_language
+from fastlib.i18n.types import Language
+
+
+class I18nMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for automatic language detection and setting based on HTTP headers.
+    """
+
+    async def dispatch(self, request, call_next):
+        """
+        Process the request and set the language based on Accept-Language header.
+
+        Args:
+            request: The incoming HTTP request
+            call_next: The next middleware or route handler in the chain
+
+        Returns:
+            The HTTP response from the next handler
+        """
+        # Get language preference from request headers
+        accept_lang = request.headers.get("Accept-Language", "en")
+
+        # Set the language for current request
+        if accept_lang.startswith("en"):
+            language = Language.CHINESE
+        elif accept_lang.startswith("zh"):
+            language = Language.CHINESE
+
+        set_language(language)
+        try:
+            response = await call_next(request)
+        finally:
+            # Always reset to prevent leaking context between requests
+            reset_language()
+
+        return response

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/middleware/jwt.py

@@ -11,7 +11,7 @@ from starlette.responses import JSONResponse
 
 from fastlib import ConfigManager, constant, security
 from fastlib.context.contextvars import current_user_id
-from fastlib.enums.enum import MediaTypeEnum
+from fastlib.enums.base import MediaTypeEnum
 from fastlib.schema import UserCredential
 
 # Load configuration

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/router/__init__.py

@@ -1,5 +1,5 @@
 """Export router module."""
 
-from fastlib.router.router_v1 import register_router
+from fastlib.router.base import register_router
 
 __all__ = [register_router]

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/schema/__init__.py

@@ -1,13 +1,13 @@
 """Export the core schemas' symbols."""
 
-from .response import HttpResponse
-from .schema import (
+from .base import (
     CurrentUser,
     ListResult,
     PaginationRequest,
     SortItem,
     UserCredential,
 )
+from .response import HttpResponse
 
 __all__ = [
     HttpResponse,

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/schema/response.py

@@ -5,7 +5,7 @@ from typing import Any, Generic, Optional, TypeVar, Union
 
 from pydantic import BaseModel, model_serializer
 
-from fastlib.enums import ExceptionCode
+from fastlib.exception.base import ErrorDetail
 
 # Define generic type variables for response data
 DataType = TypeVar("DataType")
@@ -77,7 +77,7 @@ class HttpResponse(BaseModel, Generic[T]):
 
     @staticmethod
     def fail_with_error(
-        error: Union[ExceptionCode, tuple[int, str]],  # Supports multiple error types
+        error: Union[ErrorDetail, tuple[int, str]],  # Supports multiple error types
         extra_msg: Optional[str] = None,
     ) -> "HttpResponse[Any]":
         """Constructs an error response from various error type inputs.

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/security/security.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from datetime import datetime, timedelta
-from functools import wraps
 from typing import Any, Callable, Optional, Union
 
 import jwt
@@ -13,8 +12,8 @@ from fastlib.config.manager import ConfigManager
 from fastlib.schema import CurrentUser
 
 # Configuration
-security_config = ConfigManager.get_security_config
-server_config = ConfigManager.get_server_config
+security_config = ConfigManager.get_security_config()
+server_config = ConfigManager.get_server_config()
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
@@ -177,24 +176,3 @@ def get_user_id(token: str) -> int:
     """
     payload = decode_jwt_token(token)
     return int(payload["sub"])
-
-
-def role_required(required_role: str):
-    def decorator(func):
-        @wraps(func)
-        async def wrapper(current_user: CurrentUser, *args, **kwargs):
-            # Get the current user
-            pass
-            # user_id = current_user.user_id
-            #
-            # # Get user role info or permission info
-            # if user.get("role") != required_role:
-            #     raise HTTPException(
-            #         status_code=status.HTTP_403_FORBIDDEN,
-            #         detail=f"Requires {required_role} role"
-            #     )
-            # return await func(request, *args, **kwargs)
-
-        return wrapper
-
-    return decorator

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib/session/db_engine.py

@@ -7,10 +7,6 @@ from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from fastlib import ConfigManager
 
-# Global engine cache with thread safety
-_engine_map: dict[str, AsyncEngine] = {}
-_lock = Lock()
-
 async_engine: AsyncEngine
 
 

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/fastlib_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.2
+Version: 0.2.3
 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.2.2 → fastlib_py-0.2.3}/fastlib_py.egg-info/SOURCES.txt

@@ -20,11 +20,12 @@ fastlib/constant/__init__.py
 fastlib/constant/constant.py
 fastlib/context/__init__.py
 fastlib/context/contextvars.py
+fastlib/decorator/__init__.py
+fastlib/decorator/base.py
 fastlib/enums/__init__.py
-fastlib/enums/base_error_code.py
-fastlib/enums/enum.py
+fastlib/enums/base.py
 fastlib/exception/__init__.py
-fastlib/exception/custom_exception.py
+fastlib/exception/base.py
 fastlib/exception/exception_handler.py
 fastlib/exception/exception_manager.py
 fastlib/i18n/manager.py
@@ -42,17 +43,14 @@ fastlib/middleware/__init__.py
 fastlib/middleware/db_session.py
 fastlib/middleware/i18n.py
 fastlib/middleware/jwt.py
-fastlib/middleware/log.py
 fastlib/migrate/migrate.py
-fastlib/model/__init__.py
-fastlib/model/base_model.py
 fastlib/openapi/__init__.py
 fastlib/openapi/offline.py
 fastlib/router/__init__.py
-fastlib/router/router_v1.py
+fastlib/router/base.py
 fastlib/schema/__init__.py
+fastlib/schema/base.py
 fastlib/schema/response.py
-fastlib/schema/schema.py
 fastlib/security/__init__.py
 fastlib/security/security.py
 fastlib/security/utils.py

{fastlib_py-0.2.2 → fastlib_py-0.2.3}/pyproject.toml

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

fastlib_py-0.2.2/fastlib/enums/base_error_code.py

@@ -1,15 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Base error code enumerations for API responses."""
-
-from pydantic import BaseModel
-
-
-class ExceptionCode(BaseModel):
-    """Base class for error code enumerations.
-
-    Provides common interface for all error codes where each enum member is defined as a tuple of
-    (code, message). This enables consistent error handling across the codebase.
-    """
-
-    code: int
-    message: str

fastlib_py-0.2.2/fastlib/enums/enum.py

@@ -1,33 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Enumerations module. Contains commonly used enum types for the application."""
-
-from enum import Enum
-
-from fastlib.enums import ExceptionCode
-
-
-class SortEnum(str, Enum):
-    """Enumeration for sorting directions."""
-
-    ascending = "asc"
-    descending = "desc"
-
-
-class DBTypeEnum(str, Enum):
-    """Enumeration for supported database types."""
-
-    PGSQL = "postgresql"
-    MYSQL = "mysql"
-    SQLITE = "sqlite"
-
-
-class MediaTypeEnum(str, Enum):
-    """Enumeration for media/content types."""
-
-    JSON = ".json"
-
-
-class CommonErrorCode:
-    """Error codes for core domain."""
-
-    INTERNAL_SERVER_ERROR = ExceptionCode(code=-1, message="Internal server exception")

fastlib_py-0.2.2/fastlib/middleware/i18n.py

@@ -1,57 +0,0 @@
-# SPDX-License-Identifier: MIT
-from starlette.middleware.base import BaseHTTPMiddleware
-
-from fastlib.i18n.types import Language
-
-
-class I18nMiddleware(BaseHTTPMiddleware):
-    """
-    Middleware for automatic language detection and setting based on HTTP headers.
-
-    This middleware inspects the Accept-Language header from incoming requests
-    and sets the appropriate language in the request state for use throughout
-    the application.
-
-    The language preference is stored in request.state.language and can be
-    accessed in route handlers and other middleware.
-
-    Example:
-        ```python
-        from fastapi import FastAPI, Request
-
-        app = FastAPI()
-        app.add_middleware(I18nMiddleware)
-
-        @app.get("/")
-        async def root(request: Request):
-            language = request.state.language
-            return {"language": language.value}
-        ```
-
-    Note:
-        Currently supports only English and Chinese. Defaults to English
-        if the Accept-Language header is not present or unrecognized.
-    """
-
-    async def dispatch(self, request, call_next):
-        """
-        Process the request and set the language based on Accept-Language header.
-
-        Args:
-            request: The incoming HTTP request
-            call_next: The next middleware or route handler in the chain
-
-        Returns:
-            The HTTP response from the next handler
-        """
-        # Get language preference from request headers
-        accept_lang = request.headers.get("Accept-Language", "en")
-
-        # Set the language for current request
-        if accept_lang.startswith("en"):
-            request.state.language = Language.ENGLISH
-        else:
-            request.state.language = Language.CHINESE
-
-        response = await call_next(request)
-        return response

fastlib_py-0.2.2/fastlib/middleware/log.py

@@ -1,49 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""FastAPI Request Logging Middleware"""
-
-import time
-import uuid
-
-from fastapi import Request
-from loguru import logger
-
-
-async def log_requests(request: Request, call_next):
-    """Middleware to log all incoming requests and responses"""
-    # Generate unique request ID
-    request_id = str(uuid.uuid4())
-    request.state.request_id = request_id
-
-    # Log request start information
-    start_time = time.time()
-
-    # Request started log
-    logger.info(
-        f"Request started - {request.method} {request.url.path} "
-        f"(ID: {request_id}, IP: {request.client.host if request.client else None}, "
-        f"UA: {request.headers.get('user-agent')})"
-    )
-
-    try:
-        response = await call_next(request)
-    except Exception as exc:
-        # Log exception information
-        logger.error(
-            f"Request failed - {request.method} {request.url.path} (ID: {request_id}, Error: {str(exc)})",
-            exc_info=True,
-        )
-        raise
-
-    # Calculate processing time
-    process_time = round((time.time() - start_time) * 1000, 2)
-
-    # Request completed log
-    logger.info(
-        f"Request completed - {request.method} {request.url.path} "
-        f"(ID: {request_id}, Status: {response.status_code}, "
-        f"Time: {process_time}ms)"
-    )
-
-    # Add request ID to response headers
-    response.headers["X-Request-ID"] = request_id
-    return response

fastlib_py-0.2.2/fastlib/model/__init__.py

@@ -1,5 +0,0 @@
-"""Export model symbols"""
-
-from .base_model import BaseModel, ModelExt
-
-__all__ = [BaseModel, ModelExt]

fastlib_py-0.2.2/fastlib/model/base_model.py

@@ -1,62 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Database Model Base Classes"""
-
-from datetime import datetime
-from typing import Optional
-
-from sqlalchemy import BigInteger, DateTime, Integer
-from sqlmodel import Field
-from sqlmodel import SQLModel as _SQLModel
-
-from fastlib.utils.snowflake_util import snowflake_id
-
-
-class BaseModel(_SQLModel):
-    """
-    Identifier for a model
-    """
-
-    id: int = Field(
-        default_factory=snowflake_id,
-        primary_key=True,
-        sa_type=BigInteger,
-        sa_column_kwargs={"comment": "主键"},
-    )
-
-
-class TreeModel(BaseModel):
-    """
-    Identifier for a model
-    """
-
-    parent_id: int = Field(
-        index=True,
-        sa_type=BigInteger,
-        sa_column_kwargs={"comment": "父id"},
-    )
-
-    sort: int = Field(
-        index=True,
-        sa_type=Integer,
-        sa_column_kwargs={"comment": "排序"},
-    )
-
-
-class ModelExt(_SQLModel):
-    """
-    Create time and update time for a model, can be automatically generated
-    """
-
-    create_at: Optional[datetime] = Field(
-        sa_type=DateTime,
-        default_factory=datetime.utcnow,
-        sa_column_kwargs={"comment": "创建时间"},
-    )
-    update_at: Optional[datetime] = Field(
-        sa_type=DateTime,
-        default_factory=datetime.utcnow,
-        sa_column_kwargs={
-            "onupdate": datetime.utcnow,
-            "comment": "更新时间",
-        },
-    )