fastlib-py 0.2.0__tar.gz → 0.2.2__tar.gz

{fastlib_py-0.2.0/fastlib_py.egg-info → fastlib_py-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.0
+Version: 0.2.2
 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.0 → fastlib_py-0.2.2}/fastlib/cache/__init__.py

@@ -1,6 +1,6 @@
 """Provides a unified cache client based on configuration."""
 
-from .cache_manager import get_cache_client
+from .manager import get_cache_client
 
 __all__ = [
     get_cache_client,

{fastlib_py-0.2.0 → fastlib_py-0.2.2}/fastlib/cache/disk_cache.py

@@ -5,11 +5,11 @@ import json
 import threading
 import time
 from contextlib import asynccontextmanager
-from typing import Any, Optional, list
+from typing import Any, Optional
 
 import diskcache
 
-from fastlib.cache.base_cache import Cache, CacheError
+from fastlib.cache.base import Cache, CacheError
 
 
 class PageCache(Cache):

fastlib_py-0.2.0/fastlib/cache/cache_manager.py → fastlib_py-0.2.2/fastlib/cache/manager.py

@@ -1,8 +1,7 @@
 # SPDX-License-Identifier: MIT
 """Cache Client manager to instantiate the appropriate cache client"""
 
-from fastlib.cache.base_cache import Cache
-from fastlib.cache.redis_cache import RedisManager
+from fastlib.cache.base import Cache
 from fastlib.config.manager import ConfigManager
 
 
@@ -12,6 +11,7 @@ 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:

{fastlib_py-0.2.0 → fastlib_py-0.2.2}/fastlib/cache/redis_cache.py

@@ -5,17 +5,18 @@ import asyncio
 import time
 import uuid
 from contextlib import asynccontextmanager
-from typing import Any, Optional, list
+from typing import Any, Optional
 
 from loguru import logger
 
-from fastlib.cache.base_cache import Cache, CacheError
+from fastlib import ConfigManager
+from fastlib.cache.base import Cache, CacheError
 
 try:
     import redis.asyncio as redis
     from redis.exceptions import RedisError
 except ModuleNotFoundError:
-    logger.error(
+    logger.warning(
         "Cannot find redis module, please install it via `uv add redis[hiredis] and then uv remove diskcache`"
     )
     redis = None
@@ -25,8 +26,6 @@ except Exception:
     redis = None
     RedisError = Exception
 
-from fastlib.config.manager import load_config
-
 
 class RedisCache(Cache):
     def __init__(self, redis_client):
@@ -347,9 +346,9 @@ class RedisManager:
         if cls._instance is None:
             async with cls._lock:
                 if cls._connection_pool is None:
-                    database = load_config().database
+                    database_config = ConfigManager.get_database_config()
                     cls._connection_pool = redis.ConnectionPool.from_url(
-                        f"redis://:{database.cache_pass}@{database.cache_host}:{database.cache_port}/{database.db_num}",
+                        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:

fastlib_py-0.2.2/fastlib/config/base.py

@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: MIT
+"""Base configuration classes."""
+
+from abc import ABC, abstractmethod
+
+
+class BaseConfig(ABC):
+    """Base class for all configuration classes."""
+
+    @abstractmethod
+    def __str__(self) -> str:
+        """Return string representation of the configuration.
+
+        Returns:
+            str: String representation of the configuration instance.
+        """
+        pass

{fastlib_py-0.2.0 → fastlib_py-0.2.2}/fastlib/config/utils.py

@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: MIT
-
 """Configuration module util"""
 
 import configparser
@@ -60,7 +59,6 @@ class ProjectInfo:
             path = Path(file_util.find_project_root()) / "pyproject.toml"
         else:
             path = Path(pyproject_path)
-        print(f"{path}")
         if not path.exists():
             raise FileNotFoundError(f"{pyproject_path} does not exist")
 

{fastlib_py-0.2.0 → fastlib_py-0.2.2}/fastlib/constant/__init__.py

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

fastlib_py-0.2.2/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.2/fastlib/i18n/manager.py

@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: MIT
+"""
+Internationalization context manager
+"""
+
+import contextvars
+import functools
+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)
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def set_language(language: Language) -> None:
+    """Set current language"""
+    _language_context.set(language)
+
+
+def get_language() -> Language:
+    """Get current language"""
+    return _language_context.get()
+
+
+def get_language_code() -> str:
+    """Get current language code, e.g. 'en', 'zh'"""
+    return get_language().value
+
+
+def reset_language() -> None:
+    """Reset language to default"""
+    _language_context.set(Language.ENGLISH)
+
+
+def is_language(language: Language) -> bool:
+    """Check if current language matches"""
+    return get_language() == language
+
+
+class I18nContext:
+    """Context manager to temporarily switch language"""
+
+    def __init__(self, language: Language):
+        self.language = language
+        self._token: contextvars.Token | None = None
+
+    def __enter__(self):
+        self._token = _language_context.set(self.language)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._token is not None:
+            _language_context.reset(self._token)
+
+
+def with_language(language: Language) -> I18nContext:
+    """Helper to create context manager"""
+    return I18nContext(language)
+
+
+def _language_context_decorator(
+    language: Language, is_async: bool = False
+) -> Callable[[F], F]:
+    """Internal generator for sync/async language context decorators"""
+
+    def decorator(func: F) -> F:
+        if is_async:
+
+            @functools.wraps(func)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                with I18nContext(language):
+                    return await func(*args, **kwargs)
+
+            return async_wrapper
+        else:
+
+            @functools.wraps(func)
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
+                with I18nContext(language):
+                    return func(*args, **kwargs)
+
+            return wrapper
+
+    return decorator
+
+
+def language_context(language: Language) -> Callable[[F], F]:
+    """Decorator: run a sync function within a language context"""
+    return _language_context_decorator(language, is_async=False)
+
+
+def async_language_context(
+    language: Language,
+) -> Callable[[Callable[..., Awaitable[Any]]], Callable[..., Awaitable[Any]]]:
+    """Decorator: run an async function within a language context"""
+    return _language_context_decorator(language, is_async=True)

fastlib_py-0.2.2/fastlib/i18n/messages.py

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: MIT
+"""Load i18n data and export get message method"""
+
+import json
+from pathlib import Path
+from typing import Optional, Union
+
+from fastlib.constant import RESOURCE_DIR
+from fastlib.i18n.types import Language
+
+from .manager import get_language
+
+DEFAULT_BASE_DIR = Path(RESOURCE_DIR) / "i18n"
+TRANSLATIONS = {
+    "zh": {"debug": {"test_message": "这是一条调试测试消息"}},
+    "en": {"debug": {"test_message": "This is a debug test message"}},
+}
+
+
+def load_translations(base_dirs: Union[Path, list[Path], None] = None):
+    """Load translation files from specified directories.
+
+    Args:
+        base_dirs: Path or list of paths to translation directories.
+
+    File structure:
+        base_dir/{lang}/{namespace}.json
+        Example: i18n/en/error.json
+
+    Note: Later directories override earlier ones for duplicate keys.
+    """
+    if base_dirs is None:
+        base_dirs = [DEFAULT_BASE_DIR]
+    elif isinstance(base_dirs, Path):
+        base_dirs = [base_dirs]
+
+    for base_dir in base_dirs:
+        if not base_dir.exists():
+            continue  # Skip if directory doesn't exist
+
+        for lang in [Language.CHINESE, Language.ENGLISH]:
+            lang_dir = base_dir / lang.value
+            if not lang_dir.exists():
+                continue  # Skip if language directory doesn't exist
+
+            # Initialize language dict if not exists
+            if lang.value not in TRANSLATIONS:
+                TRANSLATIONS[lang.value] = {}
+
+            for file in lang_dir.glob("*.json"):
+                namespace = (
+                    file.stem
+                )  # Determine message_type from filename, e.g., error, success
+                with open(file, encoding="utf-8") as f:
+                    translations_data = json.load(f)
+
+                    # Merge with existing namespace data or create new
+                    if namespace in TRANSLATIONS[lang.value]:
+                        TRANSLATIONS[lang.value][namespace].update(translations_data)
+                    else:
+                        TRANSLATIONS[lang.value][namespace] = translations_data
+
+
+def get_message(
+    message_type: str, key: str, language: Optional[Language] = None
+) -> str:
+    """Get translated message for given type, key and language.
+
+    Args:
+        message_type: Namespace/category of the message (e.g., 'error', 'success')
+        key: Message identifier key
+        language: Target language
+
+    Returns:
+        Translated message or fallback to default language if not found
+    """
+
+    if not language:
+        language = get_language()
+    # Try to get message from requested language
+    lang_dict = TRANSLATIONS.get(language.value, {})
+    msg = lang_dict.get(message_type, {}).get(key)
+    print(f"lang_dict: {lang_dict}")
+    if msg:
+        return msg
+
+    default_language = Language.ENGLISH.value
+    # Fallback to default language
+    return (
+        TRANSLATIONS.get(default_language, {})
+        .get(message_type, {})
+        .get(key, f"Unknown {message_type} message: {key}")
+    )

fastlib_py-0.2.2/fastlib/i18n/types.py

@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: MIT
+"""
+Internationalization type definitions with extensible language support
+"""
+
+from enum import Enum
+from typing import Optional
+
+
+class Language(Enum):
+    """Extensible language enumeration with metadata support"""
+
+    CHINESE = "zh"
+    ENGLISH = "en"
+
+    # Language metadata (can be extended)
+    _metadata: dict[str, dict[str, str]] = {
+        "zh": {"name": "Chinese", "native_name": "中文", "direction": "ltr"},
+        "en": {"name": "English", "native_name": "English", "direction": "ltr"},
+    }
+
+    @property
+    def display_name(self) -> str:
+        """Get language display name"""
+        return self._metadata[self.value]["name"]
+
+    @property
+    def native_name(self) -> str:
+        """Get native language name"""
+        return self._metadata[self.value]["native_name"]
+
+    @property
+    def direction(self) -> str:
+        """Get text direction (ltr/rtl)"""
+        return self._metadata[self.value]["direction"]
+
+    @classmethod
+    def register(
+        cls, code: str, name: str, native_name: str, direction: str = "ltr"
+    ) -> None:
+        """Register a new language dynamically
+
+        Args:
+            code: Language code (e.g., 'es', 'fr')
+            name: English display name
+            native_name: Native language name
+            direction: Text direction ('ltr' or 'rtl')
+        """
+        if hasattr(cls, code.upper()):
+            raise ValueError(f"Language {code} already registered")
+
+        # Create new enum member
+        new_member = Enum.value.__new__(cls)
+        new_member._value_ = code
+        cls._member_map_[code.upper()] = new_member
+        cls._member_names_.append(code.upper())
+
+        # Add metadata
+        cls._metadata[code] = {
+            "name": name,
+            "native_name": native_name,
+            "direction": direction,
+        }
+
+    @classmethod
+    def from_code(cls, code: str) -> Optional["Language"]:
+        """Get Language enum from language code
+
+        Args:
+            code: Language code (e.g., 'zh', 'en')
+
+        Returns:
+            Language enum or None if not found
+        """
+        code_upper = code.upper()
+        return cls._member_map_.get(code_upper)
+
+    @classmethod
+    def supported_codes(cls) -> set[str]:
+        """Get set of all supported language codes"""
+        return {member.value for member in cls}
+
+    @classmethod
+    def is_supported(cls, code: str) -> bool:
+        """Check if language code is supported"""
+        return code in cls.supported_codes()
+
+
+# if __name__ == "__main__":
+#     # Register new languages dynamically
+#     Language.register("es", "Spanish", "Español")
+#     Language.register("ja", "Japanese", "日本語")
+#     Language.register("ar", "Arabic", "العربية", "rtl")
+
+#     # Access new languages
+#     spanish = Language.ES
+#     print(f"Spanish code: {spanish.value}")  # es
+#     print(f"Spanish native: {spanish.native_name}")  # Español
+
+#     # Check support
+#     print(Language.is_supported("fr"))  # False
+#     print(Language.is_supported("ja"))  # True
+
+#     # Get from code
+#     japanese = Language.from_code("ja")
+#     print(japanese.display_name)  # Japanese

fastlib_py-0.2.2/fastlib/i18n/utils.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: MIT
+"""
+Internationalization utilities
+"""
+
+from typing import Optional
+
+from .manager import I18nContext
+from .messages import get_message
+from .types import Language
+
+# Default language
+DEFAULT_LANGUAGE = Language.ENGLISH
+
+# Language alias mapping
+LANGUAGE_MAPPING = {
+    "zh": Language.CHINESE,
+    "zh_cn": Language.CHINESE,
+    "en": Language.ENGLISH,
+    "en_us": Language.ENGLISH,
+}
+
+
+def _resolve_language(language: Optional[Language]) -> Language:
+    """Return given language or current context default"""
+    return language or I18nContext.get_language()
+
+
+def parse_language(language_str: Optional[str]) -> Language:
+    """Parse string like 'zh-CN', 'en-US' to Language enum"""
+    if not language_str:
+        return DEFAULT_LANGUAGE
+    return LANGUAGE_MAPPING.get(
+        language_str.lower().replace("-", "_"), DEFAULT_LANGUAGE
+    )
+
+
+def get_localized_message(
+    category: str, key: str, language: Optional[Language] = None
+) -> str:
+    """Get localized message by category ('error', 'success', 'business')"""
+    lang = _resolve_language(language)
+    return get_message(category, key, lang)

{fastlib_py-0.2.0 → fastlib_py-0.2.2}/fastlib/logging/config.py

@@ -64,3 +64,12 @@ class LogConfig(BaseConfig):
     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"
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the database configuration.
+
+        Returns:
+            A string representation of the DatabaseConfig instance.
+        """
+        return f"{self.__class__.__name__}({self.__dict__})"

{fastlib_py-0.2.0 → fastlib_py-0.2.2}/fastlib/mapper/impl/base_mapper_impl.py

@@ -11,7 +11,7 @@ from sqlmodel.ext.asyncio.session import AsyncSession
 from fastlib.constant import FilterOperators, constant
 from fastlib.enums import SortEnum
 from fastlib.mapper.base_mapper import BaseMapper
-from fastlib.middleware.db_session_middleware import db
+from fastlib.middleware.db_session import db
 from fastlib.schema import SortItem
 
 IDType = TypeVar("IDType", int, str)

fastlib_py-0.2.2/fastlib/middleware/__init__.py

@@ -0,0 +1,7 @@
+"""Export middleware symbols."""
+
+from .db_session import SQLAlchemyMiddleware, db
+from .jwt import jwt_middleware
+from .log import log_requests
+
+__all__ = [SQLAlchemyMiddleware, jwt_middleware, log_requests, db]