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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.1
+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.1 → fastlib_py-0.2.3}/fastlib/cache/manager.py

@@ -2,7 +2,6 @@
 """Cache Client manager to instantiate the appropriate cache client"""
 
 from fastlib.cache.base import Cache
-
 from fastlib.config.manager import ConfigManager
 
 
@@ -13,7 +12,7 @@ async def get_cache_client() -> Cache:
         Cache: Redis client if Redis is enabled in config, otherwise returns page cache.
     """
     from fastlib.cache.redis_cache import RedisManager
-    
+
     config = ConfigManager.get_database_config()
     if config.enable_redis:
         from fastlib.cache.redis_cache import RedisCache

{fastlib_py-0.2.1 → 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.1 → fastlib_py-0.2.3}/fastlib/constant/__init__.py

@@ -1,3 +1,4 @@
+# SPDX-License-Identifier: MIT
 """Constant for the application"""
 
 from .constant import (

fastlib_py-0.2.3/fastlib/constant/constant.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: MIT
+"""Common constant"""
+
+import os
+from typing import Any
+
+from fastlib.utils import file_util
+
+# Default constant values
+_DEFAULT_CONSTANTS: dict[str, Any] = {
+    "RESOURCE_DIR": os.path.abspath(
+        os.path.join(file_util.find_project_root(), "src", "main", "resource")
+    ),
+    "ADMIN_ID": 9,
+    "ROOT_PARENT_ID": 0,
+    "MAX_PAGE_SIZE": 1000,
+    "ENV": "env",
+    "PARENT_ID": "parent_id",
+    "CONFIG_FILE": "config_file",
+    "CONFIG_FILE_NAME": "config.yml",
+    "AUTHORIZATION": "Authorization",
+}
+
+# Current constant values (initially defaults)
+_CURRENT_CONSTANTS = _DEFAULT_CONSTANTS.copy()
+
+# Exported constants (maintain original interface)
+RESOURCE_DIR: str = _CURRENT_CONSTANTS["RESOURCE_DIR"]
+ADMIN_ID = _CURRENT_CONSTANTS["ADMIN_ID"]
+ROOT_PARENT_ID = _CURRENT_CONSTANTS["ROOT_PARENT_ID"]
+MAX_PAGE_SIZE = _CURRENT_CONSTANTS["MAX_PAGE_SIZE"]
+ENV = _CURRENT_CONSTANTS["ENV"]
+PARENT_ID = _CURRENT_CONSTANTS["PARENT_ID"]
+CONFIG_FILE = _CURRENT_CONSTANTS["CONFIG_FILE"]
+CONFIG_FILE_NAME = _CURRENT_CONSTANTS["CONFIG_FILE_NAME"]
+AUTHORIZATION = _CURRENT_CONSTANTS["AUTHORIZATION"]
+
+
+def set_constant(name: str, value: Any) -> None:
+    """Set constant value.
+
+    Args:
+        name: Constant name
+        value: New value
+
+    Raises:
+        ValueError: If constant doesn't exist
+    """
+    if name not in _DEFAULT_CONSTANTS:
+        raise ValueError(f"Constant '{name}' doesn't exist")
+
+    _CURRENT_CONSTANTS[name] = value
+    _update_exported_constants()
+
+
+def reset_constant(name: str = None) -> None:
+    """Reset constant(s) to default values.
+
+    Args:
+        name: Constant name to reset, None resets all
+
+    Raises:
+        ValueError: If constant doesn't exist
+    """
+    if name is None:
+        _CURRENT_CONSTANTS.clear()
+        _CURRENT_CONSTANTS.update(_DEFAULT_CONSTANTS)
+    else:
+        if name not in _DEFAULT_CONSTANTS:
+            raise ValueError(f"Constant '{name}' doesn't exist")
+        _CURRENT_CONSTANTS[name] = _DEFAULT_CONSTANTS[name]
+
+    _update_exported_constants()
+
+
+def get_constant(name: str) -> Any:
+    """Get current constant value.
+
+    Args:
+        name: Constant name
+
+    Returns:
+        Current constant value
+
+    Raises:
+        ValueError: If constant doesn't exist
+    """
+    if name not in _CURRENT_CONSTANTS:
+        raise ValueError(f"Constant '{name}' doesn't exist")
+    return _CURRENT_CONSTANTS[name]
+
+
+def get_default_constant(name: str) -> Any:
+    """Get default constant value.
+
+    Args:
+        name: Constant name
+
+    Returns:
+        Default constant value
+
+    Raises:
+        ValueError: If constant doesn't exist
+    """
+    if name not in _DEFAULT_CONSTANTS:
+        raise ValueError(f"Constant '{name}' doesn't exist")
+    return _DEFAULT_CONSTANTS[name]
+
+
+def list_constants() -> dict[str, dict[str, Any]]:
+    """List all constants with current and default values.
+
+    Returns:
+        Dictionary with constant information
+    """
+    return {
+        name: {
+            "current": _CURRENT_CONSTANTS[name],
+            "default": _DEFAULT_CONSTANTS[name],
+            "is_modified": _CURRENT_CONSTANTS[name] != _DEFAULT_CONSTANTS[name],
+        }
+        for name in _DEFAULT_CONSTANTS
+    }
+
+
+def _update_exported_constants() -> None:
+    """Update exported constant variables."""
+    global RESOURCE_DIR, ADMIN_ID, ROOT_PARENT_ID, MAX_PAGE_SIZE
+    global ENV, PARENT_ID, CONFIG_FILE, CONFIG_FILE_NAME, AUTHORIZATION
+
+    RESOURCE_DIR = _CURRENT_CONSTANTS["RESOURCE_DIR"]
+    ADMIN_ID = _CURRENT_CONSTANTS["ADMIN_ID"]
+    ROOT_PARENT_ID = _CURRENT_CONSTANTS["ROOT_PARENT_ID"]
+    MAX_PAGE_SIZE = _CURRENT_CONSTANTS["MAX_PAGE_SIZE"]
+    ENV = _CURRENT_CONSTANTS["ENV"]
+    PARENT_ID = _CURRENT_CONSTANTS["PARENT_ID"]
+    CONFIG_FILE = _CURRENT_CONSTANTS["CONFIG_FILE"]
+    CONFIG_FILE_NAME = _CURRENT_CONSTANTS["CONFIG_FILE_NAME"]
+    AUTHORIZATION = _CURRENT_CONSTANTS["AUTHORIZATION"]
+
+
+class FilterOperators:
+    EQ = "EQ"
+    NE = "NE"
+    GT = "GT"
+    GE = "GE"
+    LT = "LT"
+    LE = "LE"
+    BETWEEN = "BETWEEN"
+    LIKE = "LIKE"

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.1 → 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.1 → 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.1/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.1 → 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.1 → 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.1 → fastlib_py-0.2.3}/fastlib/i18n/manager.py

@@ -1,10 +1,13 @@
+# SPDX-License-Identifier: MIT
 """
 Internationalization context manager
 """
 
 import contextvars
 import functools
-from typing import Any, Callable, TypeVar, Awaitable
+from collections.abc import Awaitable
+from typing import Any, Callable, TypeVar
+
 from fastlib.i18n.types import Language
 
 _language_context = contextvars.ContextVar("language", default=Language.ENGLISH)