fastlib-py 0.3.4__tar.gz → 0.3.6__tar.gz

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.3.4
+Version: 0.3.6
 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>
@@ -10,21 +10,18 @@ Keywords: fastapi,library,sqlmodel,web
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiosqlite>=0.21
 Requires-Dist: alembic>=1.15.2
-Requires-Dist: asgi-correlation-id>=4.3.4
 Requires-Dist: cryptography>=45.0.6
-Requires-Dist: diskcache>=5.6.3
 Requires-Dist: fastapi[standard]>=0.115.12
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: openpyxl>=3.1.5

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/_logging/config.py

@@ -4,7 +4,7 @@ Log configuration and logging utility for the application.
 """
 
 from pathlib import Path
-from typing import Literal, Optional
+from typing import Literal
 
 from fastlib.config.base import BaseConfig
 from fastlib.config.manager import config_class
@@ -29,7 +29,7 @@ class LogConfig(BaseConfig):
         error_log_rotation: str = "1 day",
         error_log_retention: str = "90 days",
         enable_async: bool = True,
-        max_file_size: Optional[str] = "10 MB",
+        max_file_size: str | None = "10 MB",
         time_format: str = "YYYY-MM-DD",
         **kwargs,
     ):

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/_logging/handlers.py

@@ -5,12 +5,11 @@ 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
+from fastlib.config.manager import ConfigManager
 
 
 class Logger:
@@ -19,7 +18,7 @@ class Logger:
     """
 
     _instances: dict[str, "Logger"] = {}
-    _config: Optional[LogConfig] = None
+    _config: LogConfig | None = None
     _is_configured: bool = False
 
     @classmethod
@@ -49,7 +48,7 @@ class Logger:
     @classmethod
     def get_instance(
         cls,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> "Logger":
         """
         Get or create a named logger instance.

fastlib_py-0.3.6/fastlib/cache/_memony_cache.py

@@ -0,0 +1,267 @@
+# SPDX-License-Identifier: MIT
+"""Memory-based cache implementation compatible with Cache interface."""
+
+import asyncio
+import time
+from contextlib import asynccontextmanager
+from typing import Any, Dict, Optional, Set
+
+from fastlib.cache.base import Cache, CacheError
+
+
+class MemoryCache(Cache):
+    """
+    Memory-based cache implementation
+    """
+    
+    def __init__(self, namespace: str = "default"):
+        self.namespace = namespace
+        self._data: Dict[str, Any] = {}
+        self._expiry: Dict[str, float] = {}
+        self._lists: Dict[str, list] = {}
+        self._sets: Dict[str, Set] = {}
+        self._hashes: Dict[str, Dict[str, Any]] = {}
+        self._locks: Dict[str, asyncio.Lock] = {}
+        self._global_lock = asyncio.Lock()
+    
+    def _is_expired(self, key: str) -> bool:
+        """Check if a key has expired"""
+        if key not in self._expiry:
+            return False
+        return time.time() > self._expiry[key]
+    
+    def _clean_expired(self):
+        """Clean up expired keys"""
+        expired_keys = [k for k in self._expiry if self._is_expired(k)]
+        for key in expired_keys:
+            self._data.pop(key, None)
+            self._expiry.pop(key, None)
+            self._lists.pop(key, None)
+            self._sets.pop(key, None)
+            self._hashes.pop(key, None)
+    
+    async def ping(self) -> bool:
+        try:
+            await self.set("__ping__", "pong", ex=1)
+            return True
+        except Exception as e:
+            raise CacheError("Ping failed", e) from e
+
+    async def set(
+        self,
+        key: str,
+        value: Any,
+        ex: Optional[int] = None,
+        nx: bool = False,  # only set if not exists
+        xx: bool = False,  # only set if exists
+    ) -> bool:
+        async with self._global_lock:
+            self._clean_expired()
+            
+            if nx and key in self._data:
+                return False
+            if xx and key not in self._data:
+                return False
+            
+            self._data[key] = value
+            if ex is not None:
+                self._expiry[key] = time.time() + ex
+            elif key in self._expiry:
+                del self._expiry[key]  # Remove expiration time
+            
+            return True
+
+    async def get(self, key: str) -> Any | None:
+        async with self._global_lock:
+            self._clean_expired()
+            
+            if key in self._data and not self._is_expired(key):
+                return self._data[key]
+            return None
+
+    async def delete(self, *keys: str) -> int:
+        async with self._global_lock:
+            count = 0
+            for key in keys:
+                if key in self._data:
+                    del self._data[key]
+                    self._expiry.pop(key, None)
+                    self._lists.pop(key, None)
+                    self._sets.pop(key, None)
+                    self._hashes.pop(key, None)
+                    count += 1
+            return count
+
+    async def exists(self, *keys: str) -> int:
+        async with self._global_lock:
+            self._clean_expired()
+            return sum(1 for k in keys if k in self._data and not self._is_expired(k))
+
+    async def expire(self, key: str, seconds: int) -> bool:
+        async with self._global_lock:
+            if key not in self._data or self._is_expired(key):
+                return False
+            self._expiry[key] = time.time() + seconds
+            return True
+
+    async def ttl(self, key: str) -> int:
+        async with self._global_lock:
+            if key not in self._data or key not in self._expiry:
+                return -1  # No expiration time set
+            if self._is_expired(key):
+                return -2  # Key does not exist (expired)
+            return int(self._expiry[key] - time.time())
+
+    async def incr(self, key: str, amount: int = 1) -> int:
+        async with self._global_lock:
+            self._clean_expired()
+            
+            current = self._data.get(key, 0)
+            if not isinstance(current, int):
+                raise CacheError("Value is not integer")
+            
+            new_value = current + amount
+            self._data[key] = new_value
+            return new_value
+
+    async def decr(self, key: str, amount: int = 1) -> int:
+        return await self.incr(key, -amount)
+
+    # ---------------- Hash (dict) ----------------
+    async def hset(self, name: str, key: str, value: Any) -> int:
+        async with self._global_lock:
+            if name not in self._hashes:
+                self._hashes[name] = {}
+            self._hashes[name][key] = value
+            return 1
+
+    async def hget(self, name: str, key: str) -> Any | None:
+        async with self._global_lock:
+            if name in self._hashes:
+                return self._hashes[name].get(key)
+            return None
+
+    async def hgetall(self, name: str) -> dict[str, Any]:
+        async with self._global_lock:
+            return self._hashes.get(name, {}).copy()
+
+    async def hdel(self, name: str, *keys: str) -> int:
+        async with self._global_lock:
+            if name not in self._hashes:
+                return 0
+            removed = 0
+            for k in keys:
+                if k in self._hashes[name]:
+                    del self._hashes[name][k]
+                    removed += 1
+            return removed
+
+    # ---------------- List ----------------
+    async def lpush(self, name: str, *values: Any) -> int:
+        async with self._global_lock:
+            if name not in self._lists:
+                self._lists[name] = []
+            self._lists[name][:0] = values  # Insert at the beginning
+            return len(self._lists[name])
+
+    async def rpush(self, name: str, *values: Any) -> int:
+        async with self._global_lock:
+            if name not in self._lists:
+                self._lists[name] = []
+            self._lists[name].extend(values)
+            return len(self._lists[name])
+
+    async def lpop(self, name: str) -> Any | None:
+        async with self._global_lock:
+            if name not in self._lists or not self._lists[name]:
+                return None
+            return self._lists[name].pop(0)
+
+    async def rpop(self, name: str) -> Any | None:
+        async with self._global_lock:
+            if name not in self._lists or not self._lists[name]:
+                return None
+            return self._lists[name].pop()
+
+    async def lrange(self, name: str, start: int = 0, end: int = -1) -> list[Any]:
+        async with self._global_lock:
+            if name not in self._lists:
+                return []
+            lst = self._lists[name]
+            if end == -1:
+                end = len(lst)
+            return lst[start:end]
+
+    # ---------------- Set ----------------
+    async def sadd(self, name: str, *values: Any) -> int:
+        async with self._global_lock:
+            if name not in self._sets:
+                self._sets[name] = set()
+            before = len(self._sets[name])
+            self._sets[name].update(values)
+            return len(self._sets[name]) - before
+
+    async def smembers(self, name: str) -> list[Any]:
+        async with self._global_lock:
+            if name not in self._sets:
+                return []
+            return list(self._sets[name])
+
+    async def srem(self, name: str, *values: Any) -> int:
+        async with self._global_lock:
+            if name not in self._sets:
+                return 0
+            before = len(self._sets[name])
+            for v in values:
+                self._sets[name].discard(v)
+            return before - len(self._sets[name])
+
+    # ---------------- Lock (async-based) ----------------
+    async def acquire_lock(
+        self,
+        lock_name: str,
+        timeout: int = 10,
+        blocking_timeout: int = 5,
+        thread_local: bool = True,
+    ) -> bool:
+        if lock_name not in self._locks:
+            self._locks[lock_name] = asyncio.Lock()
+        
+        try:
+            await asyncio.wait_for(self._locks[lock_name].acquire(), timeout=blocking_timeout)
+            return True
+        except asyncio.TimeoutError:
+            return False
+
+    async def release_lock(self, lock_name: str) -> bool:
+        if lock_name in self._locks and self._locks[lock_name].locked():
+            self._locks[lock_name].release()
+            return True
+        return False
+
+    @asynccontextmanager
+    async def lock(self, lock_name: str, timeout: int = 10, blocking_timeout: int = 5):
+        acquired = await self.acquire_lock(lock_name, timeout, blocking_timeout)
+        if not acquired:
+            raise CacheError(f"Failed to acquire lock: {lock_name}")
+        try:
+            yield
+        finally:
+            await self.release_lock(lock_name)
+
+    async def close(self) -> None:
+        """Clean up resources"""
+        self._data.clear()
+        self._expiry.clear()
+        self._lists.clear()
+        self._sets.clear()
+        self._hashes.clear()
+        self._locks.clear()
+    
+    def clear(self) -> None:
+        """Clear all cached data"""
+        self._data.clear()
+        self._expiry.clear()
+        self._lists.clear()
+        self._sets.clear()
+        self._hashes.clear()

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/cache/_redis_cache.py

@@ -47,7 +47,7 @@ class RedisCache(Cache):
         self,
         key: str,
         value: Any,
-        ex: Optional[int] = None,
+        ex: int | None = None,
         nx: bool = False,
         xx: bool = False,
     ) -> bool:
@@ -65,7 +65,7 @@ class RedisCache(Cache):
         except RedisError as e:
             raise CacheError(f"Failed to set key {key}", e) from e
 
-    async def get(self, key: str) -> Optional[Any]:
+    async def get(self, key: str) -> Any | None:
         """Get a value from cache."""
         try:
             return await self.redis_client.get(key)
@@ -127,7 +127,7 @@ class RedisCache(Cache):
         except RedisError as e:
             raise CacheError(f"Failed to set hash field {key} in {name}", e) from e
 
-    async def hget(self, name: str, key: str) -> Optional[Any]:
+    async def hget(self, name: str, key: str) -> Any | None:
         """Get a field from a hash."""
         try:
             return await self.redis_client.hget(name, key)
@@ -164,14 +164,14 @@ class RedisCache(Cache):
         except RedisError as e:
             raise CacheError(f"Failed to rpush values to list {name}", e) from e
 
-    async def lpop(self, name: str) -> Optional[Any]:
+    async def lpop(self, name: str) -> Any | None:
         """Pop a value from the left of a list."""
         try:
             return await self.redis_client.lpop(name)
         except RedisError as e:
             raise CacheError(f"Failed to lpop from list {name}", e) from e
 
-    async def rpop(self, name: str) -> Optional[Any]:
+    async def rpop(self, name: str) -> Any | None:
         """Pop a value from the right of a list."""
         try:
             return await self.redis_client.rpop(name)

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/cache/base.py

@@ -7,13 +7,13 @@ for different caching implementations like Redis, memory cache, etc.
 
 from abc import ABC, abstractmethod
 from contextlib import asynccontextmanager
-from typing import Any, Optional
+from typing import Any
 
 
 class CacheError(Exception):
     """Custom exception for cache-related errors."""
 
-    def __init__(self, message: str, original_error: Optional[Exception] = None):
+    def __init__(self, message: str, original_error: Exception | None = None):
         self.message = message
         self.original_error = original_error
         super().__init__(f"Cache Error: {message}")
@@ -37,7 +37,7 @@ class Cache(ABC):
         self,
         key: str,
         value: Any,
-        ex: Optional[int] = None,
+        ex: int | None = None,
         nx: bool = False,
         xx: bool = False,
     ) -> bool:
@@ -45,7 +45,7 @@ class Cache(ABC):
         pass
 
     @abstractmethod
-    async def get(self, key: str) -> Optional[Any]:
+    async def get(self, key: str) -> Any | None:
         """Get a value from cache."""
         pass
 
@@ -85,7 +85,7 @@ class Cache(ABC):
         pass
 
     @abstractmethod
-    async def hget(self, name: str, key: str) -> Optional[Any]:
+    async def hget(self, name: str, key: str) -> Any | None:
         """Get a field from a hash."""
         pass
 
@@ -110,12 +110,12 @@ class Cache(ABC):
         pass
 
     @abstractmethod
-    async def lpop(self, name: str) -> Optional[Any]:
+    async def lpop(self, name: str) -> Any | None:
         """Pop a value from the left of a list."""
         pass
 
     @abstractmethod
-    async def rpop(self, name: str) -> Optional[Any]:
+    async def rpop(self, name: str) -> Any | None:
         """Pop a value from the right of a list."""
         pass
 

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/cache/manager.py

@@ -11,15 +11,13 @@ async def get_cache_client() -> Cache:
     Returns:
         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
+        from fastlib.cache._redis_cache import RedisCache, RedisManager
 
         redis_client = await RedisManager.get_instance()
         return RedisCache(redis_client)
     else:
-        from fastlib.cache._disk_cache import PageCache
+        from fastlib.cache._memony_cache import MemoryCache
 
-        return PageCache()
+        return MemoryCache()

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/config/loader.py

@@ -2,7 +2,7 @@
 """ConfigLoader class for loading and managing application configurations from YAML files."""
 
 import os
-from typing import Any, Optional
+from typing import Any
 
 import yaml
 from loguru import logger
@@ -12,7 +12,7 @@ from fastlib.config import utils as config_util
 
 
 class ConfigLoader:
-    def __init__(self, env: str, base_config_file: Optional[str] = None) -> None:
+    def __init__(self, env: str, base_config_file: str | None = None) -> None:
         """
         Initializes a new instance of the ConfigLoader class
 
@@ -59,7 +59,7 @@ class ConfigLoader:
             except yaml.YAMLError as e:
                 raise yaml.YAMLError(f"Error parsing YAML file {file_path}: {e}") from e
 
-    def load_config(self, environment: Optional[str] = None) -> dict[str, Any]:
+    def load_config(self, environment: str | None = None) -> dict[str, Any]:
         """
         Load the base configuration and merge with environment-specific settings.
         """

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/config/manager.py

@@ -2,7 +2,7 @@
 """Configuration loading and management with dynamic registry support."""
 
 import os
-from typing import Any, Optional
+from typing import Any
 
 from fastlib import constants as constant
 from fastlib.config import utils as config_util
@@ -38,7 +38,7 @@ def config_class(name: str):
 class ConfigManager:
     """Global configuration manager with static methods and dynamic registry support."""
 
-    _global_config_dict: Optional[dict[str, Any]] = None
+    _global_config_dict: dict[str, Any] | None = None
     _config_instances: dict[str, BaseConfig] = {}
     _initialized: bool = False
 
@@ -63,9 +63,9 @@ class ConfigManager:
 
     @staticmethod
     def initialize_global_config(
-        env: Optional[str] = None,
-        config_file: Optional[str] = None,
-        custom_configs: Optional[dict[str, Any]] = None,
+        env: str | None = None,
+        config_file: str | None = None,
+        custom_configs: dict[str, Any] | None = None,
     ) -> None:
         """
         Initialize global configuration.
@@ -136,7 +136,7 @@ class ConfigManager:
                 ) from e
 
     @staticmethod
-    def get_config_instance(config_name: str) -> Optional[BaseConfig]:
+    def get_config_instance(config_name: str) -> BaseConfig | None:
         """
         Get a specific configuration instance.
 
@@ -205,7 +205,7 @@ class ConfigManager:
         return ConfigManager._initialized
 
     @staticmethod
-    def get_config_dict() -> Optional[dict[str, Any]]:
+    def get_config_dict() -> dict[str, Any] | None:
         """
         Get the raw configuration dictionary.
 

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/config/registry.py

@@ -2,7 +2,7 @@
 """Configuration registry for dynamic configuration class management."""
 
 # Import BaseConfig from config module to avoid circular imports
-from typing import Any, Optional
+from typing import Any
 
 
 class ConfigRegistry:
@@ -36,7 +36,7 @@ class ConfigRegistry:
         cls._registry[name] = config_class
 
     @classmethod
-    def get_config_class(cls, name: str) -> Optional[type]:
+    def get_config_class(cls, name: str) -> type | None:
         """
         Get a registered configuration class.
 
@@ -49,7 +49,7 @@ class ConfigRegistry:
         return cls._registry.get(name)
 
     @classmethod
-    def create_instance(cls, name: str, config_dict: dict[str, Any]) -> Optional[Any]:
+    def create_instance(cls, name: str, config_dict: dict[str, Any]) -> Any | None:
         """
         Create an instance of a registered configuration class.
 

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/config/utils.py

@@ -3,7 +3,7 @@
 
 import configparser
 from pathlib import Path
-from typing import Any, NamedTuple, Optional
+from typing import Any, NamedTuple
 from urllib.parse import urlparse
 
 from loguru import logger
@@ -36,8 +36,8 @@ class ProjectInfo:
         self,
         name: str,
         version: str,
-        description: Optional[str] = None,
-        authors: Optional[list[str]] = None,
+        description: str | None = None,
+        authors: list[str] | None = None,
     ):
         self.name = name
         self.version = version

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/contextvars.py

@@ -6,12 +6,12 @@ the current authenticated user's ID throughout the request lifecycle.
 """
 
 from contextvars import ContextVar
-from typing import Any, Optional
+from typing import Any
 
 from loguru import logger
 
 # Type aliases for better readability
-UserID = Optional[int]
+UserID = int | None
 
 # Context variable declaration
 _current_user_id: ContextVar[UserID] = ContextVar("current_user_id", default=None)

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/exception/base.py

@@ -2,7 +2,7 @@
 """Base exception class for the application."""
 
 from http import HTTPStatus
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -27,8 +27,8 @@ class BaseException(Exception):
     def __init__(
         self,
         code: ErrorDetail,
-        message: Optional[str] = None,
-        details: Optional[Any] = None,
+        message: str | None = None,
+        details: Any | None = None,
     ):
         """
         Initialize the HTTPException.
@@ -58,5 +58,5 @@ class SystemErrorCode:
 
 class SystemException(BaseException):
     code: SystemErrorCode
-    message: Optional[str] = None
-    details: Optional[Any] = None
+    message: str | None = None
+    details: Any | None = None

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/exception/exception_handler.py

@@ -4,7 +4,7 @@
 import textwrap
 import traceback
 from http import HTTPStatus
-from typing import Any, Optional
+from typing import Any
 
 from fastapi import Request
 from fastapi.exception_handlers import http_exception_handler
@@ -95,7 +95,7 @@ def build_error_response(
     exc: Exception,
     request: Request,
     status_code: int,
-    headers: Optional[dict[str, str]] = None,
+    headers: dict[str, str] | None = None,
 ) -> Response:
     """
     Build standardized error response.

{fastlib_py-0.3.4 → fastlib_py-0.3.6}/fastlib/i18n/manager.py

@@ -5,8 +5,8 @@ Internationalization context manager
 
 import contextvars
 import functools
-from collections.abc import Awaitable
-from typing import Any, Callable, TypeVar
+from collections.abc import Awaitable, Callable
+from typing import Any, TypeVar
 
 from fastlib.i18n.types import Language