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

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

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

@@ -1,8 +1,8 @@
 # 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,7 +12,8 @@ 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

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

@@ -0,0 +1,96 @@
+"""
+Internationalization context manager
+"""
+
+import contextvars
+import functools
+from typing import Any, Callable, TypeVar, Awaitable
+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.1/fastlib/i18n/messages.py

@@ -0,0 +1,88 @@
+import json
+from pathlib import Path
+from typing import List, Optional, Union
+from fastlib.constant.constant import RESOURCE_DIR
+from fastlib.i18n.types import Language
+
+# Default i18n directory (assumed to be in the same directory as this file)
+DEFAULT_BASE_DIR = Path(RESOURCE_DIR) / "i18n"
+
+# Global cache for translation data
+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 multilingual translation files from multiple directories.
+
+    Args:
+        base_dirs: Single directory path or list of directory paths for translation files.
+                   If not provided, uses the default DEFAULT_BASE_DIR.
+
+    File structure requirements:
+        Each directory should follow: base_dir/{lang}/{namespace}.json
+        Example: i18n/zh/error.json
+
+    Note: Later directories will override translations from earlier directories
+          if the same language and namespace exist.
+    """
+    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, "r", 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: Language) -> 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
+    """
+    default_language = Language.CHINESE.value
+
+    # Try to get message from requested language
+    lang_dict = TRANSLATIONS.get(language.value, {})
+    msg = lang_dict.get(message_type, {}).get(key)
+
+    if msg:
+        return msg
+
+    # Fallback to default language
+    return (
+        TRANSLATIONS.get(default_language, {})
+        .get(message_type, {})
+        .get(key, f"Unknown {message_type} message: {key}")
+    )

fastlib_py-0.2.1/fastlib/i18n/utils.py

@@ -0,0 +1,86 @@
+"""
+Internationalization utilities
+"""
+
+from typing import Any, 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,
+}
+
+# --- Helpers ---
+
+
+def _resolve_language(language: Optional[Language]) -> Language:
+    """Return given language or current context default"""
+    return language or I18nContext.get_language()
+
+
+# --- Core utilities ---
+
+
+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)
+
+
+def get_error_message(key: str, language: Optional[Language] = None) -> str:
+    return get_localized_message("error", key, language)
+
+
+def get_success_message(key: str, language: Optional[Language] = None) -> str:
+    return get_localized_message("success", key, language)
+
+
+def create_error_response(
+    error_key: str,
+    language: Optional[Language] = None,
+    details: Optional[str] = None,
+    error_code: int = 400,
+) -> dict[str, Any]:
+    lang = _resolve_language(language)
+    error = {
+        "code": error_code,
+        "message": get_error_message(error_key, lang),
+        "language": lang.value,
+    }
+    if details:
+        error["details"] = details
+    return {"success": False, "error": error}
+
+
+def create_success_response(
+    data: Any,
+    language: Optional[Language] = None,
+    message_key: str = "search_success",
+) -> dict[str, Any]:
+    lang = _resolve_language(language)
+    return {
+        "success": True,
+        "data": data,
+        "message": get_success_message(message_key, lang),
+        "language": lang.value,
+    }

{fastlib_py-0.2.0 → fastlib_py-0.2.1}/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.1}/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.1/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]

fastlib_py-0.2.1/fastlib/middleware/i18n.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: MIT
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from fastlib.i18n.types import Language
+
+
+class I18nMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for automatic language detection and setting based on HTTP headers.
+    
+    This middleware inspects the Accept-Language header from incoming requests
+    and sets the appropriate language in the request state for use throughout
+    the application.
+    
+    The language preference is stored in request.state.language and can be
+    accessed in route handlers and other middleware.
+    
+    Example:
+        ```python
+        from fastapi import FastAPI, Request
+        
+        app = FastAPI()
+        app.add_middleware(I18nMiddleware)
+        
+        @app.get("/")
+        async def root(request: Request):
+            language = request.state.language
+            return {"language": language.value}
+        ```
+    
+    Note:
+        Currently supports only English and Chinese. Defaults to English
+        if the Accept-Language header is not present or unrecognized.
+    """
+    
+    async def dispatch(self, request, call_next):
+        """
+        Process the request and set the language based on Accept-Language header.
+        
+        Args:
+            request: The incoming HTTP request
+            call_next: The next middleware or route handler in the chain
+            
+        Returns:
+            The HTTP response from the next handler
+        """
+        # Get language preference from request headers
+        accept_lang = request.headers.get("Accept-Language", "en")
+
+        # Set the language for current request
+        if accept_lang.startswith("en"):
+            request.state.language = Language.ENGLISH
+        else:
+            request.state.language = Language.CHINESE
+
+        response = await call_next(request)
+        return response

fastlib_py-0.2.0/fastlib/middleware/jwt_middleware.py → fastlib_py-0.2.1/fastlib/middleware/jwt.py

@@ -6,12 +6,12 @@ import http
 from fastapi import Request
 from jwt.exceptions import PyJWTError
 from loguru import logger
-from src.main.app.enums.auth_error_code import AuthErrorCode
 from starlette.responses import JSONResponse
 
 from fastlib import ConfigManager, constant, security
 from fastlib.context.contextvars import current_user_id
 from fastlib.enums.enum import MediaTypeEnum
+from fastlib.enums import AuthErrorCode
 from fastlib.schema import UserCredential
 
 # Load configuration

{fastlib_py-0.2.0 → fastlib_py-0.2.1}/fastlib/model/base_model.py

@@ -47,12 +47,12 @@ class ModelExt(_SQLModel):
     Create time and update time for a model, can be automatically generated
     """
 
-    create_time: Optional[datetime] = Field(
+    create_at: Optional[datetime] = Field(
         sa_type=DateTime,
         default_factory=datetime.utcnow,
         sa_column_kwargs={"comment": "创建时间"},
     )
-    update_time: Optional[datetime] = Field(
+    update_at: Optional[datetime] = Field(
         sa_type=DateTime,
         default_factory=datetime.utcnow,
         sa_column_kwargs={

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.0
+Version: 0.2.1
 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.1}/fastlib_py.egg-info/SOURCES.txt

@@ -3,9 +3,9 @@ README.md
 pyproject.toml
 fastlib/__init__.py
 fastlib/cache/__init__.py
-fastlib/cache/base_cache.py
-fastlib/cache/cache_manager.py
+fastlib/cache/base.py
 fastlib/cache/disk_cache.py
+fastlib/cache/manager.py
 fastlib/cache/redis_cache.py
 fastlib/config/__init__.py
 fastlib/config/base.py
@@ -27,10 +27,10 @@ fastlib/exception/__init__.py
 fastlib/exception/custom_exception.py
 fastlib/exception/exception_handler.py
 fastlib/exception/exception_manager.py
-fastlib/i18n/i18n_context.py
-fastlib/i18n/i18n_messages.py
-fastlib/i18n/i18n_types.py
-fastlib/i18n/i18n_util.py
+fastlib/i18n/manager.py
+fastlib/i18n/messages.py
+fastlib/i18n/types.py
+fastlib/i18n/utils.py
 fastlib/logging/__init__.py
 fastlib/logging/config.py
 fastlib/logging/handlers.py
@@ -39,9 +39,10 @@ fastlib/mapper/base_mapper.py
 fastlib/mapper/impl/__init__.py
 fastlib/mapper/impl/base_mapper_impl.py
 fastlib/middleware/__init__.py
-fastlib/middleware/db_session_middleware.py
-fastlib/middleware/jwt_middleware.py
-fastlib/middleware/log_middleware.py
+fastlib/middleware/db_session.py
+fastlib/middleware/i18n.py
+fastlib/middleware/jwt.py
+fastlib/middleware/log.py
 fastlib/migrate/migrate.py
 fastlib/model/__init__.py
 fastlib/model/base_model.py
@@ -54,6 +55,7 @@ fastlib/schema/response.py
 fastlib/schema/schema.py
 fastlib/security/__init__.py
 fastlib/security/security.py
+fastlib/security/utils.py
 fastlib/service/__init__.py
 fastlib/service/base_service.py
 fastlib/service/impl/__init__.py
@@ -66,7 +68,6 @@ fastlib/utils/excel_util.py
 fastlib/utils/file_util.py
 fastlib/utils/http_util.py
 fastlib/utils/ip_util.py
-fastlib/utils/security_util.py
 fastlib/utils/snowflake_util.py
 fastlib/utils/str_util.py
 fastlib_py.egg-info/PKG-INFO

{fastlib_py-0.2.0 → fastlib_py-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastlib-py"
-version = "0.2.0"
+version = "0.2.1"
 description = "Fastlib, high performance, easy to use, fast to code, ready for production"
 readme = "README.md"
 keywords = [

fastlib_py-0.2.0/fastlib/config/base.py

@@ -1,6 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Base configuration classes."""
-
-
-class BaseConfig:
-    """Base class for all configuration classes."""