velocity-python 0.0.157__tar.gz → 0.0.158__tar.gz

{velocity_python-0.0.157 → velocity_python-0.0.158}/PKG-INFO

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

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

{velocity_python-0.0.157 → velocity_python-0.0.158}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.157"
+__version__ = version = "0.0.158"
 
 from . import aws
 from . import db

{velocity_python-0.0.157 → velocity_python-0.0.158}/src/velocity/db/core/decorators.py

@@ -4,10 +4,27 @@ from functools import wraps
 from velocity.db import exceptions
 
 
+_PRIMARY_KEY_PATTERNS = (
+    "primary key",
+    "key 'primary'",
+    'key "primary"',
+)
+
+
+def _is_primary_key_duplicate(error):
+    """Return True when the duplicate-key error is targeting the primary key."""
+
+    message = str(error or "")
+    lowered = message.lower()
+
+    if "sys_id" in lowered:
+        return True
+
+    return any(pattern in lowered for pattern in _PRIMARY_KEY_PATTERNS)
+
+
 def retry_on_dup_key(func):
-    """
-    Retries a function call if it raises DbDuplicateKeyError, up to max_retries.
-    """
+    """Retry when insert/update fails because the primary key already exists."""
 
     @wraps(func)
     def retry_decorator(self, *args, **kwds):
@@ -19,10 +36,12 @@ def retry_on_dup_key(func):
                 result = func(self, *args, **kwds)
                 self.tx.release_savepoint(sp, cursor=self.cursor())
                 return result
-            except exceptions.DbDuplicateKeyError:
+            except exceptions.DbDuplicateKeyError as error:
                 self.tx.rollback_savepoint(sp, cursor=self.cursor())
                 if "sys_id" in kwds.get("data", {}):
                     raise
+                if not _is_primary_key_duplicate(error):
+                    raise
                 retries += 1
                 if retries >= max_retries:
                     raise
@@ -34,9 +53,7 @@ def retry_on_dup_key(func):
 
 
 def reset_id_on_dup_key(func):
-    """
-    Wraps an INSERT/UPSERT to reset the sys_id sequence on duplicate key collisions.
-    """
+    """Retry sys_id sequence bump only when the primary key collides."""
 
     @wraps(func)
     def reset_decorator(self, *args, retries=0, **kwds):
@@ -45,10 +62,12 @@ def reset_id_on_dup_key(func):
             result = func(self, *args, **kwds)
             self.tx.release_savepoint(sp, cursor=self.cursor())
             return result
-        except exceptions.DbDuplicateKeyError:
+        except exceptions.DbDuplicateKeyError as error:
             self.tx.rollback_savepoint(sp, cursor=self.cursor())
             if "sys_id" in kwds.get("data", {}):
                 raise
+            if not _is_primary_key_duplicate(error):
+                raise
             if retries < 3:
                 backoff_time = (2**retries) * 0.01 + random.uniform(0, 0.02)
                 time.sleep(backoff_time)

{velocity_python-0.0.157 → velocity_python-0.0.158}/src/velocity_python.egg-info/PKG-INFO

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

@@ -130,5 +130,6 @@ 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_decorators.py
 tests/test_sys_modified_count_postgres_demo.py
 tests/test_where_clause_validation.py

velocity_python-0.0.158/tests/test_decorators.py

@@ -0,0 +1,157 @@
+import unittest
+from unittest.mock import patch
+
+from velocity.db import exceptions
+from velocity.db.core.decorators import reset_id_on_dup_key, retry_on_dup_key
+
+
+class DummyTx:
+    def __init__(self):
+        self.savepoints = []
+
+    def create_savepoint(self, cursor=None):
+        savepoint = object()
+        self.savepoints.append(("create", savepoint))
+        return savepoint
+
+    def release_savepoint(self, savepoint, cursor=None):
+        self.savepoints.append(("release", savepoint))
+
+    def rollback_savepoint(self, savepoint, cursor=None):
+        self.savepoints.append(("rollback", savepoint))
+
+
+class DummyTable:
+    def __init__(self):
+        self.tx = DummyTx()
+        self._cursor = object()
+        self.sequence_updates = []
+        self.last_max_column = None
+        self.max_value = 7
+
+    def cursor(self):
+        return self._cursor
+
+    def set_sequence(self, value):
+        self.sequence_updates.append(value)
+
+    def max(self, column):
+        self.last_max_column = column
+        return self.max_value
+
+
+class ResetIdOnDupKeyTests(unittest.TestCase):
+    def setUp(self):
+        self.table = DummyTable()
+
+    def test_retries_when_sys_id_duplicate(self):
+        attempts = {"count": 0}
+
+        @reset_id_on_dup_key
+        def insert(self, data):
+            attempts["count"] += 1
+            if attempts["count"] == 1:
+                raise exceptions.DbDuplicateKeyError(
+                    'duplicate key value violates unique constraint "table_pkey"\nDETAIL: Key (sys_id)=(1) already exists.'
+                )
+            return "ok"
+
+        with patch("velocity.db.core.decorators.time.sleep", return_value=None):
+            result = insert(self.table, data={})
+
+        self.assertEqual(result, "ok")
+        self.assertEqual(attempts["count"], 2)
+        self.assertEqual(self.table.sequence_updates, [self.table.max_value + 1])
+        self.assertEqual(self.table.last_max_column, "sys_id")
+
+    def test_retries_when_primary_constraint_name_only(self):
+        attempts = {"count": 0}
+
+        @reset_id_on_dup_key
+        def insert(self, data):
+            attempts["count"] += 1
+            if attempts["count"] == 1:
+                raise exceptions.DbDuplicateKeyError(
+                    "Duplicate entry '1' for key 'PRIMARY'"
+                )
+            return "ok"
+
+        with patch("velocity.db.core.decorators.time.sleep", return_value=None):
+            result = insert(self.table, data={})
+
+        self.assertEqual(result, "ok")
+        self.assertEqual(attempts["count"], 2)
+        self.assertEqual(self.table.sequence_updates, [self.table.max_value + 1])
+
+    def test_raises_when_non_primary_duplicate(self):
+        attempts = {"count": 0}
+
+        @reset_id_on_dup_key
+        def insert(self, data):
+            attempts["count"] += 1
+            raise exceptions.DbDuplicateKeyError(
+                'duplicate key value violates unique constraint "table_email_key"'
+            )
+
+        with patch("velocity.db.core.decorators.time.sleep", return_value=None):
+            with self.assertRaises(exceptions.DbDuplicateKeyError):
+                insert(self.table, data={})
+
+        self.assertEqual(attempts["count"], 1)
+        self.assertEqual(self.table.sequence_updates, [])
+
+
+class RetryOnDupKeyTests(unittest.TestCase):
+    def setUp(self):
+        self.table = DummyTable()
+
+    def test_retries_for_primary_key_duplicate(self):
+        attempts = {"count": 0}
+
+        @retry_on_dup_key
+        def operation(self):
+            attempts["count"] += 1
+            if attempts["count"] == 1:
+                raise exceptions.DbDuplicateKeyError(
+                    "Key (sys_id)=(1) already exists."
+                )
+            return "done"
+
+        with patch("velocity.db.core.decorators.time.sleep", return_value=None):
+            result = operation(self.table)
+
+        self.assertEqual(result, "done")
+        self.assertEqual(attempts["count"], 2)
+
+    def test_retries_for_primary_keyword_only(self):
+        attempts = {"count": 0}
+
+        @retry_on_dup_key
+        def operation(self):
+            attempts["count"] += 1
+            if attempts["count"] == 1:
+                raise exceptions.DbDuplicateKeyError(
+                    "Violation of PRIMARY KEY constraint"
+                )
+            return "done"
+
+        with patch("velocity.db.core.decorators.time.sleep", return_value=None):
+            result = operation(self.table)
+
+        self.assertEqual(result, "done")
+        self.assertEqual(attempts["count"], 2)
+
+    def test_raises_for_non_primary_duplicate(self):
+        @retry_on_dup_key
+        def operation(self):
+            raise exceptions.DbDuplicateKeyError(
+                'duplicate key value violates unique constraint "table_email_key"'
+            )
+
+        with patch("velocity.db.core.decorators.time.sleep", return_value=None):
+            with self.assertRaises(exceptions.DbDuplicateKeyError):
+                operation(self.table)
+
+
+if __name__ == "__main__":
+    unittest.main()