fastlib-py 0.2.6__tar.gz → 0.2.8__tar.gz

{fastlib_py-0.2.6 → fastlib_py-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.6
+Version: 0.2.8
 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.6 → fastlib_py-0.2.8}/fastlib/config/loader.py

@@ -5,6 +5,7 @@ import os
 from typing import Any, Optional
 
 import yaml
+from loguru import logger
 
 from fastlib import constant
 from fastlib.config import utils as config_util
@@ -47,7 +48,10 @@ class ConfigLoader:
             yaml.YAMLError: If there is an error parsing the YAML
         """
         if not os.path.exists(file_path):
-            raise FileNotFoundError(f"Config file not found: {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:
             try:

{fastlib_py-0.2.6 → fastlib_py-0.2.8}/fastlib/config/manager.py

@@ -123,9 +123,6 @@ class ConfigManager:
         for config_name in ConfigRegistry.list_registered():
             config_data = ConfigManager._global_config_dict.get(config_name, {})
 
-            if not config_data:
-                continue
-
             try:
                 instance = ConfigRegistry.create_instance(
                     config_name, {config_name: config_data}

{fastlib_py-0.2.6 → fastlib_py-0.2.8}/fastlib/config/utils.py

@@ -172,7 +172,11 @@ def get_alembic_db_info(
 
 def get_db_url() -> str:
     """Get the database connection URL from alembic.ini configuration."""
-    return get_alembic_db_info(file_util.get_file_path("alembic.ini")).full_url
+    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")
+        return "sqlite+aiosqlite:///./fastlib.db"
 
 
 def get_sqlite_db_path() -> str:

{fastlib_py-0.2.6 → fastlib_py-0.2.8}/fastlib/mapper/impl/base_mapper_impl.py

@@ -550,7 +550,7 @@ class SqlModelMapper(BaseMapper, Generic[ModelType]):
 
         # Query children for the current level
         stmt = select(self.model).where(self.model.parent_id.in_(parent_ids))
-        result = await db_session.execute(stmt)
+        result = await db_session.exec(stmt)
         children = result.scalars().all()
 
         # Convert ORM children to SchemaType instances

{fastlib_py-0.2.6 → fastlib_py-0.2.8}/fastlib/security/utils.py

@@ -10,7 +10,7 @@ from typing import Optional, Union
 try:
     from cryptography.fernet import Fernet
     from cryptography.hazmat.primitives import hashes, serialization
-    from cryptography.hazmat.primitives.asymmetric import padding, rsa
+    from cryptography.hazmat.primitives.asymmetric import ed25519, padding, rsa
     from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 
     HAS_CRYPTOGRAPHY = True
@@ -137,110 +137,6 @@ class SymmetricEncryption:
         return decrypted.decode("utf-8")
 
 
-class SimpleSymmetricEncryption:
-    """Simple symmetric encryption using XOR and HMAC (when cryptography is not available)."""
-
-    def __init__(self, key: Optional[bytes] = None) -> None:
-        """
-        Initialize simple symmetric encryption with a key.
-
-        Args:
-            key: Encryption key. If None, generates a new key.
-        """
-        if key is None:
-            self._key = os.urandom(32)
-        else:
-            self._key = key[:32] if len(key) > 32 else key.ljust(32, b"\x00")
-
-    def get_key(self) -> bytes:
-        """Get the encryption key."""
-        return self._key
-
-    def _xor_encrypt_decrypt(self, data: bytes) -> bytes:
-        """XOR encryption/decryption."""
-        key_len = len(self._key)
-        return bytes(data[i] ^ self._key[i % key_len] for i in range(len(data)))
-
-    def encrypt(self, plaintext: Union[str, bytes]) -> bytes:
-        """
-        Encrypt plaintext data using XOR + HMAC.
-
-        Args:
-            plaintext: Data to encrypt
-
-        Returns:
-            Encrypted data with HMAC
-        """
-        if isinstance(plaintext, str):
-            plaintext = plaintext.encode("utf-8")
-
-        # Add random IV
-        iv = os.urandom(16)
-
-        # XOR encrypt
-        encrypted = self._xor_encrypt_decrypt(plaintext)
-
-        # Create HMAC for integrity
-        mac = hmac.new(self._key, iv + encrypted, hashlib.sha256).digest()
-
-        return iv + mac + encrypted
-
-    def decrypt(self, ciphertext: bytes) -> bytes:
-        """
-        Decrypt ciphertext data.
-
-        Args:
-            ciphertext: Encrypted data to decrypt
-
-        Returns:
-            Decrypted data
-
-        Raises:
-            ValueError: If decryption fails or HMAC verification fails
-        """
-        if len(ciphertext) < 48:  # 16 (IV) + 32 (HMAC) = 48 minimum
-            raise ValueError("Invalid ciphertext length")
-
-        iv = ciphertext[:16]
-        mac = ciphertext[16:48]
-        encrypted = ciphertext[48:]
-
-        # Verify HMAC
-        expected_mac = hmac.new(self._key, iv + encrypted, hashlib.sha256).digest()
-        if not hmac.compare_digest(mac, expected_mac):
-            raise ValueError("HMAC verification failed")
-
-        # XOR decrypt
-        return self._xor_encrypt_decrypt(encrypted)
-
-    def encrypt_string(self, plaintext: str) -> str:
-        """
-        Encrypt string and return base64 encoded result.
-
-        Args:
-            plaintext: String to encrypt
-
-        Returns:
-            Base64 encoded encrypted string
-        """
-        encrypted = self.encrypt(plaintext)
-        return base64.b64encode(encrypted).decode("utf-8")
-
-    def decrypt_string(self, ciphertext: str) -> str:
-        """
-        Decrypt base64 encoded string.
-
-        Args:
-            ciphertext: Base64 encoded encrypted string
-
-        Returns:
-            Decrypted string
-        """
-        encrypted_bytes = base64.b64decode(ciphertext.encode("utf-8"))
-        decrypted = self.decrypt(encrypted_bytes)
-        return decrypted.decode("utf-8")
-
-
 class HMACSigner:
     """HMAC-based message signing and verification."""
 
@@ -463,6 +359,248 @@ class RSASigner:
             return False
 
 
+class Ed25519Signer:
+    """Ed25519 elliptic curve digital signing and verification."""
+
+    def __init__(
+        self, private_key: Optional[bytes] = None, public_key: Optional[bytes] = None
+    ) -> None:
+        """
+        Initialize Ed25519 signer.
+
+        Args:
+            private_key: PEM encoded private key for signing
+            public_key: PEM encoded public key for verification
+
+        Raises:
+            ImportError: If cryptography package is not available
+        """
+        if not HAS_CRYPTOGRAPHY:
+            raise ImportError(
+                "cryptography package is required for Ed25519Signer. Install it with: uv add cryptography"
+            )
+
+        self._private_key = None
+        self._public_key = None
+
+        if private_key:
+            self._private_key = serialization.load_pem_private_key(
+                private_key, password=None
+            )
+            # Validate that it's an Ed25519 key
+            if not isinstance(self._private_key, ed25519.Ed25519PrivateKey):
+                raise ValueError("Private key is not an Ed25519 key")
+
+        if public_key:
+            self._public_key = serialization.load_pem_public_key(public_key)
+            # Validate that it's an Ed25519 key
+            if not isinstance(self._public_key, ed25519.Ed25519PublicKey):
+                raise ValueError("Public key is not an Ed25519 key")
+
+    @classmethod
+    def generate_keypair(cls) -> tuple[bytes, bytes]:
+        """
+        Generate Ed25519 key pair.
+
+        Returns:
+            Tuple of (private_key_pem, public_key_pem)
+
+        Raises:
+            ImportError: If cryptography package is not available
+        """
+        if not HAS_CRYPTOGRAPHY:
+            raise ImportError(
+                "cryptography package is required for Ed25519Signer. Install it with: uv add cryptography"
+            )
+
+        # Generate private key
+        private_key = ed25519.Ed25519PrivateKey.generate()
+
+        # Serialize private key
+        private_pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+
+        # Serialize public key
+        public_pem = private_key.public_key().public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+
+        return private_pem, public_pem
+
+    @classmethod
+    def from_private_key_bytes(cls, private_key_bytes: bytes) -> "Ed25519Signer":
+        """
+        Create Ed25519Signer from raw private key bytes.
+
+        Args:
+            private_key_bytes: Raw 32-byte private key
+
+        Returns:
+            Ed25519Signer instance
+        """
+        if not HAS_CRYPTOGRAPHY:
+            raise ImportError(
+                "cryptography package is required for Ed25519Signer. Install it with: uv add cryptography"
+            )
+
+        private_key = ed25519.Ed25519PrivateKey.from_private_bytes(private_key_bytes)
+        private_pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        return cls(private_key=private_pem)
+
+    def get_private_key_bytes(self) -> bytes:
+        """
+        Get raw private key bytes (32 bytes).
+
+        Returns:
+            Raw private key bytes
+
+        Raises:
+            ValueError: If private key is not available
+        """
+        if not self._private_key:
+            raise ValueError("Private key not available")
+
+        # Extract raw private key bytes from PEM
+        private_bytes = self._private_key.private_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PrivateFormat.Raw,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+        return private_bytes
+
+    def get_public_key_bytes(self) -> bytes:
+        """
+        Get raw public key bytes (32 bytes).
+
+        Returns:
+            Raw public key bytes
+
+        Raises:
+            ValueError: If public key is not available
+        """
+        if self._public_key:
+            public_key = self._public_key
+        elif self._private_key:
+            public_key = self._private_key.public_key()
+        else:
+            raise ValueError("No public key available")
+
+        public_bytes = public_key.public_bytes(
+            encoding=serialization.Encoding.Raw,
+            format=serialization.PublicFormat.Raw,
+        )
+        return public_bytes
+
+    def sign(self, message: Union[str, bytes]) -> str:
+        """
+        Create Ed25519 signature for message.
+
+        Args:
+            message: Message to sign
+
+        Returns:
+            Base64 encoded signature
+
+        Raises:
+            ValueError: If private key is not available
+        """
+        if not self._private_key:
+            raise ValueError("Private key required for signing")
+
+        if isinstance(message, str):
+            message = message.encode("utf-8")
+
+        # Ed25519 signing is straightforward, no padding needed
+        signature = self._private_key.sign(message)
+
+        return base64.b64encode(signature).decode("utf-8")
+
+    def verify(self, message: Union[str, bytes], signature: str) -> bool:
+        """
+        Verify Ed25519 signature.
+
+        Args:
+            message: Original message
+            signature: Base64 encoded signature to verify
+
+        Returns:
+            True if signature is valid, False otherwise
+        """
+        public_key = self._public_key
+        if not public_key and self._private_key:
+            public_key = self._private_key.public_key()
+
+        if not public_key:
+            return False
+
+        try:
+            if isinstance(message, str):
+                message = message.encode("utf-8")
+
+            signature_bytes = base64.b64decode(signature.encode("utf-8"))
+
+            public_key.verify(signature_bytes, message)
+            return True
+        except Exception:
+            return False
+
+    def sign_detached(self, message: Union[str, bytes]) -> bytes:
+        """
+        Create detached Ed25519 signature (raw bytes).
+
+        Args:
+            message: Message to sign
+
+        Returns:
+            Raw signature bytes (64 bytes)
+
+        Raises:
+            ValueError: If private key is not available
+        """
+        if not self._private_key:
+            raise ValueError("Private key required for signing")
+
+        if isinstance(message, str):
+            message = message.encode("utf-8")
+
+        return self._private_key.sign(message)
+
+    def verify_detached(self, message: Union[str, bytes], signature: bytes) -> bool:
+        """
+        Verify detached Ed25519 signature.
+
+        Args:
+            message: Original message
+            signature: Raw signature bytes to verify
+
+        Returns:
+            True if signature is valid, False otherwise
+        """
+        public_key = self._public_key
+        if not public_key and self._private_key:
+            public_key = self._private_key.public_key()
+
+        if not public_key:
+            return False
+
+        try:
+            if isinstance(message, str):
+                message = message.encode("utf-8")
+
+            public_key.verify(signature, message)
+            return True
+        except Exception:
+            return False
+
+
 def generate_random_key(length: int = 32) -> str:
     """
     Generate a random key for symmetric encryption.
@@ -534,29 +672,31 @@ def verify_password(password: str, hashed_password: str, salt: str) -> bool:
         return False
 
 
-def create_symmetric_encryption(
-    key: Optional[bytes] = None,
-) -> Union[SymmetricEncryption, SimpleSymmetricEncryption]:
+def create_symmetric_encryption(key: Optional[bytes] = None) -> SymmetricEncryption:
     """
-    Create a symmetric encryption instance using the best available method.
+    Create a symmetric encryption instance.
 
     Args:
         key: Encryption key. If None, generates a new key.
 
     Returns:
-        SymmetricEncryption if cryptography is available, SimpleSymmetricEncryption otherwise
+        SymmetricEncryption instance
+
+    Raises:
+        ImportError: If cryptography package is not available
     """
-    if HAS_CRYPTOGRAPHY:
-        return SymmetricEncryption(key)
-    else:
-        return SimpleSymmetricEncryption(key)
+    if not HAS_CRYPTOGRAPHY:
+        raise ImportError(
+            "cryptography package is required for encryption. Install it with: uv add cryptography"
+        )
+    return SymmetricEncryption(key)
 
 
 def encrypt_data(
     data: Union[str, bytes], key: Optional[bytes] = None
 ) -> tuple[bytes, bytes]:
     """
-    Encrypt data using the best available symmetric encryption.
+    Encrypt data using symmetric encryption.
 
     Args:
         data: Data to encrypt
@@ -564,6 +704,9 @@ def encrypt_data(
 
     Returns:
         Tuple of (encrypted_data, key_used)
+
+    Raises:
+        ImportError: If cryptography package is not available
     """
     encryptor = create_symmetric_encryption(key)
     encrypted = encryptor.encrypt(data)
@@ -572,7 +715,7 @@ def encrypt_data(
 
 def decrypt_data(encrypted_data: bytes, key: bytes) -> bytes:
     """
-    Decrypt data using the best available symmetric encryption.
+    Decrypt data using symmetric encryption.
 
     Args:
         encrypted_data: Encrypted data
@@ -580,6 +723,9 @@ def decrypt_data(encrypted_data: bytes, key: bytes) -> bytes:
 
     Returns:
         Decrypted data
+
+    Raises:
+        ImportError: If cryptography package is not available
     """
     encryptor = create_symmetric_encryption(key)
     return encryptor.decrypt(encrypted_data)

fastlib_py-0.2.8/fastlib/service/base_service.py

@@ -0,0 +1,187 @@
+# SPDX-License-Identifier: MIT
+"""Abstract service with common database operations."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Generic, Optional, TypeVar
+
+from pydantic import BaseModel
+from sqlmodel import SQLModel
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from fastlib.schema import SortItem
+
+IDType = TypeVar("IDType", int, str)
+ModelType = TypeVar("ModelType", bound=SQLModel)
+
+
+class BaseService(Generic[ModelType], ABC):
+    """Base service interface with common CRUD operations"""
+
+    @abstractmethod
+    async def save(
+        self, data: BaseModel, db_session: Optional[AsyncSession] = None
+    ) -> BaseModel:
+        """Insert a single record"""
+        pass
+
+    @abstractmethod
+    async def save_batch(
+        self, data_list: list[BaseModel], db_session: Optional[AsyncSession] = None
+    ) -> int:
+        """Batch insert records"""
+        pass
+
+    @abstractmethod
+    async def save_or_update(
+        self, data: BaseModel, db_session: Optional[AsyncSession] = None
+    ) -> bool:
+        """Insert or update a record"""
+        pass
+
+    @abstractmethod
+    async def save_or_update_batch(
+        self, data_list: list[BaseModel], db_session: Optional[AsyncSession] = None
+    ) -> bool:
+        """Batch insert or update records"""
+        pass
+
+    @abstractmethod
+    async def remove_by_id(
+        self, id: IDType, db_session: Optional[AsyncSession] = None
+    ) -> bool:
+        """Delete record by ID"""
+        pass
+
+    @abstractmethod
+    async def remove_by_ids(
+        self, ids: list[IDType], db_session: Optional[AsyncSession] = None
+    ) -> bool:
+        """Batch delete records by IDs"""
+        pass
+
+    @abstractmethod
+    async def remove(self, db_session: Optional[AsyncSession] = None, **kwargs) -> bool:
+        """Delete records by conditions"""
+        pass
+
+    @abstractmethod
+    async def update_by_id(
+        self, data: BaseModel, db_session: Optional[AsyncSession] = None
+    ) -> bool:
+        """Update record by ID"""
+        pass
+
+    @abstractmethod
+    async def update_batch_by_ids(
+        self,
+        ids: list[IDType],
+        data: dict[str, Any],
+        db_session: Optional[AsyncSession] = None,
+    ) -> bool:
+        """Batch update records by IDs"""
+        pass
+
+    @abstractmethod
+    async def batch_update(
+        self, data_list: list[BaseModel], db_session: Optional[AsyncSession] = None
+    ) -> bool:
+        """Batch update records"""
+        pass
+
+    @abstractmethod
+    async def update(
+        self, data: BaseModel, db_session: Optional[AsyncSession] = None, **kwargs
+    ) -> bool:
+        """Update records by conditions"""
+        pass
+
+    @abstractmethod
+    async def get_by_id(
+        self,
+        id: IDType,
+        fields: Optional[list[str]] = None,
+        db_session: Optional[AsyncSession] = None,
+    ) -> Optional[BaseModel]:
+        """Get record by ID"""
+        pass
+
+    @abstractmethod
+    async def get_one(
+        self, db_session: Optional[AsyncSession] = None, **kwargs
+    ) -> Optional[BaseModel]:
+        """Get one record by conditions"""
+        pass
+
+    @abstractmethod
+    async def list_by_ids(
+        self,
+        ids: list[IDType],
+        fields: Optional[list[str]] = None,
+        db_session: Optional[AsyncSession] = None,
+    ) -> list[BaseModel]:
+        """Get records by IDs"""
+        pass
+
+    @abstractmethod
+    async def list_all(
+        self,
+        fields: Optional[list[str]] = None,
+        db_session: Optional[AsyncSession] = None,
+        **kwargs,
+    ) -> list[BaseModel]:
+        """Get all records with optional filtering"""
+        pass
+
+    @abstractmethod
+    async def list(
+        self, db_session: Optional[AsyncSession] = None, **kwargs
+    ) -> list[BaseModel]:
+        """Get records by conditions"""
+        pass
+
+    @abstractmethod
+    async def page(
+        self,
+        current: int = 1,
+        page_size: int = 100,
+        count: bool = True,
+        fields: Optional[list[str]] = None,
+        db_session: Optional[AsyncSession] = None,
+        **kwargs,
+    ) -> tuple[list[BaseModel], int]:
+        """Paginated query"""
+        pass
+
+    @abstractmethod
+    async def page_ordered(
+        self,
+        current: int = 1,
+        page_size: int = 100,
+        count: bool = True,
+        sort_list: Optional[list[SortItem]] = None,
+        fields: Optional[list[str]] = None,
+        db_session: Optional[AsyncSession] = None,
+        **kwargs,
+    ) -> tuple[list[BaseModel], int]:
+        """Paginated query with ordering"""
+        pass
+
+    @abstractmethod
+    async def count(self, db_session: Optional[AsyncSession] = None, **kwargs) -> int:
+        """Count records by conditions"""
+        pass
+
+    @abstractmethod
+    async def exists(self, db_session: Optional[AsyncSession] = None, **kwargs) -> bool:
+        """Check if records exist by conditions"""
+        pass
+
+    @abstractmethod
+    async def get_children_tree(
+        self,
+        parent_data: list[BaseModel],
+        max_level: int = 5,
+        db_session: Optional[AsyncSession] = None,
+    ) -> list[BaseModel]:
+        """Get children tree recursively"""
+        pass