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

{fastlib_py-0.2.1 → fastlib_py-0.2.2}/PKG-INFO

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

@@ -2,7 +2,6 @@
 """Cache Client manager to instantiate the appropriate cache client"""
 
 from fastlib.cache.base import Cache
-
 from fastlib.config.manager import ConfigManager
 
 
@@ -13,7 +12,7 @@ async def get_cache_client() -> Cache:
         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.1 → 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.1 → fastlib_py-0.2.2}/fastlib/i18n/manager.py

@@ -1,10 +1,13 @@
+# SPDX-License-Identifier: MIT
 """
 Internationalization context manager
 """
 
 import contextvars
 import functools
-from typing import Any, Callable, TypeVar, Awaitable
+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)

{fastlib_py-0.2.1 → fastlib_py-0.2.2}/fastlib/i18n/messages.py

@@ -1,32 +1,33 @@
+# SPDX-License-Identifier: MIT
+"""Load i18n data and export get message method"""
+
 import json
 from pathlib import Path
-from typing import List, Optional, Union
-from fastlib.constant.constant import RESOURCE_DIR
+from typing import Optional, Union
+
+from fastlib.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"
+from .manager import get_language
 
-# Global cache for translation data
+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 multilingual translation files from multiple directories.
+def load_translations(base_dirs: Union[Path, list[Path], None] = None):
+    """Load translation files from specified directories.
 
     Args:
-        base_dirs: Single directory path or list of directory paths for translation files.
-                   If not provided, uses the default DEFAULT_BASE_DIR.
+        base_dirs: Path or list of paths to translation directories.
 
-    File structure requirements:
-        Each directory should follow: base_dir/{lang}/{namespace}.json
-        Example: i18n/zh/error.json
+    File structure:
+        base_dir/{lang}/{namespace}.json
+        Example: i18n/en/error.json
 
-    Note: Later directories will override translations from earlier directories
-          if the same language and namespace exist.
+    Note: Later directories override earlier ones for duplicate keys.
     """
     if base_dirs is None:
         base_dirs = [DEFAULT_BASE_DIR]
@@ -50,7 +51,7 @@ def load_translations(base_dirs: Union[Path, List[Path], None] = None):
                 namespace = (
                     file.stem
                 )  # Determine message_type from filename, e.g., error, success
-                with open(file, "r", encoding="utf-8") as f:
+                with open(file, encoding="utf-8") as f:
                     translations_data = json.load(f)
 
                     # Merge with existing namespace data or create new
@@ -60,7 +61,9 @@ def load_translations(base_dirs: Union[Path, List[Path], None] = None):
                         TRANSLATIONS[lang.value][namespace] = translations_data
 
 
-def get_message(message_type: str, key: str, language: Language) -> str:
+def get_message(
+    message_type: str, key: str, language: Optional[Language] = None
+) -> str:
     """Get translated message for given type, key and language.
 
     Args:
@@ -71,15 +74,17 @@ def get_message(message_type: str, key: str, language: Language) -> str:
     Returns:
         Translated message or fallback to default language if not found
     """
-    default_language = Language.CHINESE.value
 
+    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, {})

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.1 → fastlib_py-0.2.2}/fastlib/middleware/i18n.py

@@ -7,40 +7,40 @@ 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
         """
@@ -54,4 +54,4 @@ class I18nMiddleware(BaseHTTPMiddleware):
             request.state.language = Language.CHINESE
 
         response = await call_next(request)
-        return response
+        return response

{fastlib_py-0.2.1 → fastlib_py-0.2.2}/fastlib/middleware/jwt.py

@@ -2,6 +2,7 @@
 """JWT middleware for FastAPI authentication"""
 
 import http
+from enum import Enum
 
 from fastapi import Request
 from jwt.exceptions import PyJWTError
@@ -11,7 +12,6 @@ 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
@@ -19,6 +19,32 @@ server_config = ConfigManager.get_server_config()
 security_config = ConfigManager.get_security_config()
 
 
+class JWTErrorCode(Enum):
+    """Authentication error codes with code and message"""
+
+    OPENAPI_FORBIDDEN = (403, "OpenAPI documentation is disabled")
+    TOKEN_EXPIRED = (401, "Authorization token has expired")
+    MISSING_TOKEN = (401, "Authorization token is missing")
+
+    def __init__(self, code: int, message: str):
+        self._code = code
+        self._message = message
+
+    @property
+    def code(self) -> int:
+        """Get error code"""
+        return self._code
+
+    @property
+    def message(self) -> str:
+        """Get error message"""
+        return self._message
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary format for JSON response"""
+        return {"code": self.code, "message": self.message}
+
+
 async def jwt_middleware(request: Request, call_next):
     ctx_token: UserCredential | None = None
     try:
@@ -32,8 +58,8 @@ async def jwt_middleware(request: Request, call_next):
                 return JSONResponse(
                     status_code=http.HTTPStatus.FORBIDDEN,
                     content={
-                        "code": AuthErrorCode.OPENAPI_FORBIDDEN.code,
-                        "message": AuthErrorCode.OPENAPI_FORBIDDEN.message,
+                        "code": JWTErrorCode.OPENAPI_FORBIDDEN.code,
+                        "message": JWTErrorCode.OPENAPI_FORBIDDEN.message,
                     },
                 )
 
@@ -63,16 +89,16 @@ async def jwt_middleware(request: Request, call_next):
                 return JSONResponse(
                     status_code=http.HTTPStatus.UNAUTHORIZED,
                     content={
-                        "code": AuthErrorCode.TOKEN_EXPIRED.code,
-                        "message": AuthErrorCode.TOKEN_EXPIRED.message,
+                        "code": JWTErrorCode.TOKEN_EXPIRED.code,
+                        "message": JWTErrorCode.TOKEN_EXPIRED.message,
                     },
                 )
         else:
             return JSONResponse(
                 status_code=http.HTTPStatus.UNAUTHORIZED,
                 content={
-                    "code": AuthErrorCode.MISSING_TOKEN.code,
-                    "message": AuthErrorCode.MISSING_TOKEN.message,
+                    "code": JWTErrorCode.MISSING_TOKEN.code,
+                    "message": JWTErrorCode.MISSING_TOKEN.message,
                 },
             )
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.1
+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.1 → fastlib_py-0.2.2}/pyproject.toml

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

fastlib_py-0.2.1/fastlib/constant/constant.py

@@ -1,31 +0,0 @@
-# SPDX-License-Identifier: MIT
-"""Common constant"""
-
-import os
-
-from fastlib.utils import file_util
-
-RESOURCE_DIR: str = 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"
-
-
-class FilterOperators:
-    EQ = "EQ"
-    NE = "NE"
-    GT = "GT"
-    GE = "GE"
-    LT = "LT"
-    LE = "LE"
-    BETWEEN = "BETWEEN"
-    LIKE = "LIKE"

fastlib_py-0.2.1/fastlib/i18n/types.py

@@ -1,12 +0,0 @@
-"""
-Internationalization type definitions
-"""
-
-from enum import Enum
-
-
-class Language(Enum):
-    """Supported language enumeration"""
-
-    CHINESE = "zh"
-    ENGLISH = "en"

fastlib_py-0.2.1/fastlib/i18n/utils.py

@@ -1,86 +0,0 @@
-"""
-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,
-    }