fastlib-py 0.2.4__tar.gz → 0.2.5__tar.gz

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.4
+Version: 0.2.5
 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.4 → fastlib_py-0.2.5}/fastlib/__init__.py

@@ -5,10 +5,12 @@ from .config import ConfigManager as ConfigManager
 from .constant import constant as constant
 from .logging import LogConfig as LogConfig
 from .logging import Logger as Logger
+from .openapi import register_offline_openapi as register_offline_openapi
 
 __all__ = [
     "ConfigManager",
     "Logger",
     "LogConfig",
     "constant",
+    "register_offline_openapi",
 ]

fastlib_py-0.2.5/fastlib/config/base.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+"""Base configuration classes."""
+
+
+class BaseConfig:
+    """Base class for all configuration classes."""
+
+    pass

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/fastlib/config/utils.py

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

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/fastlib/exception/base.py

@@ -7,8 +7,7 @@ from pydantic import BaseModel
 
 
 class ErrorDetail(BaseModel):
-    """Base class for error code.
-    """
+    """Base class for error code."""
 
     code: int
     message: str

fastlib_py-0.2.5/fastlib/i18n/__init__.py

@@ -0,0 +1 @@
+# SPDX-License-Identifier: MIT

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/fastlib/i18n/manager.py

@@ -56,11 +56,6 @@ class I18nContext:
             _language_context.reset(self._token)
 
 
-def with_language(language: Language) -> I18nContext:
-    """Helper to create context manager"""
-    return I18nContext(language)
-
-
 def _language_context_decorator(
     language: Language, is_async: bool = False
 ) -> Callable[[F], F]:
@@ -97,3 +92,8 @@ def async_language_context(
 ) -> Callable[[Callable[..., Awaitable[Any]]], Callable[..., Awaitable[Any]]]:
     """Decorator: run an async function within a language context"""
     return _language_context_decorator(language, is_async=True)
+
+
+def i18n_context(language: Language) -> I18nContext:
+    """Helper to create context manager"""
+    return I18nContext(language)

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/fastlib/logging/__init__.py

@@ -1,4 +1,7 @@
-"""Logging module"""
+# SPDX-License-Identifier: MIT
+"""
+Logging module
+"""
 
 from .config import LogConfig
 from .handlers import Logger

fastlib_py-0.2.5/fastlib/logging/config.py

@@ -0,0 +1,102 @@
+# SPDX-License-Identifier: MIT
+"""
+Log configuration and logging utility for the application.
+"""
+
+from pathlib import Path
+from typing import Literal, Optional
+
+from fastlib.config.base import BaseConfig
+from fastlib.config.manager import config_class
+from fastlib.config.utils import ProjectInfo
+
+LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+
+@config_class("log")
+class LogConfig(BaseConfig):
+    """Configuration for logging settings."""
+
+    def __init__(
+        self,
+        log_dir: str = "/var/log",
+        app_name: str = None,
+        log_level: LogLevel = "INFO",
+        log_rotation: str = "1 day",
+        log_retention: str = "90 days",
+        enable_console_log: bool = True,
+        enable_json_logs: bool = False,
+        error_log_rotation: str = "1 day",
+        error_log_retention: str = "90 days",
+        enable_async: bool = True,
+        max_file_size: Optional[str] = "10 MB",
+        time_format: str = "YYYY-MM-DD",
+        **kwargs,
+    ):
+        """
+        Initialize LogConfig with logging settings.
+
+        Args:
+            log_dir: Directory where log files will be stored
+            app_name: Name of the application for log file naming
+            log_level: Minimum log level to record
+            log_rotation: How often to rotate log files
+            log_retention: How long to keep log files
+            enable_console_log: Whether to output logs to console
+            enable_json_logs: Whether to use JSON format for logs
+            error_log_rotation: How often to rotate error log files
+            error_log_retention: How long to keep error log files
+            enable_async: Whether to use asynchronous logging
+            max_file_size: Maximum size for log files before rotation
+            time_format: Format string for timestamps in log file names
+            **kwargs: Additional keyword arguments for base class
+        """
+        # Set app_name default if not provided
+        if app_name is None:
+            app_name = ProjectInfo.from_pyproject().name
+
+        # Initialize instance attributes directly
+        self.log_dir = log_dir
+        self.app_name = app_name
+        self.log_level = log_level
+        self.log_rotation = log_rotation
+        self.log_retention = log_retention
+        self.enable_console_log = enable_console_log
+        self.enable_json_logs = enable_json_logs
+        self.error_log_rotation = error_log_rotation
+        self.error_log_retention = error_log_retention
+        self.enable_async = enable_async
+        self.max_file_size = max_file_size
+        self.time_format = time_format
+
+        # Handle any additional kwargs for base class
+        if kwargs:
+            # If base class needs special handling, you can add it here
+            # For now, we'll set them as instance attributes
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+    @property
+    def default_format(self) -> str:
+        """Default log format string."""
+        return "{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} | {message}"
+
+    @property
+    def log_file_pattern(self) -> str:
+        """Returns the main log file pattern with timestamp."""
+        return f"{{time:{self.time_format}}}_{self.app_name}.log"
+
+    @property
+    def error_log_file_pattern(self) -> str:
+        """Returns the error log file pattern with timestamp."""
+        return f"{{time:{self.time_format}}}_error_{self.app_name}.log"
+
+    @property
+    def log_file_path(self) -> Path:
+        """Returns the full path for the main log file."""
+        return Path(self.log_dir) / self.log_file_pattern
+
+    @property
+    def error_log_file_path(self) -> Path:
+        """Returns the full path for the error log file."""
+        return Path(self.log_dir) / self.error_log_file_pattern

fastlib_py-0.2.5/fastlib/logging/handlers.py

@@ -0,0 +1,172 @@
+# SPDX-License-Identifier: MIT
+"""
+A comprehensive logging tool for the application.
+"""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger
+
+from fastlib.config.manager import ConfigManager
+from fastlib.logging.config import LogConfig
+
+
+class Logger:
+    """
+    Enhanced logging tool support structured logging.
+    """
+
+    _instances: dict[str, "Logger"] = {}
+    _config: Optional[LogConfig] = None
+    _is_configured: bool = False
+
+    @classmethod
+    def initialize(cls) -> "Logger":
+        """
+        Initialize the logging system.
+
+        Returns:
+            Logger instance
+        """
+        if not cls._is_configured:
+            # Load configuration first
+            cls._config = cls._get_config()
+            # Create and configure the logger
+            instance = cls.get_instance()
+            cls._is_configured = True
+            return instance
+        return cls.get_instance()
+
+    @classmethod
+    def _get_config(cls) -> LogConfig:
+        """Lazy load configuration."""
+        if cls._config is None:
+            cls._config = ConfigManager.get_config_instance("log")
+        return cls._config
+
+    @classmethod
+    def get_instance(
+        cls,
+        name: Optional[str] = None,
+    ) -> "Logger":
+        """
+        Get or create a named logger instance.
+
+        Args:
+            name: Logger instance name
+
+        Returns:
+            Logger instance
+        """
+        # Ensure config is loaded
+        if cls._config is None:
+            cls._config = cls._get_config()
+
+        if not name:
+            name = cls._config.app_name
+
+        if name not in cls._instances:
+            cls._instances[name] = cls(name)
+        return cls._instances[name]
+
+    def __init__(self, name: str):
+        """Initialize the Logger with optional overrides."""
+        self.name = name
+
+        # Get configuration
+        self._config = self._get_config()
+
+        # Only setup logging once globally
+        if not self.__class__._is_configured:
+            self._setup_logging()
+
+    def _setup_logging(self) -> None:
+        """Configure loguru logger with handlers based on configuration."""
+        # Remove default handler
+        logger.remove()
+
+        config = self._config
+
+        # Create log directory
+        Path(config.log_dir).mkdir(parents=True, exist_ok=True)
+
+        # Console handler
+        if config.enable_console_log:
+            logger.add(
+                sys.stderr,
+                format=self._get_format_string(),
+                level=config.log_level,
+                colorize=True,
+            )
+
+        # Main file handler
+        rotation = config.max_file_size or config.log_rotation
+
+        logger.add(
+            str(config.log_file_path),
+            format=self._get_format_string(),
+            level=config.log_level,
+            rotation=rotation,
+            retention=config.log_retention,
+            compression="zip",
+            serialize=config.enable_json_logs,
+            enqueue=config.enable_async,
+        )
+
+        # Error log handler - only add if log level is not ERROR or CRITICAL
+        if config.log_level not in ["ERROR", "CRITICAL"]:
+            logger.add(
+                str(config.error_log_file_path),
+                format=self._get_format_string(),
+                level="ERROR",
+                rotation=config.error_log_rotation,
+                retention=config.error_log_retention,
+                compression="zip",
+                serialize=config.enable_json_logs,
+                enqueue=config.enable_async,
+            )
+
+    def _get_format_string(self) -> str:
+        """Get the log format string."""
+        config = self._config
+
+        if config.enable_json_logs:
+            # JSON logs don't need format string
+            return "{message}"
+
+        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 info(self, message: str, **kwargs) -> None:
+        """Log info message."""
+        logger.bind(logger_name=self.name).info(message, **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, **kwargs) -> None:
+        """Log error message."""
+        logger.bind(logger_name=self.name).error(message, **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, **kwargs) -> None:
+        """Log exception with traceback."""
+        logger.bind(logger_name=self.name).exception(message, **kwargs)
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset all logger instances and configuration (useful for testing)."""
+        cls._instances.clear()
+        cls._config = None
+        cls._is_configured = False
+        logger.remove()

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/fastlib/middleware/jwt.py

@@ -10,8 +10,8 @@ from loguru import logger
 from starlette.responses import JSONResponse
 
 from fastlib import ConfigManager, constant, security
-from fastlib.context.contextvars import current_user_id
-from fastlib.enums.base import MediaTypeEnum
+from fastlib.contextvars import current_user_id
+from fastlib.enums import MediaTypeEnum
 from fastlib.schema import UserCredential
 
 # Load configuration

{fastlib_py-0.2.4/fastlib/schema → fastlib_py-0.2.5/fastlib}/response.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 """Standardized HTTP response model for API implementations."""
 
-from typing import Any, Generic, Optional, TypeVar, Union
+from typing import Any, Generic, Optional, TypeVar, Union, overload
 
 from pydantic import BaseModel, model_serializer
 
@@ -57,6 +57,7 @@ class HttpResponse(BaseModel, Generic[T]):
         return HttpResponse[T](code=code, message=message, data=data)
 
     @staticmethod
+    @overload
     def fail(
         message: str = str,
         code: int = DEFAULT_FAIL_CODE,
@@ -76,7 +77,8 @@ class HttpResponse(BaseModel, Generic[T]):
         return HttpResponse[Any](code=code, message=message, data=data)
 
     @staticmethod
-    def fail_with_error(
+    @overload
+    def fail(
         error: Union[ErrorDetail, tuple[int, str]],  # Supports multiple error types
         extra_msg: Optional[str] = None,
     ) -> "HttpResponse[Any]":

fastlib_py-0.2.4/fastlib/schema/base.py → fastlib_py-0.2.5/fastlib/schema.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 """Common schema with data validation."""
 
-from typing import Generic, Optional, TypeVar
+from typing import Generic, Literal, Optional, TypeVar
 
 from pydantic import BaseModel, Field
 
@@ -53,18 +53,18 @@ class SortItem(BaseModel):
     """
 
     field: str
-    order: str
+    order: Literal["asc", "desc"]
 
 
-class PaginationRequest(BaseModel):
+class ListRequest(BaseModel):
     """
-    Pagination parameters for API endpoints.
+    Pagination and sorting parameters for list endpoints.
 
     Attributes:
-
-        current: Current page number (1-based).
-        page_size: Number of items per page.
-        count: Flag to request total count of items.
+        current: Current page number (1-based). Default: 1.
+        page_size: Items per page (1-1000). Default: 10.
+        count: Whether to return total count. Default: True.
+        sort_str: Optional sorting string (e.g., "field:asc,field2:desc").
     """
 
     current: int = Field(default=1, gt=0, description="Current page number (1-based)")
@@ -74,9 +74,8 @@ class PaginationRequest(BaseModel):
         le=1000,
         description="Number of items per page (1-1000)",
     )
-    count: bool = Field(
-        default=True, description="Flag to request total count of items"
-    )
+    count: bool = Field(default=True, description="Whether to return total count")
     sort_str: Optional[str] = Field(
-        default=None, description="Optional sorting string, eg:"
+        default=None,
+        description='Optional sorting string (e.g., "field:asc,field2:desc")',
     )

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/fastlib/session/db_engine.py

@@ -1,8 +1,6 @@
 # SPDX-License-Identifier: MIT
 """Thread-safe async SQLAlchemy engine management."""
 
-from threading import Lock
-
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
 from fastlib import ConfigManager

{fastlib_py-0.2.4 → fastlib_py-0.2.5}/fastlib_py.egg-info/PKG-INFO

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

@@ -2,6 +2,13 @@ LICENSE
 README.md
 pyproject.toml
 fastlib/__init__.py
+fastlib/contextvars.py
+fastlib/enums.py
+fastlib/migrate.py
+fastlib/openapi.py
+fastlib/response.py
+fastlib/router.py
+fastlib/schema.py
 fastlib/cache/__init__.py
 fastlib/cache/base.py
 fastlib/cache/disk_cache.py
@@ -18,14 +25,11 @@ fastlib/config/server_config.py
 fastlib/config/utils.py
 fastlib/constant/__init__.py
 fastlib/constant/constant.py
-fastlib/context/__init__.py
-fastlib/context/contextvars.py
-fastlib/enums/__init__.py
-fastlib/enums/base.py
 fastlib/exception/__init__.py
 fastlib/exception/base.py
 fastlib/exception/exception_handler.py
 fastlib/exception/exception_manager.py
+fastlib/i18n/__init__.py
 fastlib/i18n/manager.py
 fastlib/i18n/messages.py
 fastlib/i18n/types.py
@@ -41,14 +45,6 @@ fastlib/middleware/__init__.py
 fastlib/middleware/db_session.py
 fastlib/middleware/i18n.py
 fastlib/middleware/jwt.py
-fastlib/migrate/migrate.py
-fastlib/openapi/__init__.py
-fastlib/openapi/offline.py
-fastlib/router/__init__.py
-fastlib/router/base.py
-fastlib/schema/__init__.py
-fastlib/schema/base.py
-fastlib/schema/response.py
 fastlib/security/__init__.py
 fastlib/security/security.py
 fastlib/security/utils.py