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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.132
+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.132 → velocity_python-0.0.134}/pyproject.toml

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

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

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.132"
+__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.132 → 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.132 → 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.132 → 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.132 → velocity_python-0.0.134}/src/velocity/db/servers/base/initializer.py

@@ -16,12 +16,13 @@ class BaseInitializer(ABC):
 
     @staticmethod
     @abstractmethod
-    def initialize(config: Optional[Dict[str, Any]] = None, **kwargs) -> engine.Engine:
+    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:

{velocity_python-0.0.132 → velocity_python-0.0.134}/src/velocity/db/servers/mysql/__init__.py

@@ -8,12 +8,13 @@ class MySQLInitializer(BaseInitializer):
     """MySQL database initializer."""
 
     @staticmethod
-    def initialize(config=None, **kwargs):
+    def initialize(config=None, schema_locked=False, **kwargs):
         """
         Initialize MySQL engine with mysql.connector driver.
         
         Args:
             config: Configuration dictionary
+            schema_locked: Boolean to lock schema modifications
             **kwargs: Additional configuration parameters
             
         Returns:
@@ -55,10 +56,18 @@ class MySQLInitializer(BaseInitializer):
         required_keys = ["database", "host", "user"]
         MySQLInitializer._validate_required_config(final_config, required_keys)
         
-        return engine.Engine(mysql.connector, final_config, SQL)
+        # Check for environment variable override for schema locking
+        if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+            schema_locked = True
+        
+        return engine.Engine(mysql.connector, final_config, SQL, schema_locked=schema_locked)
 
 
 # Maintain backward compatibility
-def initialize(config=None, **kwargs):
+def initialize(config=None, schema_locked=False, **kwargs):
     """Backward compatible initialization function."""
-    return MySQLInitializer.initialize(config, **kwargs)
+    # Check for environment variable override for schema locking
+    if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+        schema_locked = True
+        
+    return MySQLInitializer.initialize(config, schema_locked, **kwargs)

{velocity_python-0.0.132 → velocity_python-0.0.134}/src/velocity/db/servers/postgres/__init__.py

@@ -9,12 +9,13 @@ class PostgreSQLInitializer(BaseInitializer):
     """PostgreSQL database initializer."""
 
     @staticmethod
-    def initialize(config=None, **kwargs):
+    def initialize(config=None, schema_locked=False, **kwargs):
         """
         Initialize PostgreSQL engine with psycopg2 driver.
         
         Args:
             config: Configuration dictionary
+            schema_locked: Boolean to lock schema modifications
             **kwargs: Additional configuration parameters
             
         Returns:
@@ -39,11 +40,15 @@ class PostgreSQLInitializer(BaseInitializer):
         required_keys = ["database", "host", "user", "password"]
         PostgreSQLInitializer._validate_required_config(final_config, required_keys)
         
-        return engine.Engine(psycopg2, final_config, SQL)
+        # Check for environment variable override for schema locking
+        if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+            schema_locked = True
+        
+        return engine.Engine(psycopg2, final_config, SQL, schema_locked=schema_locked)
 
 
 # Maintain backward compatibility
-def initialize(config=None, **kwargs):
+def initialize(config=None, schema_locked=False, **kwargs):
     """Backward compatible initialization function - matches original behavior exactly."""
     konfig = {
         "database": os.environ["DBDatabase"],
@@ -54,4 +59,9 @@ def initialize(config=None, **kwargs):
     }
     konfig.update(config or {})
     konfig.update(kwargs)
-    return engine.Engine(psycopg2, konfig, SQL)
+    
+    # Check for environment variable override for schema locking
+    if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+        schema_locked = True
+        
+    return engine.Engine(psycopg2, konfig, SQL, schema_locked=schema_locked)

{velocity_python-0.0.132 → velocity_python-0.0.134}/src/velocity/db/servers/sqlite/__init__.py

@@ -9,12 +9,13 @@ class SQLiteInitializer(BaseInitializer):
     """SQLite database initializer."""
 
     @staticmethod
-    def initialize(config=None, **kwargs):
+    def initialize(config=None, schema_locked=False, **kwargs):
         """
         Initialize SQLite engine with sqlite3 driver.
         
         Args:
             config: Configuration dictionary
+            schema_locked: Boolean to lock schema modifications
             **kwargs: Additional configuration parameters
             
         Returns:
@@ -43,10 +44,18 @@ class SQLiteInitializer(BaseInitializer):
         required_keys = ["database"]
         SQLiteInitializer._validate_required_config(final_config, required_keys)
         
-        return engine.Engine(sqlite3, final_config, SQL)
+        # Check for environment variable override for schema locking
+        if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+            schema_locked = True
+        
+        return engine.Engine(sqlite3, final_config, SQL, schema_locked=schema_locked)
 
 
 # Maintain backward compatibility
-def initialize(config=None, **kwargs):
+def initialize(config=None, schema_locked=False, **kwargs):
     """Backward compatible initialization function."""
-    return SQLiteInitializer.initialize(config, **kwargs)
+    # Check for environment variable override for schema locking
+    if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+        schema_locked = True
+        
+    return SQLiteInitializer.initialize(config, schema_locked, **kwargs)

{velocity_python-0.0.132 → velocity_python-0.0.134}/src/velocity/db/servers/sqlserver/__init__.py

@@ -8,12 +8,13 @@ class SQLServerInitializer(BaseInitializer):
     """SQL Server database initializer."""
 
     @staticmethod
-    def initialize(config=None, **kwargs):
+    def initialize(config=None, schema_locked=False, **kwargs):
         """
         Initialize SQL Server engine with pytds driver.
         
         Args:
             config: Configuration dictionary
+            schema_locked: Boolean to lock schema modifications
             **kwargs: Additional configuration parameters
             
         Returns:
@@ -55,10 +56,18 @@ class SQLServerInitializer(BaseInitializer):
         required_keys = ["database", "server", "user"]
         SQLServerInitializer._validate_required_config(final_config, required_keys)
         
-        return engine.Engine(pytds, final_config, SQL)
+        # Check for environment variable override for schema locking
+        if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+            schema_locked = True
+        
+        return engine.Engine(pytds, final_config, SQL, schema_locked=schema_locked)
 
 
 # Maintain backward compatibility
-def initialize(config=None, **kwargs):
+def initialize(config=None, schema_locked=False, **kwargs):
     """Backward compatible initialization function."""
-    return SQLServerInitializer.initialize(config, **kwargs)
+    # Check for environment variable override for schema locking
+    if os.environ.get("VELOCITY_SCHEMA_LOCKED", "").lower() in ('true', '1', 'yes'):
+        schema_locked = True
+        
+    return SQLServerInitializer.initialize(config, schema_locked, **kwargs)

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

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

velocity_python-0.0.134/src/velocity/db/tests/postgres/__init__.py

@@ -0,0 +1 @@
+# PostgreSQL tests

velocity_python-0.0.134/src/velocity/db/tests/postgres/common.py

@@ -0,0 +1,49 @@
+import unittest
+from velocity.db.servers import postgres
+import env
+env.set()
+
+test_db = "test_db_postgres"
+engine = postgres.initialize(database=test_db)
+
+
+class CommonPostgresTest(unittest.TestCase):
+    """
+    Base test class for PostgreSQL tests following the common pattern.
+    All PostgreSQL tests should inherit from this class.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up the test database and create any common tables."""
+        @engine.transaction
+        def setup(tx):
+            tx.switch_to_database("postgres")
+            tx.execute(f"drop database if exists {test_db}", single=True)
+            
+            # Create the test database
+            db = tx.database(test_db)
+            if not db.exists():
+                db.create()
+            db.switch()
+
+            # Call subclass-specific table creation with commit
+            if hasattr(cls, 'create_test_tables'):
+                cls.create_test_tables(tx)
+        
+        setup()
+
+    @classmethod
+    def tearDownClass(cls):
+        """Clean up the test database."""
+        @engine.transaction
+        def cleanup(tx):
+            tx.switch_to_database("postgres")
+            tx.execute(f"drop database if exists {test_db}", single=True)
+        
+        cleanup()
+
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Override this method in subclasses to create test-specific tables."""
+        pass

velocity_python-0.0.134/src/velocity/db/tests/postgres/test_column.py

@@ -0,0 +1,29 @@
+import unittest
+from velocity.db.core.column import Column
+from velocity.db.exceptions import DbColumnMissingError
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestColumn(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Create test tables for column tests."""
+        tx.table("mock_table").create(
+            columns={
+                "column1": int,
+                "column2": str,
+                "column3": str,
+            }
+        )
+    
+    def test_init(self, tx):
+        column = tx.table("mock_table").column("column1")
+        self.assertIsInstance(column, Column)
+        self.assertEqual(column.name, "column1")
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.0.134/src/velocity/db/tests/postgres/test_connections.py

@@ -0,0 +1,25 @@
+import unittest
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestConnections(CommonPostgresTest):
+    
+    @classmethod
+    def create_test_tables(cls, tx):
+        """Create test tables for connection tests."""
+        tx.table("mock_table").create(
+            columns={
+                "column1": int,
+                "column2": str,
+                "column3": str,
+            }
+        )
+    def test_init(self, tx):
+        # Test the initialization of the Database object
+        assert tx.table("mock_table").exists()
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.0.134/src/velocity/db/tests/postgres/test_database.py

@@ -0,0 +1,21 @@
+import unittest
+from velocity.db.core.database import Database
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+@engine.transaction
+class TestDatabase(CommonPostgresTest):
+
+    @classmethod
+    def create_test_tables(cls, tx):
+        """No special tables needed for database tests."""
+        pass
+
+    def test_init(self, tx):
+        # Test the initialization of the Database object
+        tx.database
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.0.134/src/velocity/db/tests/postgres/test_engine.py

@@ -0,0 +1,205 @@
+import os
+import datetime
+import unittest
+from velocity.db.core.engine import Engine
+from velocity.db.core.transaction import Transaction
+from .common import CommonPostgresTest, engine, test_db
+
+
+@engine.transaction
+class TestEngine(CommonPostgresTest):
+    @classmethod
+    def create_test_tables(cls, tx):
+        """No special tables needed for engine tests."""
+        pass
+
+    def test_engine_init(self, tx):
+        import psycopg2
+        from velocity.db.servers.postgres import SQL
+        
+        # Test the engine instance from common test
+        assert engine.sql == SQL
+        assert engine.driver == psycopg2
+
+    def test_engine_attributes(self, tx):
+        import psycopg2
+        from velocity.db.servers.postgres import SQL
+        
+        # Test private attributes
+        assert engine._Engine__sql == SQL
+        assert engine._Engine__driver == psycopg2
+
+    def test_connect(self, tx):
+        import psycopg2
+        
+        assert engine.connect() != None
+        conn = engine.connect()
+        self.assertIsInstance(conn, psycopg2.extensions.connection)
+
+    def test_other_stuff(self, tx):
+        assert engine.version[:10] == "PostgreSQL"
+
+        timestamp = engine.timestamp
+        self.assertIsInstance(timestamp, datetime.datetime)
+        assert engine.user == os.environ["DBUser"]
+        assert test_db in engine.databases
+        assert "public" in engine.schemas
+        assert "information_schema" in engine.schemas
+        assert "public" == engine.current_schema
+        assert engine.current_database == test_db
+        assert [] == engine.views
+        assert [] == engine.tables
+
+    def test_process_error(self, tx):
+        local_engine = Engine(None, None, None)  # Replace None with appropriate arguments
+        with self.assertRaises(
+            Exception
+        ):  # Replace Exception with the specific exception raised by process_error
+            local_engine.process_error(sql_stmt=None, sql_params=None)
+        # Add additional assertions as needed
+
+    def test_transaction_injection_1(self, tx):
+        @engine.transaction
+        def function():
+            pass
+
+        function()
+
+        @engine.transaction
+        def function(_tx):
+            pass
+
+        with self.assertRaises(NameError):
+            function()
+
+        @engine.transaction
+        def function(tx):
+            pass
+
+        with self.assertRaises(TypeError):
+            function(tx=3)
+        with self.assertRaises(TypeError):
+            function(tx=None)
+
+    def test_transaction_injection_function(self, tx):
+        with engine.transaction() as original:
+
+            @engine.transaction
+            def function(tx):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function()
+
+            @engine.transaction
+            def function(tx):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(original)
+
+            @engine.transaction
+            def function(tx=None):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function()
+
+            @engine.transaction
+            def function(tx=None):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(original)
+
+            @engine.transaction
+            def function(tx=None):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(tx=original)
+
+            @engine.transaction
+            def function(tx, a, b):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function(1, 2)
+
+            @engine.transaction
+            def function(tx, a, b):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(original, 1, 2)
+
+            @engine.transaction
+            def function(tx, a, b):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(tx=original, a=1, b=2)
+
+            @engine.transaction
+            def function(tx, src, b):
+                assert tx != None
+                assert tx != src
+                self.assertIsInstance(tx, Transaction)
+
+            function(src=original, b=2)
+
+            @engine.transaction
+            def function(a, tx, b):
+                assert tx != None
+                assert tx != original
+                self.assertIsInstance(tx, Transaction)
+
+            function(1, 2)
+
+            @engine.transaction
+            def function(a, tx, b):
+                assert tx != None
+                assert tx == original
+                self.assertIsInstance(tx, Transaction)
+
+            function(1, original, 2)
+
+    def test_transaction_injection_class(self, tx):
+        test_class = self
+        with engine.transaction() as original:
+
+            @engine.transaction
+            class TestClass:
+                @engine.transaction
+                def __init__(self, tx):
+                    assert tx != None
+                    assert tx != original
+                    test_class.assertIsInstance(tx, Transaction)
+
+                def first_method(self, tx):
+                    assert tx != None
+                    assert tx != original
+                    test_class.assertIsInstance(tx, Transaction)
+
+                def second_method(self, tx):
+                    assert tx != None
+                    assert tx == original
+                    test_class.assertIsInstance(tx, Transaction)
+
+            tc = TestClass()
+
+            tc.first_method()
+            tc.second_method(original)
+            self.assertRaises(AssertionError, tc.second_method)
+
+
+if __name__ == "__main__":
+    unittest.main()