velocity-python 0.0.105__tar.gz → 0.0.108__tar.gz

{velocity_python-0.0.105/src/velocity_python.egg-info → velocity_python-0.0.108}/PKG-INFO

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

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

{velocity_python-0.0.105 → velocity_python-0.0.108}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.98"
+__version__ = version = "0.0.108"
 
 from . import aws
 from . import db

{velocity_python-0.0.105 → velocity_python-0.0.108}/src/velocity/db/core/result.py

@@ -56,10 +56,18 @@ class Result:
     def _fetch_first_row(self):
         """
         Pre-fetch the first row from the cursor to enable immediate boolean evaluation.
+        Only attempts to fetch for SELECT-like operations that return rows.
         """
         if self._first_row_fetched or not self._cursor:
             return
             
+        # Don't try to fetch from INSERT/UPDATE/DELETE operations
+        # These operations don't return rows, only rowcount
+        if self.__sql and self.__sql.strip().upper().startswith(('INSERT', 'UPDATE', 'DELETE', 'TRUNCATE')):
+            self._exhausted = True
+            self._first_row_fetched = True
+            return
+            
         try:
             raw_row = self._cursor.fetchone()
             if raw_row:

{velocity_python-0.0.105 → velocity_python-0.0.108}/src/velocity/db/core/table.py

@@ -431,7 +431,7 @@ class Table:
         if kwds.get("sql_only", False):
             return sql, vals
         result = self.tx.execute(sql, vals, cursor=self.cursor())
-        return result.cursor.rowcount
+        return result.cursor.rowcount if result.cursor else 0
 
     @reset_id_on_dup_key
     @create_missing
@@ -443,7 +443,7 @@ class Table:
         if kwds.get("sql_only", False):
             return sql, vals
         result = self.tx.execute(sql, vals, cursor=self.cursor())
-        return result.cursor.rowcount
+        return result.cursor.rowcount if result.cursor else 0
 
     @reset_id_on_dup_key
     @create_missing
@@ -462,7 +462,7 @@ class Table:
         if kwds.get("sql_only", False):
             return sql, vals
         result = self.tx.execute(sql, vals, cursor=self.cursor())
-        return result.cursor.rowcount
+        return result.cursor.rowcount if result.cursor else 0
 
     upsert = merge
     indate = merge
@@ -662,7 +662,7 @@ class Table:
         if kwds.get("sql_only", False):
             return sql, vals
         result = self.tx.execute(sql, vals)
-        return result.cursor.rowcount
+        return result.cursor.rowcount if result.cursor else 0
 
     def truncate(self, **kwds):
         """

{velocity_python-0.0.105 → velocity_python-0.0.108/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.105
+Version: 0.0.108
 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.105 → velocity_python-0.0.108}/src/velocity_python.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ src/velocity_python.egg-info/SOURCES.txt
 src/velocity_python.egg-info/dependency_links.txt
 src/velocity_python.egg-info/requires.txt
 src/velocity_python.egg-info/top_level.txt
+tests/test_cursor_rowcount_fix.py
 tests/test_db.py
 tests/test_db_utils.py
 tests/test_email_processing.py
@@ -71,6 +72,7 @@ tests/test_postgres.py
 tests/test_process_error_robustness.py
 tests/test_response.py
 tests/test_result_caching.py
+tests/test_result_sql_aware.py
 tests/test_row_get_missing_column.py
 tests/test_spreadsheet_functions.py
 tests/test_sql_builder.py

velocity_python-0.0.108/tests/test_cursor_rowcount_fix.py

@@ -0,0 +1,150 @@
+import unittest
+from unittest.mock import Mock, MagicMock
+from velocity.db.core.table import Table
+from velocity.db.core.result import Result
+
+
+class TestCursorRowCountFix(unittest.TestCase):
+    """
+    Test cases to verify that table methods handle None cursors gracefully
+    when accessing result.cursor.rowcount.
+    
+    This addresses the AttributeError: 'NoneType' object has no attribute 'rowcount'
+    issue that can occur when the cursor is None due to connection errors or 
+    other exceptional conditions.
+    """
+
+    def setUp(self):
+        """Set up mock objects for testing."""
+        self.mock_tx = Mock()
+        self.mock_sql = Mock()
+        self.table = Table(self.mock_tx, "test_table")
+        self.table.sql = self.mock_sql
+        
+    def test_insert_with_none_cursor(self):
+        """Test that insert() returns 0 when result.cursor is None."""
+        # Mock the SQL generation
+        self.mock_sql.insert.return_value = ("INSERT SQL", ["values"])
+        
+        # Create a mock result with cursor = None
+        mock_result = Mock(spec=Result)
+        mock_result.cursor = None
+        
+        # Mock the execute method to return our mock result
+        self.mock_tx.execute.return_value = mock_result
+        
+        # Mock the cursor method
+        mock_cursor = Mock()
+        self.table.cursor = Mock(return_value=mock_cursor)
+        
+        # Call insert and verify it returns 0 instead of raising AttributeError
+        result = self.table.insert({"test_field": "test_value"})
+        self.assertEqual(result, 0)
+        
+    def test_update_with_none_cursor(self):
+        """Test that update() returns 0 when result.cursor is None."""
+        # Mock the SQL generation
+        self.mock_sql.update.return_value = ("UPDATE SQL", ["values"])
+        
+        # Create a mock result with cursor = None
+        mock_result = Mock(spec=Result)
+        mock_result.cursor = None
+        
+        # Mock the execute method to return our mock result
+        self.mock_tx.execute.return_value = mock_result
+        
+        # Mock the cursor method
+        mock_cursor = Mock()
+        self.table.cursor = Mock(return_value=mock_cursor)
+        
+        # Call update and verify it returns 0 instead of raising AttributeError
+        result = self.table.update({"test_field": "new_value"}, where={"id": 1})
+        self.assertEqual(result, 0)
+        
+    def test_merge_with_none_cursor(self):
+        """Test that merge() returns 0 when result.cursor is None."""
+        # Mock the SQL generation
+        self.mock_sql.merge.return_value = ("MERGE SQL", ["values"])
+        
+        # Create a mock result with cursor = None
+        mock_result = Mock(spec=Result)
+        mock_result.cursor = None
+        
+        # Mock the execute method to return our mock result
+        self.mock_tx.execute.return_value = mock_result
+        
+        # Mock the cursor method
+        mock_cursor = Mock()
+        self.table.cursor = Mock(return_value=mock_cursor)
+        
+        # Call merge and verify it returns 0 instead of raising AttributeError
+        result = self.table.merge({"test_field": "test_value"})
+        self.assertEqual(result, 0)
+        
+    def test_delete_with_none_cursor(self):
+        """Test that delete() returns 0 when result.cursor is None."""
+        # Mock the SQL generation
+        self.mock_sql.delete.return_value = ("DELETE SQL", ["values"])
+        
+        # Create a mock result with cursor = None
+        mock_result = Mock(spec=Result)
+        mock_result.cursor = None
+        
+        # Mock the execute method to return our mock result
+        self.mock_tx.execute.return_value = mock_result
+        
+        # Call delete and verify it returns 0 instead of raising AttributeError
+        result = self.table.delete(where={"id": 1})
+        self.assertEqual(result, 0)
+        
+    def test_insert_with_valid_cursor(self):
+        """Test that insert() returns rowcount when result.cursor is valid."""
+        # Mock the SQL generation
+        self.mock_sql.insert.return_value = ("INSERT SQL", ["values"])
+        
+        # Create a mock cursor with rowcount
+        mock_cursor = Mock()
+        mock_cursor.rowcount = 1
+        
+        # Create a mock result with valid cursor
+        mock_result = Mock(spec=Result)
+        mock_result.cursor = mock_cursor
+        
+        # Mock the execute method to return our mock result
+        self.mock_tx.execute.return_value = mock_result
+        
+        # Mock the cursor method
+        table_cursor = Mock()
+        self.table.cursor = Mock(return_value=table_cursor)
+        
+        # Call insert and verify it returns the actual rowcount
+        result = self.table.insert({"test_field": "test_value"})
+        self.assertEqual(result, 1)
+        
+    def test_update_with_valid_cursor(self):
+        """Test that update() returns rowcount when result.cursor is valid."""
+        # Mock the SQL generation
+        self.mock_sql.update.return_value = ("UPDATE SQL", ["values"])
+        
+        # Create a mock cursor with rowcount
+        mock_cursor = Mock()
+        mock_cursor.rowcount = 2
+        
+        # Create a mock result with valid cursor
+        mock_result = Mock(spec=Result)
+        mock_result.cursor = mock_cursor
+        
+        # Mock the execute method to return our mock result
+        self.mock_tx.execute.return_value = mock_result
+        
+        # Mock the cursor method
+        table_cursor = Mock()
+        self.table.cursor = Mock(return_value=table_cursor)
+        
+        # Call update and verify it returns the actual rowcount
+        result = self.table.update({"test_field": "new_value"}, where={"id": 1})
+        self.assertEqual(result, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

velocity_python-0.0.108/tests/test_result_sql_aware.py

@@ -0,0 +1,115 @@
+import unittest
+from unittest.mock import Mock, MagicMock
+from velocity.db.core.result import Result
+
+
+class TestResultSQLAwareFetch(unittest.TestCase):
+    """
+    Test cases to verify that Result doesn't attempt to fetch from 
+    INSERT/UPDATE/DELETE operations, preventing cursor errors.
+    """
+
+    def test_insert_sql_no_fetch_attempt(self):
+        """Test that INSERT SQL doesn't attempt to fetch rows."""
+        mock_cursor = Mock()
+        
+        # Create Result with INSERT SQL
+        result = Result(cursor=mock_cursor, sql="INSERT INTO test (name) VALUES ('test')")
+        
+        # Verify fetchone was never called on INSERT
+        mock_cursor.fetchone.assert_not_called()
+        
+        # Verify result is marked as exhausted (no rows expected)
+        self.assertTrue(result._exhausted)
+        self.assertTrue(result._first_row_fetched)
+        
+        # Verify cursor is still valid (not set to None)
+        self.assertIsNotNone(result.cursor)
+        
+    def test_update_sql_no_fetch_attempt(self):
+        """Test that UPDATE SQL doesn't attempt to fetch rows."""
+        mock_cursor = Mock()
+        
+        # Create Result with UPDATE SQL
+        result = Result(cursor=mock_cursor, sql="UPDATE test SET name='new' WHERE id=1")
+        
+        # Verify fetchone was never called on UPDATE
+        mock_cursor.fetchone.assert_not_called()
+        
+        # Verify result is marked as exhausted (no rows expected)
+        self.assertTrue(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+        
+    def test_delete_sql_no_fetch_attempt(self):
+        """Test that DELETE SQL doesn't attempt to fetch rows."""
+        mock_cursor = Mock()
+        
+        # Create Result with DELETE SQL
+        result = Result(cursor=mock_cursor, sql="DELETE FROM test WHERE id=1")
+        
+        # Verify fetchone was never called on DELETE
+        mock_cursor.fetchone.assert_not_called()
+        
+        # Verify result is marked as exhausted (no rows expected)
+        self.assertTrue(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+        
+    def test_select_sql_does_fetch(self):
+        """Test that SELECT SQL still attempts to fetch rows."""
+        mock_cursor = Mock()
+        mock_cursor.fetchone.return_value = None  # No rows returned
+        
+        # Create Result with SELECT SQL
+        result = Result(cursor=mock_cursor, sql="SELECT * FROM test")
+        
+        # Verify fetchone WAS called on SELECT
+        mock_cursor.fetchone.assert_called_once()
+        
+        # Verify result is marked as exhausted (no rows returned)
+        self.assertTrue(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+        
+    def test_select_sql_with_rows(self):
+        """Test that SELECT SQL with rows works correctly."""
+        mock_cursor = Mock()
+        mock_cursor.fetchone.return_value = ('test_value',)
+        mock_cursor.description = [('column1',)]
+        
+        # Create Result with SELECT SQL
+        result = Result(cursor=mock_cursor, sql="SELECT column1 FROM test")
+        
+        # Verify fetchone WAS called on SELECT
+        mock_cursor.fetchone.assert_called_once()
+        
+        # Verify result has cached first row and is not exhausted
+        self.assertIsNotNone(result._cached_first_row)
+        self.assertFalse(result._exhausted)
+        self.assertIsNotNone(result.cursor)
+        
+    def test_case_insensitive_sql_detection(self):
+        """Test that SQL detection works with various cases."""
+        test_cases = [
+            "insert into test values (1)",      # lowercase
+            "INSERT INTO test VALUES (1)",      # uppercase  
+            "   INSERT INTO test VALUES (1)",   # leading whitespace
+            "Insert Into test Values (1)",      # mixed case
+            "UPDATE test SET name='x'",         # update
+            "delete from test",                 # delete
+            "TRUNCATE TABLE test"               # truncate
+        ]
+        
+        for sql in test_cases:
+            with self.subTest(sql=sql):
+                mock_cursor = Mock()
+                result = Result(cursor=mock_cursor, sql=sql)
+                
+                # Verify fetchone was never called
+                mock_cursor.fetchone.assert_not_called()
+                
+                # Verify result is marked as exhausted
+                self.assertTrue(result._exhausted)
+                self.assertIsNotNone(result.cursor)
+
+
+if __name__ == "__main__":
+    unittest.main()