velocity-python 0.0.131__tar.gz → 0.0.134__tar.gz

{velocity_python-0.0.131 → velocity_python-0.0.134}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.131
+Version: 0.0.134
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.131 → velocity_python-0.0.134}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.131"
+version = "0.0.134"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.131 → velocity_python-0.0.134}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.131"
+__version__ = version = "0.0.134"
 
 from . import aws
 from . import db

velocity_python-0.0.134/src/velocity/app/tests/__init__.py

@@ -0,0 +1 @@
+# App module tests

velocity_python-0.0.134/src/velocity/aws/tests/__init__.py

@@ -0,0 +1 @@
+# AWS module tests

{velocity_python-0.0.131 → velocity_python-0.0.134}/src/velocity/db/core/decorators.py

@@ -99,7 +99,8 @@ def return_default(
 
 def create_missing(func):
     """
-    If the function call fails with DbColumnMissingError or DbTableMissingError, tries to create them and re-run.
+    If the function call fails with DbColumnMissingError or DbTableMissingError, 
+    tries to create them and re-run (only if schema is not locked).
     """
 
     @wraps(func)
@@ -109,8 +110,16 @@ def create_missing(func):
             result = func(self, *args, **kwds)
             self.tx.release_savepoint(sp, cursor=self.cursor())
             return result
-        except exceptions.DbColumnMissingError:
+        except exceptions.DbColumnMissingError as e:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
+            
+            # Check if schema is locked
+            if self.tx.engine.schema_locked:
+                raise exceptions.DbSchemaLockedError(
+                    f"Cannot create missing column: schema is locked. Original error: {e}"
+                ) from e
+                
+            # Existing logic for automatic creation
             data = {}
             if "pk" in kwds:
                 data.update(kwds["pk"])
@@ -121,8 +130,16 @@ def create_missing(func):
                     data.update(arg)
             self.alter(data)
             return func(self, *args, **kwds)
-        except exceptions.DbTableMissingError:
+        except exceptions.DbTableMissingError as e:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
+            
+            # Check if schema is locked
+            if self.tx.engine.schema_locked:
+                raise exceptions.DbSchemaLockedError(
+                    f"Cannot create missing table: schema is locked. Original error: {e}"
+                ) from e
+                
+            # Existing logic for automatic creation
             data = {}
             if "pk" in kwds:
                 data.update(kwds["pk"])

{velocity_python-0.0.131 → velocity_python-0.0.134}/src/velocity/db/core/engine.py

@@ -1,5 +1,7 @@
 import inspect
 import re
+import os
+from contextlib import contextmanager
 from functools import wraps
 from velocity.db import exceptions
 from velocity.db.core.transaction import Transaction
@@ -17,11 +19,12 @@ class Engine:
 
     MAX_RETRIES = 100
 
-    def __init__(self, driver, config, sql, connect_timeout=5):
+    def __init__(self, driver, config, sql, connect_timeout=5, schema_locked=False):
         self.__config = config
         self.__sql = sql
         self.__driver = driver
         self.__connect_timeout = connect_timeout
+        self.__schema_locked = schema_locked
 
     def __str__(self):
         return f"[{self.sql.server}] engine({self.config})"
@@ -205,6 +208,29 @@ class Engine:
     def sql(self):
         return self.__sql
 
+    @property
+    def schema_locked(self):
+        """Returns True if schema modifications are locked."""
+        return self.__schema_locked
+
+    def lock_schema(self):
+        """Lock schema to prevent automatic modifications."""
+        self.__schema_locked = True
+
+    def unlock_schema(self):
+        """Unlock schema to allow automatic modifications."""
+        self.__schema_locked = False
+
+    @contextmanager
+    def unlocked_schema(self):
+        """Temporarily unlock schema for automatic creation."""
+        original_state = self.__schema_locked
+        self.__schema_locked = False
+        try:
+            yield self
+        finally:
+            self.__schema_locked = original_state
+
     @property
     def version(self):
         """
@@ -353,12 +379,12 @@ class Engine:
         if sql:
             formatted_sql_info = f" sql={self._format_sql_with_params(sql, parameters)}"
 
-        logger.warning(
-            "Database error caught. Attempting to transform: code=%s message=%s%s",
-            error_code,
-            error_message,
-            formatted_sql_info,
-        )
+        # logger.warning(
+        #     "Database error caught. Attempting to transform: code=%s message=%s%s",
+        #     error_code,
+        #     error_message,
+        #     formatted_sql_info,
+        # )
 
         # Direct error code mapping
         if error_code in self.sql.ApplicationErrorCodes:

{velocity_python-0.0.131 → velocity_python-0.0.134}/src/velocity/db/exceptions.py

@@ -93,6 +93,12 @@ class DbTransactionError(DbException):
     pass
 
 
+class DbSchemaLockedError(DbApplicationError):
+    """Raised when attempting to modify schema while schema is locked."""
+
+    pass
+
+
 class DuplicateRowsFoundError(Exception):
     """Multiple rows found when expecting single result."""
 
@@ -125,5 +131,6 @@ __all__ = [
     "DbDataIntegrityError",
     "DbQueryError",
     "DbTransactionError",
+    "DbSchemaLockedError",
     "DuplicateRowsFoundError",
 ]

velocity_python-0.0.134/src/velocity/db/servers/base/__init__.py

@@ -0,0 +1,9 @@
+"""
+Base abstract classes for database server implementations.
+"""
+from .sql import BaseSQLDialect
+from .types import BaseTypes
+from .operators import BaseOperators
+from .initializer import BaseInitializer
+
+__all__ = ["BaseSQLDialect", "BaseTypes", "BaseOperators", "BaseInitializer"]

velocity_python-0.0.134/src/velocity/db/servers/base/initializer.py

@@ -0,0 +1,70 @@
+"""
+Abstract base class for database initialization.
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+from velocity.db.core import engine
+
+
+class BaseInitializer(ABC):
+    """
+    Abstract base class for database connection initialization.
+    
+    Each database implementation should provide a concrete implementation
+    of the initialize method to set up database connections properly.
+    """
+
+    @staticmethod
+    @abstractmethod
+    def initialize(config: Optional[Dict[str, Any]] = None, schema_locked: bool = False, **kwargs) -> engine.Engine:
+        """
+        Initialize a database engine with the appropriate driver and configuration.
+        
+        Args:
+            config: Configuration dictionary (can be None)
+            schema_locked: Boolean to lock schema modifications (default: False)
+            **kwargs: Additional configuration parameters
+            
+        Returns:
+            Configured Engine instance
+            
+        Raises:
+            ImportError: If required database driver is not available
+            ValueError: If configuration is invalid
+        """
+        pass
+
+    @staticmethod
+    def _merge_config(base_config: Dict[str, Any], config: Optional[Dict[str, Any]], **kwargs) -> Dict[str, Any]:
+        """
+        Helper method to merge configuration from multiple sources.
+        
+        Args:
+            base_config: Base configuration (e.g., from environment)
+            config: User-provided configuration
+            **kwargs: Additional keyword arguments
+            
+        Returns:
+            Merged configuration dictionary
+        """
+        final_config = base_config.copy()
+        if config:
+            final_config.update(config)
+        final_config.update(kwargs)
+        return final_config
+
+    @staticmethod
+    def _validate_required_config(config: Dict[str, Any], required_keys: list[str]) -> None:
+        """
+        Validate that required configuration keys are present.
+        
+        Args:
+            config: Configuration to validate
+            required_keys: List of required configuration keys
+            
+        Raises:
+            ValueError: If required keys are missing
+        """
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ValueError(f"Missing required configuration keys: {missing_keys}")

velocity_python-0.0.134/src/velocity/db/servers/base/operators.py

@@ -0,0 +1,98 @@
+"""
+Abstract base class for database operator mapping implementations.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict
+
+
+class BaseOperators(ABC):
+    """
+    Abstract base class that defines the interface for database operator mappings.
+    
+    Each database implementation should provide concrete implementations of operator
+    mappings to handle conversion between Velocity.DB operators and SQL operators.
+    """
+
+    @classmethod
+    @abstractmethod
+    def get_operators(cls) -> Dict[str, str]:
+        """
+        Returns a dictionary mapping Velocity.DB operators to SQL operators.
+        
+        This method should return a complete mapping of all operators supported
+        by this database implementation.
+        
+        Returns:
+            Dictionary mapping operator symbols to SQL operators
+            
+        Examples:
+            {
+                "=": "=",
+                "!=": "<>",
+                "<>": "<>", 
+                "%": "LIKE",
+                "!%": "NOT LIKE",
+                "%%": "ILIKE",  # PostgreSQL case-insensitive
+                "!%%": "NOT ILIKE",
+                "><": "BETWEEN",
+                "!><": "NOT BETWEEN",
+                # ... etc
+            }
+        """
+        pass
+
+    @classmethod
+    def get_base_operators(cls) -> Dict[str, str]:
+        """
+        Returns common operators supported by most databases.
+        Subclasses can use this as a starting point and override specific operators.
+        
+        Returns:
+            Dictionary of common SQL operators
+        """
+        return {
+            "=": "=",
+            "==": "=",
+            "!=": "<>",
+            "<>": "<>",
+            "!": "<>",
+            "<": "<",
+            ">": ">", 
+            "<=": "<=",
+            ">=": ">=",
+            "%": "LIKE",
+            "!%": "NOT LIKE",
+            "><": "BETWEEN",
+            "!><": "NOT BETWEEN",
+            ">!<": "NOT BETWEEN",
+        }
+
+    @classmethod
+    def supports_case_insensitive_like(cls) -> bool:
+        """
+        Returns True if this database supports case-insensitive LIKE operations.
+        
+        Returns:
+            True if database supports ILIKE or similar
+        """
+        return False
+
+    @classmethod
+    def supports_regex(cls) -> bool:
+        """
+        Returns True if this database supports regular expressions.
+        
+        Returns:
+            True if database supports regex operators
+        """
+        return False
+
+    @classmethod
+    def get_regex_operators(cls) -> Dict[str, str]:
+        """
+        Returns regex operators if supported by this database.
+        
+        Returns:
+            Dictionary of regex operators or empty dict if not supported
+        """
+        return {}