fastlib-py 0.3.8__tar.gz → 0.3.9__tar.gz

{fastlib_py-0.3.8 → fastlib_py-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.3.8
+Version: 0.3.9
 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>
@@ -21,9 +21,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiosqlite>=0.21
 Requires-Dist: alembic>=1.15.2
-Requires-Dist: fakeredis>=2.32
 Requires-Dist: fastapi[standard]>=0.115.12
-Requires-Dist: loguru>=0.7.3
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pyjwt[crypto]>=2.10.1

fastlib_py-0.3.9/fastlib/_logging/config.py

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: MIT
+"""
+Log configuration and logging utility for the application.
+"""
+
+from dataclasses import dataclass
+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")
+@dataclass
+class LogConfig(BaseConfig):
+    """
+    Configuration for logging settings.
+    """
+
+    log_dir: str = "logs"
+    app_name: Optional[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 = "%Y-%m-%d"
+
+    def __post_init__(self):
+        """
+        Post-initialization hook.
+        """
+        if not self.app_name:
+            project = ProjectInfo.from_pyproject()
+            self.app_name = getattr(project, "name", "app")
+
+        # ✅ ensure log directory exists
+        Path(self.log_dir).mkdir(parents=True, exist_ok=True)
+
+    @property
+    def default_format(self) -> str:
+        """Default text log format."""
+        return "%(asctime)s | %(levelname)-8s | %(name)s:%(funcName)s:%(lineno)d | %(message)s"
+
+    @property
+    def log_file_name(self) -> str:
+        """Main log filename."""
+        return f"{self.app_name}.log"
+
+    @property
+    def error_log_file_name(self) -> str:
+        """Error log filename."""
+        return f"{self.app_name}_error.log"
+
+    @property
+    def log_file_path(self) -> Path:
+        """Full path for the main log file."""
+        return Path(self.log_dir) / self.log_file_name
+
+    @property
+    def error_log_file_path(self) -> Path:
+        """Full path for the error log file."""
+        return Path(self.log_dir) / self.error_log_file_name

fastlib_py-0.3.9/fastlib/_logging/handlers.py

@@ -0,0 +1,253 @@
+# SPDX-License-Identifier: MIT
+"""
+A comprehensive logging tool for the application.
+"""
+
+import sys
+import logging
+import logging.config
+from pathlib import Path
+from typing import Dict, Any, Optional
+from logging.handlers import TimedRotatingFileHandler
+import json
+import gzip
+import os
+import re
+
+from fastlib._logging.config import LogConfig
+from fastlib.config.manager import ConfigManager
+
+
+class JSONFormatter(logging.Formatter):
+    """Custom formatter for JSON logs."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record as JSON."""
+        log_data = {
+            "timestamp": self.formatTime(record, self.datefmt),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno,
+        }
+
+        # Safely merge user-provided data
+        extra_data = getattr(record, "extra_data", None)
+        if isinstance(extra_data, dict):
+            log_data.update(extra_data)
+
+        return json.dumps(log_data, ensure_ascii=False)
+
+
+class Logger:
+    """
+    Enhanced logging tool supporting structured and JSON logs.
+    """
+
+    _instances: Dict[str, "Logger"] = {}
+    _config: Optional[LogConfig] = None
+    _is_configured: bool = False
+    _initialized_loggers: set[str] = set()
+
+    @classmethod
+    def initialize(cls) -> "Logger":
+        """Initialize the logging system."""
+        if not cls._is_configured:
+            cls._config = cls._get_config()
+            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."""
+        if cls._config is None:
+            cls._config = cls._get_config()
+
+        name = name or 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."""
+        self.name = name
+        self._config = self._get_config()
+
+        # Only setup logging once globally
+        if not self.__class__._is_configured:
+            self._setup_logging()
+            self.__class__._is_configured = True
+
+        # Create or reuse named logger
+        self._logger = logging.getLogger(name)
+
+        # Avoid duplicate handler addition
+        if name not in self.__class__._initialized_loggers:
+            self.__class__._initialized_loggers.add(name)
+
+    # -----------------------------
+    # Setup and Handlers
+    # -----------------------------
+
+    def _setup_logging(self) -> None:
+        """Configure native logging with handlers."""
+        config = self._config
+
+        Path(config.log_dir).mkdir(parents=True, exist_ok=True)
+
+        root_logger = logging.getLogger()
+        root_logger.setLevel(getattr(logging, config.log_level, logging.INFO))
+
+        # Clear any stale handlers (important for tests)
+        for h in root_logger.handlers[:]:
+            root_logger.removeHandler(h)
+            h.close()
+
+        # Console handler
+        if config.enable_console_log:
+            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler.setLevel(getattr(logging, config.log_level))
+            console_handler.setFormatter(self._get_formatter())
+            root_logger.addHandler(console_handler)
+
+        # Main rotating file handler
+        file_handler = self._create_file_handler(
+            str(config.log_file_path),
+            config.log_level,
+            config.log_rotation,
+            config.log_retention,
+        )
+        root_logger.addHandler(file_handler)
+
+        # Error log handler
+        if config.log_level not in ["ERROR", "CRITICAL"]:
+            error_handler = self._create_file_handler(
+                str(config.error_log_file_path),
+                "ERROR",
+                config.error_log_rotation,
+                config.error_log_retention,
+            )
+            root_logger.addHandler(error_handler)
+
+    def _create_file_handler(
+        self, filepath: str, level: str, rotation: str, retention: str
+    ) -> logging.Handler:
+        """Create a TimedRotatingFileHandler with compression."""
+
+        when, interval = self._parse_rotation(rotation)
+
+        handler = TimedRotatingFileHandler(
+            filepath,
+            when=when,
+            interval=interval,
+            backupCount=self._parse_retention(retention),
+            encoding="utf-8",
+            utc=False,
+        )
+
+        handler.setLevel(getattr(logging, level, logging.INFO))
+        handler.setFormatter(self._get_formatter())
+
+        # Patch doRollover to auto-compress old logs
+        original_doRollover = handler.doRollover
+
+        def compressed_doRollover(*args, **kwargs):
+            original_doRollover(*args, **kwargs)
+            try:
+                self._compress_old_logs(filepath)
+            except Exception:
+                # Prevent logging failure on compression errors
+                logging.getLogger(__name__).warning("Log compression failed", exc_info=True)
+
+        handler.doRollover = compressed_doRollover
+        return handler
+
+    def _parse_rotation(self, rotation: Optional[str]) -> tuple[str, int]:
+        """Parse rotation string like '1 day' or '6 hours'."""
+        if not rotation:
+            return "midnight", 1
+        rotation = rotation.lower()
+        num = int(re.findall(r"\d+", rotation)[0]) if re.search(r"\d+", rotation) else 1
+        if "hour" in rotation:
+            return "h", num
+        if "minute" in rotation:
+            return "m", num
+        return "midnight", num
+
+    def _parse_retention(self, retention: Optional[str]) -> int:
+        """Parse retention like '7 days'."""
+        if not retention:
+            return 7
+        if isinstance(retention, (int, float)):
+            return int(retention)
+        nums = re.findall(r"\d+", str(retention))
+        return int(nums[0]) if nums else 7
+
+    def _compress_old_logs(self, base_path: str) -> None:
+        """Compress all rotated logs except current."""
+        log_dir = os.path.dirname(base_path)
+        base_name = os.path.basename(base_path)
+
+        for f in os.listdir(log_dir):
+            if f.startswith(base_name) and not f.endswith(".gz"):
+                full_path = os.path.join(log_dir, f)
+                if f != base_name:  # Skip active file
+                    gz_path = f"{full_path}.gz"
+                    if not os.path.exists(gz_path):  # avoid double compress
+                        with open(full_path, "rb") as f_in, gzip.open(gz_path, "wb") as f_out:
+                            f_out.writelines(f_in)
+                        os.remove(full_path)
+
+    def _get_formatter(self) -> logging.Formatter:
+        """Return JSON or plain formatter."""
+        if self._config.enable_json_logs:
+            return JSONFormatter()
+        return logging.Formatter(self._config.default_format)
+
+    # -----------------------------
+    # Logging Methods
+    # -----------------------------
+
+    def _log_with_extra(self, level: int, message: str, **kwargs) -> None:
+        """Log message with structured context."""
+        if not self._logger.isEnabledFor(level):
+            return
+
+        # Prevent passing non-serializable extra
+        safe_extra = {"extra_data": kwargs}
+        self._logger.log(level, message, extra=safe_extra)
+
+    def debug(self, message: str, **kwargs): self._log_with_extra(logging.DEBUG, message, **kwargs)
+    def info(self, message: str, **kwargs): self._log_with_extra(logging.INFO, message, **kwargs)
+    def warning(self, message: str, **kwargs): self._log_with_extra(logging.WARNING, message, **kwargs)
+    def error(self, message: str, **kwargs): self._log_with_extra(logging.ERROR, message, **kwargs)
+    def critical(self, message: str, **kwargs): self._log_with_extra(logging.CRITICAL, message, **kwargs)
+
+    def exception(self, message: str, **kwargs):
+        """Log exception with traceback."""
+        self._logger.exception(message, extra={"extra_data": kwargs})
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset all logger instances (for testing)."""
+        root_logger = logging.getLogger()
+        for h in root_logger.handlers[:]:
+            root_logger.removeHandler(h)
+            h.close()
+
+        cls._instances.clear()
+        cls._config = None
+        cls._is_configured = False
+        cls._initialized_loggers.clear()

fastlib_py-0.3.9/fastlib/cache/_memony_cache.py

@@ -0,0 +1,67 @@
+# SPDX-License-Identifier: MIT
+"""Memory (MemoryStorage) Cache Manager for in-memory caching"""
+
+import asyncio
+
+
+class MemoryStorage:
+    """In-memory storage implementation"""
+
+    def __init__(self):
+        self._data = {}
+
+    async def set(self, key, value):
+        self._data[key] = value
+        return key
+
+    async def get(self, key):
+        return self._data.get(key)
+
+    async def update(self, key, **updated):
+        if key not in self._data:
+            return None
+
+        value = self._data[key]
+        for key, value in updated.items():
+            if hasattr(value, key):
+                setattr(value, key, value)
+
+        return value
+
+    async def delete(self, key):
+        if key in self._data:
+            del self._data[key]
+            return True
+        return False
+
+    async def list(self):
+        return list(self._data.values())
+
+
+class MemoryCacheManager:
+    """Singleton manager for in-memory (MemoryStorage) cache client."""
+
+    _instance = None
+    _lock = asyncio.Lock()
+
+    @classmethod
+    async def get_instance(cls):
+        """Get a singleton MemoryStorage instance."""
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._instance is None:
+                    cls._instance = MemoryStorage()
+        return cls._instance
+
+    @classmethod
+    async def close(cls):
+        """Close the MemoryStorage instance (for cleanup in tests)."""
+        if cls._instance is not None:
+            await cls._instance.close()
+            cls._instance = None
+
+    @classmethod
+    async def reset(cls):
+        """Clear all cached data without destroying the instance."""
+        if cls._instance is not None:
+            await cls._instance.flushall()

fastlib_py-0.3.9/fastlib/cache/_redis_cache.py

@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: MIT
+"""Redis cache implementation"""
+
+import asyncio
+from typing import Optional
+
+from loguru import logger
+
+import json
+from datetime import datetime, date
+from typing import Any, Type
+from redis._parsers.encoders import Encoder
+from pydantic import BaseModel
+
+from fastlib import ConfigManager
+
+try:
+    import redis.asyncio as redis
+except ModuleNotFoundError:
+    logger.warning(
+        "Cannot find redis module, please install it via `uv add redis[hiredis]`"
+    )
+    redis = None
+    RedisError = Exception
+except Exception:
+    logger.error("Error importing redis module")
+    redis = None
+    RedisError = Exception
+
+
+class CustomJsonEncoder(Encoder):
+    def encode(self, value: Any):
+        """Extended encoding to support datetime and Pydantic models."""
+        if isinstance(value, (datetime, date)):
+            return json.dumps(
+                {
+                    "__type__": "datetime",
+                    "value": value.isoformat(),
+                }
+            ).encode("utf-8")
+
+        elif isinstance(value, BaseModel):
+            return json.dumps(
+                {
+                    "__type__": "pydantic",
+                    "model": value.__class__.__name__,
+                    "module": value.__class__.__module__,
+                    "data": value.model_dump(),
+                }
+            ).encode("utf-8")
+
+        elif isinstance(value, dict):
+            return json.dumps(value).encode("utf-8")
+
+        return super().encode(value)
+
+    def decode(self, value, force=False):
+        """Extended decoding to restore datetime and Pydantic models."""
+        if self.decode_responses or force:
+            if isinstance(value, bytes):
+                value = value.decode(self.encoding, self.encoding_errors)
+                try:
+                    data = json.loads(value)
+                    if isinstance(data, dict) and "__type__" in data:
+                        if data["__type__"] == "datetime":
+                            return datetime.fromisoformat(data["value"])
+
+                        elif data["__type__"] == "pydantic":
+                            module_name = data.get("module")
+                            model_name = data.get("model")
+                            payload = data.get("data")
+
+                            # Dynamically import model class
+                            module = __import__(module_name, fromlist=[model_name])
+                            model_cls: Type[BaseModel] = getattr(module, model_name)
+                            return model_cls(**payload)
+
+                    return data
+                except json.JSONDecodeError:
+                    raise
+        return value
+
+
+class RedisCacheManager:
+    _instance: Optional["redis.Redis"] = None
+    _connection_pool: Optional["redis.ConnectionPool"] = None
+    _lock = asyncio.Lock()
+
+    @classmethod
+    async def get_instance(cls) -> "redis.Redis":
+        """
+        Get redis instance
+        """
+        if redis is None:
+            raise RuntimeError(
+                "Redis module is not available. Please install it via 'uv add redis[hiredis]'"
+            )
+
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._connection_pool is None:
+                    database_config = ConfigManager.get_database_config()
+                    cls._connection_pool = redis.ConnectionPool.from_url(
+                        f"redis://:{database_config.cache_pass}@{database_config.cache_host}:{database_config.cache_port}/{database_config.db_num}",
+                        encoder_class=CustomJsonEncoder,
+                        encoding="utf-8",
+                        encoding_errors="strict",
+                        decode_responses=True,
+                    )
+                if cls._instance is None:
+                    cls._instance = redis.Redis(connection_pool=cls._connection_pool)
+        return cls._instance
+
+    @classmethod
+    async def close_pool(cls):
+        """Close the connection pool."""
+        if cls._connection_pool:
+            await cls._connection_pool.disconnect()
+            cls._connection_pool = None
+            cls._instance = None

{fastlib_py-0.3.8 → fastlib_py-0.3.9}/fastlib_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.3.8
+Version: 0.3.9
 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>
@@ -21,9 +21,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiosqlite>=0.21
 Requires-Dist: alembic>=1.15.2
-Requires-Dist: fakeredis>=2.32
 Requires-Dist: fastapi[standard]>=0.115.12
-Requires-Dist: loguru>=0.7.3
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pyjwt[crypto]>=2.10.1

{fastlib_py-0.3.8 → fastlib_py-0.3.9}/fastlib_py.egg-info/requires.txt

@@ -1,8 +1,6 @@
 aiosqlite>=0.21
 alembic>=1.15.2
-fakeredis>=2.32
 fastapi[standard]>=0.115.12
-loguru>=0.7.3
 openpyxl>=3.1.5
 pandas>=2.2.3
 pyjwt[crypto]>=2.10.1

{fastlib_py-0.3.8 → fastlib_py-0.3.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastlib-py"
-version = "0.3.8"
+version = "0.3.9"
 description = "Fastlib, high performance, easy to use, fast to code, ready for production"
 readme = "README.md"
 keywords = [
@@ -31,9 +31,7 @@ classifiers = [
 dependencies = [
   "aiosqlite>=0.21",
   "alembic>=1.15.2",
-  "fakeredis>=2.32",
   "fastapi[standard]>=0.115.12",
-  "loguru>=0.7.3",
   "openpyxl>=3.1.5",
   "pandas>=2.2.3",
   "pyjwt[crypto]>=2.10.1",

fastlib_py-0.3.8/fastlib/_logging/config.py

@@ -1,109 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""
-Log configuration and logging utility for the application.
-"""
-
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Literal
-
-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")
-@dataclass
-class LogConfig(BaseConfig):
-    """
-    Configuration for logging settings.
-
-    Attributes:
-        log_dir (str): Directory where log files will be stored.
-        app_name (str): Name of the application for log file naming.
-        log_level (LogLevel): Minimum log level to record. Possible values: DEBUG, INFO, WARNING, ERROR, CRITICAL.
-        log_rotation (str): Frequency of log file rotation. Default is "1 day".
-        log_retention (str): How long to keep log files. Default is "90 days".
-        enable_console_log (bool): Whether to output logs to console. Default is True.
-        enable_json_logs (bool): Whether to use JSON format for logs. Default is False.
-        error_log_rotation (str): Frequency of error log rotation. Default is "1 day".
-        error_log_retention (str): How long to keep error log files. Default is "90 days".
-        enable_async (bool): Whether to use asynchronous logging. Default is True.
-        max_file_size (Optional[str]): Maximum size for log files before rotation. Default is "10 MB".
-        time_format (str): Format string for timestamps in log file names. Default is "YYYY-MM-DD".
-    """
-
-    log_dir: str = "/var/log"
-    app_name: str | None = 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: str | None = "10 MB"
-    time_format: str = "YYYY-MM-DD"
-
-    def __post_init__(self):
-        """
-        Set default app_name if not provided.
-
-        If `app_name` is not provided, it will be set to the name of the project
-        retrieved from the `pyproject.toml` file.
-        """
-        if self.app_name is None:
-            self.app_name = ProjectInfo.from_pyproject().name
-
-    @property
-    def default_format(self) -> str:
-        """
-        Default log format string.
-
-        Returns:
-            str: The default format used for log messages.
-        """
-        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.
-
-        Returns:
-            str: The pattern used to name the main log file.
-        """
-        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.
-
-        Returns:
-            str: The pattern used to name the error log file.
-        """
-        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.
-
-        Returns:
-            Path: The full path to 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.
-
-        Returns:
-            Path: The full path to the error log file.
-        """
-        return Path(self.log_dir) / self.error_log_file_pattern

fastlib_py-0.3.8/fastlib/_logging/handlers.py

@@ -1,171 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""
-A comprehensive logging tool for the application.
-"""
-
-import sys
-from pathlib import Path
-
-from loguru import logger
-
-from fastlib._logging.config import LogConfig
-from fastlib.config.manager import ConfigManager
-
-
-class Logger:
-    """
-    Enhanced logging tool support structured logging.
-    """
-
-    _instances: dict[str, "Logger"] = {}
-    _config: LogConfig | None = 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: str | None = 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.3.8/fastlib/cache/_memony_cache.py

@@ -1,35 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Memory (FakeRedis) Cache Manager for in-memory caching"""
-
-import asyncio
-
-from fakeredis.aioredis import FakeRedis
-
-
-class MemoryCacheManager:
-    """Singleton manager for in-memory (FakeRedis) cache client."""
-
-    _instance: FakeRedis | None = None
-    _lock = asyncio.Lock()
-
-    @classmethod
-    async def get_instance(cls) -> FakeRedis:
-        """Get a singleton FakeRedis instance."""
-        if cls._instance is None:
-            async with cls._lock:
-                if cls._instance is None:
-                    cls._instance = FakeRedis()
-        return cls._instance
-
-    @classmethod
-    async def close(cls):
-        """Close the FakeRedis instance (for cleanup in tests)."""
-        if cls._instance is not None:
-            await cls._instance.close()
-            cls._instance = None
-
-    @classmethod
-    async def reset(cls):
-        """Clear all cached data without destroying the instance."""
-        if cls._instance is not None:
-            await cls._instance.flushall()

fastlib_py-0.3.8/fastlib/cache/_redis_cache.py

@@ -1,58 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Redis cache implementation"""
-
-import asyncio
-from typing import Optional
-
-from loguru import logger
-
-from fastlib import ConfigManager
-
-try:
-    import redis.asyncio as redis
-except ModuleNotFoundError:
-    logger.warning(
-        "Cannot find redis module, please install it via `uv add redis[hiredis]`"
-    )
-    redis = None
-    RedisError = Exception
-except Exception:
-    logger.error("Error importing redis module")
-    redis = None
-    RedisError = Exception
-
-
-class RedisCacheManager:
-    _instance: Optional["redis.Redis"] = None
-    _connection_pool: Optional["redis.ConnectionPool"] = None
-    _lock = asyncio.Lock()
-
-    @classmethod
-    async def get_instance(cls) -> "redis.Redis":
-        """
-        Get redis instance
-        """
-        if redis is None:
-            raise RuntimeError(
-                "Redis module is not available. Please install it via 'uv add redis[hiredis]'"
-            )
-
-        if cls._instance is None:
-            async with cls._lock:
-                if cls._connection_pool is None:
-                    database_config = ConfigManager.get_database_config()
-                    cls._connection_pool = redis.ConnectionPool.from_url(
-                        f"redis://:{database_config.cache_pass}@{database_config.cache_host}:{database_config.cache_port}/{database_config.db_num}",
-                        decode_responses=True,
-                    )
-                if cls._instance is None:
-                    cls._instance = redis.Redis(connection_pool=cls._connection_pool)
-        return cls._instance
-
-    @classmethod
-    async def close_pool(cls):
-        """Close the connection pool."""
-        if cls._connection_pool:
-            await cls._connection_pool.disconnect()
-            cls._connection_pool = None
-            cls._instance = None