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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastlib-py
-Version: 0.2.6
+Version: 0.2.7
 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.7}/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.7}/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.7}/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.7}/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.6 → fastlib_py-0.2.7}/fastlib_py.egg-info/PKG-INFO

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

@@ -1,126 +1,127 @@
-[project]
-name = "fastlib-py"
-version = "0.2.6"
-description = "Fastlib, high performance, easy to use, fast to code, ready for production"
-readme = "README.md"
-keywords = [
-  "fastapi",
-  "library",
-  "sqlmodel",
-  "web",
-]
-license = "MIT"
-maintainers = [
-  { name = "tyvekZhang", email = "tyvekzhang@gmail.com" },
-]
-authors = [
-  { name = "tyvekZhang", email = "tyvekzhang@gmail.com" },
-]
-requires-python = ">=3.9"
-classifiers = [
-  "Development Status :: 4 - Beta",
-  "Programming Language :: Python",
-  "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.9",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-  "Programming Language :: Python :: 3.13",
-  "Programming Language :: Python :: Implementation :: CPython",
-  "Programming Language :: Python :: Implementation :: PyPy",
-]
-dependencies = [
-  "aiosqlite>=0.21",
-  "alembic>=1.15.2",
-  "asgi-correlation-id>=4.3.4",
-  "cryptography>=45.0.6",
-  "diskcache>=5.6.3",
-  "fastapi[standard]>=0.115.12",
-  "loguru>=0.7.3",
-  "openpyxl>=3.1.5",
-  "pandas>=2.2.3",
-  "passlib[bcrypt]>=1.7.4",
-  "pyjwt>=2.10.1",
-  "sqlmodel>=0.0.24",
-]
-
-urls.Homepage = "https://github.com/tyvekzhang/fastlib"
-
-[dependency-groups]
-dev = [
-  "coverage>=7.8",
-  "httpx>=0.28.1",
-  "pre-commit>=4.2",
-  "pytest>=8.3.5",
-  "pytest-asyncio>=1.1",
-]
-
-docs = [
-  "sphinx>=7.2.6",
-  "sphinx-rtd-theme>=2",
-]
-
-[tool.ruff]
-line-length = 88
-
-include = [ "fastlib/**/*.py", "main.py" ]
-exclude = [ "doc/**/*.py" ]
-
-lint.select = [
-  "B",  # flake8-bugbear
-  "C4", # flake8-comprehensions
-  "E",  # pycodestyle errors
-  "F",  # pyflakes
-  "I",  # isort
-  "UP", # pyupgrade
-  "W",  # pycodestyle warnings
-]
-lint.ignore = [
-  "B008", # do not perform function calls in argument defaults
-  "C901", # too complex
-  "E501", # line too long, handled by black
-  "W191", # indentation contains tabs
-]
-lint.isort.known-third-party = [
-  "aiosqlite",
-  "alembic",
-  "diskcache",
-  "fastapi",
-  "loguru",
-  "openpyxl",
-  "pandas",
-  "passlib",
-  "pyjwt",
-  "sqlmodel",
-  "starlette",
-  "pydantic",
-  "bcrypt",
-  "cryptography",
-]
-# Preserve types, even if a file imports `from __future__ import annotations`.
-lint.pyupgrade.keep-runtime-typing = true
-
-[tool.coverage.run]
-parallel = true
-data_file = "coverage/.coverage"
-source = [ "src/main/app", "src/tests", "main.py" ]
-context = '${CONTEXT}'
-dynamic_context = "test_function"
-omit = [
-]
-
-[tool.coverage.report]
-fail_under = 90
-show_missing = true
-sort = "-Cover"
-
-[tool.coverage.html]
-show_contexts = true
-
-[tool.mypy]
-strict = true
-
-[[tool.uv.index]]
-name = "tsinghua"
-url = "https://pypi.tuna.tsinghua.edu.cn/simple/"
-default = true
+[project]
+name = "fastlib-py"
+version = "0.2.7"
+description = "Fastlib, high performance, easy to use, fast to code, ready for production"
+readme = "README.md"
+keywords = [
+  "fastapi",
+  "library",
+  "sqlmodel",
+  "web",
+]
+license = "MIT"
+maintainers = [
+  { name = "tyvekZhang", email = "tyvekzhang@gmail.com" },
+]
+authors = [
+  { name = "tyvekZhang", email = "tyvekzhang@gmail.com" },
+]
+requires-python = ">=3.9"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "aiosqlite>=0.21",
+  "alembic>=1.15.2",
+  "asgi-correlation-id>=4.3.4",
+  "cryptography>=45.0.6",
+  "diskcache>=5.6.3",
+  "fastapi[standard]>=0.115.12",
+  "loguru>=0.7.3",
+  "openpyxl>=3.1.5",
+  "pandas>=2.2.3",
+  "passlib[bcrypt]>=1.7.4",
+  "pyjwt>=2.10.1",
+  "sqlmodel>=0.0.24",
+]
+
+urls.Homepage = "https://github.com/tyvekzhang/fastlib"
+
+[dependency-groups]
+dev = [
+  "coverage>=7.8",
+  "httpx>=0.28.1",
+  "pre-commit>=4.2",
+  "pytest>=8.3.5",
+  "pytest-asyncio>=1.1",
+]
+
+docs = [
+  "sphinx>=7.2.6",
+  "sphinx-rtd-theme>=2",
+]
+
+[tool.ruff]
+line-length = 88
+
+include = [ "fastlib/**/*.py", "main.py" ]
+exclude = [ "doc/**/*.py" ]
+
+lint.select = [
+  "B",  # flake8-bugbear
+  "C4", # flake8-comprehensions
+  "E",  # pycodestyle errors
+  "F",  # pyflakes
+  "I",  # isort
+  "UP", # pyupgrade
+  "W",  # pycodestyle warnings
+]
+lint.ignore = [
+  "B008", # do not perform function calls in argument defaults
+  "C901", # too complex
+  "E501", # line too long, handled by black
+  "W191", # indentation contains tabs
+]
+lint.isort.known-third-party = [
+  "aiosqlite",
+  "alembic",
+  "diskcache",
+  "fastapi",
+  "loguru",
+  "openpyxl",
+  "pandas",
+  "passlib",
+  "pyjwt",
+  "sqlmodel",
+  "starlette",
+  "pydantic",
+  "bcrypt",
+  "cryptography",
+]
+# Preserve types, even if a file imports `from __future__ import annotations`.
+lint.pyupgrade.keep-runtime-typing = true
+
+[tool.coverage.run]
+data_file = "coverage/.coverage"
+source = [ "fastlib" ]
+context = '${CONTEXT}'
+dynamic_context = "test_function"
+omit = [
+]
+
+[tool.coverage.report]
+fail_under = 90
+show_missing = true
+sort = "-Cover"
+
+[tool.coverage.html]
+show_contexts = true
+directory = "coverage/html"
+title = "FastLib Coverage Report"
+
+[tool.mypy]
+strict = true
+
+[[tool.uv.index]]
+name = "tsinghua"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple/"
+default = true