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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.3.8
+Version: 0.4.0
 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,7 +21,6 @@ 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

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/__init__.py

@@ -1,12 +1,10 @@
 # SPDX-License-Identifier: MIT
 """Fastlib Application Libraries Package."""
 
-from ._logging.config import LogConfig as LogConfig
 from .config import ConfigManager as ConfigManager
 from .openapi import register_offline_openapi as register_offline_openapi
 
 __all__ = [
     "ConfigManager",
-    "LogConfig",
     "register_offline_openapi",
 ]

fastlib_py-0.4.0/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.4.0/fastlib/cache/_redis_cache.py

@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: MIT
+"""Redis cache implementation"""
+
+import asyncio
+import json
+from datetime import date, datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel
+from redis._parsers.encoders import Encoder
+
+from fastlib import ConfigManager
+from fastlib.logging.handlers import logger
+
+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.4.0}/fastlib/config/__init__.py

@@ -1,4 +1,5 @@
 from .base import BaseConfig
-from .manager import ConfigManager, config_class
+from .decorator import config_class
+from .manager import ConfigManager
 
 __all__ = ["BaseConfig", "ConfigManager", "config_class"]

fastlib_py-0.4.0/fastlib/config/_log_config.py

@@ -0,0 +1,102 @@
+# 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.utils import ProjectInfo
+
+LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+
+@dataclass
+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.4.0/fastlib/config/decorator.py

@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: MIT
+"""Decorator for easy registration"""
+
+from fastlib.config.base import BaseConfig
+from fastlib.config.registry import ConfigRegistry
+
+
+def config_class(name: str):
+    """
+    Decorator to register a configuration class.
+
+    Args:
+        name: The name to register the configuration under
+
+    Usage:
+        @config_class("my_config")
+        class MyConfig(BaseConfig):
+            pass
+    """
+
+    def decorator(cls: type[BaseConfig]):
+        ConfigRegistry.register(name, cls)
+        return cls
+
+    return decorator

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/config/loader.py

@@ -5,7 +5,6 @@ import os
 from typing import Any
 
 import yaml
-from loguru import logger
 
 from fastlib import constants as constant
 from fastlib.config import utils as config_util
@@ -48,9 +47,6 @@ class ConfigLoader:
             yaml.YAMLError: If there is an error parsing the YAML
         """
         if not os.path.exists(file_path):
-            logger.warning(
-                f"Config file not found: {file_path}, will use the default config"
-            )
             return {}
 
         with open(file_path, encoding="utf-8") as file:

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/config/manager.py

@@ -7,6 +7,7 @@ from typing import Any
 from fastlib import constants as constant
 from fastlib.config import utils as config_util
 from fastlib.config._database_config import DatabaseConfig
+from fastlib.config._log_config import LogConfig
 from fastlib.config._security_config import SecurityConfig
 from fastlib.config._server_config import ServerConfig
 from fastlib.config.base import BaseConfig
@@ -14,27 +15,6 @@ from fastlib.config.loader import ConfigLoader
 from fastlib.config.registry import ConfigRegistry
 
 
-# Decorator for easy registration
-def config_class(name: str):
-    """
-    Decorator to register a configuration class.
-
-    Args:
-        name: The name to register the configuration under
-
-    Usage:
-        @config_class("my_config")
-        class MyConfig(BaseConfig):
-            pass
-    """
-
-    def decorator(cls: type[BaseConfig]):
-        ConfigRegistry.register(name, cls)
-        return cls
-
-    return decorator
-
-
 class ConfigManager:
     """Global configuration manager with static methods and dynamic registry support."""
 
@@ -108,6 +88,7 @@ class ConfigManager:
             "server": ServerConfig,
             "database": DatabaseConfig,
             "security": SecurityConfig,
+            "log": LogConfig,
         }
 
         for name, config_class in default_configs.items():
@@ -194,6 +175,19 @@ class ConfigManager:
             raise RuntimeError("Security configuration not properly initialized")
         return instance
 
+    @staticmethod
+    def get_log_config() -> LogConfig:
+        """
+        Get the log configuration.
+
+        Returns:
+            LogConfig: The log configuration object
+        """
+        instance = ConfigManager.get_config_instance("log")
+        if not isinstance(instance, LogConfig):
+            raise RuntimeError("Log configuration not properly initialized")
+        return instance
+
     @staticmethod
     def is_initialized() -> bool:
         """

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/config/utils.py

@@ -6,8 +6,6 @@ from pathlib import Path
 from typing import Any, NamedTuple
 from urllib.parse import urlparse
 
-from loguru import logger
-
 from fastlib.enums import DBTypeEnum
 from fastlib.utils import file_util
 
@@ -16,8 +14,8 @@ try:
 except ModuleNotFoundError:
     import toml as tomllib
 except Exception:
-    logger.error(
-        "Cannot find tomllib module, please install it via `uv add tomllib` or `pip install tomllib`"
+    print(
+        "Cannot find toml module, please install it via `uv add toml` or `pip install toml`"
     )
 
 
@@ -175,7 +173,7 @@ def get_db_url() -> str:
     try:
         return get_alembic_db_info(file_util.get_file_path("alembic.ini")).full_url
     except FileNotFoundError:
-        logger.warning("Can not found alembic.ini in the project, use default db url")
+        print("Can not found alembic.ini in the project, use default db url")
         return "sqlite+aiosqlite:///./fastlib.db"
 
 

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/contextvars.py

@@ -8,7 +8,7 @@ the current authenticated user's ID throughout the request lifecycle.
 from contextvars import ContextVar
 from typing import Any
 
-from loguru import logger
+from fastlib.logging.handlers import logger
 
 # Type aliases for better readability
 UserID = int | None

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/exception/exception_handler.py

@@ -11,12 +11,12 @@ from fastapi.exception_handlers import http_exception_handler
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse, Response
 from fastapi.utils import is_body_allowed_for_status_code
-from loguru import logger
 from pydantic_core._pydantic_core import ValidationError  # noqa
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from fastlib import ConfigManager
 from fastlib.exception import BaseException
+from fastlib.logging.handlers import logger
 
 
 async def extract_request_data(request: Request) -> dict[str, Any]:

fastlib_py-0.4.0/fastlib/logging/__init__.py

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: MIT
+"""Export logging module"""
+
+from .handlers import Logger
+
+logger = Logger.initialize()
+
+__all__ = [
+    "logger",
+]

{fastlib_py-0.3.8/fastlib/_logging → fastlib_py-0.4.0/fastlib/logging}/handlers.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 from loguru import logger
 
-from fastlib._logging.config import LogConfig
+from fastlib.config._log_config import LogConfig
 from fastlib.config.manager import ConfigManager
 
 
@@ -42,7 +42,7 @@ class Logger:
     def _get_config(cls) -> LogConfig:
         """Lazy load configuration."""
         if cls._config is None:
-            cls._config = ConfigManager.get_config_instance("log")
+            cls._config = ConfigManager.get_log_config()
         return cls._config
 
     @classmethod

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/middleware/jwt.py

@@ -6,13 +6,13 @@ from enum import Enum
 
 from fastapi import Request
 from jwt.exceptions import PyJWTError
-from loguru import logger
 from starlette.responses import JSONResponse
 
 from fastlib import ConfigManager, security
 from fastlib import constants as constant
 from fastlib.contextvars import clear_current_user, set_current_user
 from fastlib.enums import MediaTypeEnum
+from fastlib.logging.handlers import logger
 from fastlib.schema import UserCredential
 
 # Load configuration

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/migrate.py

@@ -4,7 +4,7 @@
 import importlib
 from pathlib import Path
 
-from loguru import logger
+from fastlib.logging.handlers import logger
 
 current_path = Path(__file__).resolve()
 src_parent = None

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/router.py

@@ -12,10 +12,11 @@ import traceback
 from pathlib import Path
 
 from fastapi import APIRouter
-from loguru import logger
 
 from fastlib.utils import str_util
 
+from .logging.handlers import logger
+
 
 def register_router(
     controller_dirs: list[str] = None,

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/stream/handler.py

@@ -11,10 +11,10 @@ from collections.abc import AsyncIterable
 from datetime import datetime
 from typing import Any, Generic, TypeVar
 
-from loguru import logger
 from pydantic import BaseModel
 
 from fastlib.cache.manager import get_cache_client
+from fastlib.logging.handlers import logger
 
 from .schema import (
     BaseMessage,

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/stream/sse.py

@@ -18,13 +18,13 @@ from typing import (
 )
 
 import anyio
-from loguru import logger
 from starlette.background import BackgroundTask
 from starlette.concurrency import iterate_in_threadpool
 from starlette.datastructures import MutableHeaders
 from starlette.responses import Response
 from starlette.types import Message, Receive, Scope, Send
 
+from fastlib.logging.handlers import logger
 from fastlib.stream.event import ServerSentEvent, ensure_bytes
 
 # Context variable for exit events per event loop
@@ -176,7 +176,6 @@ class EventSourceResponse(Response):
 
         async for data in self.body_iterator:
             chunk = ensure_bytes(data, self.sep)
-            logger.debug("chunk: %s", chunk)
             with anyio.move_on_after(self.send_timeout) as cancel_scope:
                 await send(
                     {"type": "http.response.body", "body": chunk, "more_body": True}
@@ -233,7 +232,6 @@ class EventSourceResponse(Response):
                 )
             )
             ping_bytes = ensure_bytes(sse_ping, self.sep)
-            logger.debug("ping: %s", ping_bytes)
 
             async with self._send_lock:
                 if self.active:

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/utils/excel_util.py

@@ -7,13 +7,14 @@ from contextlib import contextmanager
 from datetime import datetime
 
 import pandas as pd
-from loguru import logger
 from openpyxl.styles import Alignment, Font, PatternFill
 from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.worksheet import Worksheet
 from pydantic import BaseModel
 from starlette.responses import StreamingResponse
 
+from fastlib.logging.handlers import logger
+
 
 class ExcelExporter:
     """Excel export handler for Pydantic models with customizable styling."""

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib/utils/http_util.py

@@ -12,7 +12,8 @@ import uuid
 from typing import Any
 
 import httpx
-from loguru import logger
+
+from fastlib.logging.handlers import logger
 
 
 class HTTPError(Exception):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.3.8
+Version: 0.4.0
 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,7 +21,6 @@ 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

{fastlib_py-0.3.8 → fastlib_py-0.4.0}/fastlib_py.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ fastlib/constants.py
 fastlib/contextvars.py
 fastlib/db_engine.py
 fastlib/enums.py
-fastlib/logging.py
 fastlib/migrate.py
 fastlib/openapi.py
 fastlib/py.typed
@@ -15,18 +14,17 @@ fastlib/response.py
 fastlib/router.py
 fastlib/schema.py
 fastlib/security.py
-fastlib/_logging/__init__.py
-fastlib/_logging/config.py
-fastlib/_logging/handlers.py
 fastlib/cache/__init__.py
 fastlib/cache/_memony_cache.py
 fastlib/cache/_redis_cache.py
 fastlib/cache/manager.py
 fastlib/config/__init__.py
 fastlib/config/_database_config.py
+fastlib/config/_log_config.py
 fastlib/config/_security_config.py
 fastlib/config/_server_config.py
 fastlib/config/base.py
+fastlib/config/decorator.py
 fastlib/config/loader.py
 fastlib/config/manager.py
 fastlib/config/registry.py
@@ -40,6 +38,8 @@ fastlib/i18n/manager.py
 fastlib/i18n/messages.py
 fastlib/i18n/types.py
 fastlib/i18n/utils.py
+fastlib/logging/__init__.py
+fastlib/logging/handlers.py
 fastlib/mapper/__init__.py
 fastlib/mapper/base_mapper.py
 fastlib/mapper/impl/__init__.py

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

@@ -1,6 +1,5 @@
 aiosqlite>=0.21
 alembic>=1.15.2
-fakeredis>=2.32
 fastapi[standard]>=0.115.12
 loguru>=0.7.3
 openpyxl>=3.1.5

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

@@ -1,6 +1,6 @@
 [project]
 name = "fastlib-py"
-version = "0.3.8"
+version = "0.4.0"
 description = "Fastlib, high performance, easy to use, fast to code, ready for production"
 readme = "README.md"
 keywords = [
@@ -31,7 +31,6 @@ 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",
@@ -118,6 +117,6 @@ title = "FastLib Coverage Report"
 strict = true
 
 [[tool.uv.index]]
-name = "ustc"
-url = "https://pypi.mirrors.ustc.edu.cn/simple/"
+name = "huaweicloud"
+url = "https://repo.huaweicloud.com/repository/pypi/simple/"
 default = true

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/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

fastlib_py-0.3.8/fastlib/logging.py

@@ -1,8 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""
-Logging module
-"""
-
-from _logging.handlers import Logger
-
-logger = Logger.initialize()