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

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

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

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

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

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

{velocity_python-0.0.157 → velocity_python-0.0.159}/src/velocity/aws/handlers/context.py

@@ -1,3 +1,4 @@
+import json
 import os
 import boto3
 import uuid
@@ -24,6 +25,8 @@ class Context:
         self.__aws_event = aws_event
         self.__aws_context = aws_context
         self.__log = log
+    self._job_record_cache = {}
+    self._job_cancelled_flag = False
 
     def postdata(self, keys=-1, default=None):
         if keys == -1:
@@ -87,9 +90,9 @@ class Context:
         if self.postdata("job_id"):
             # Sanitize data before storing in database
             sanitized_data = self._sanitize_job_data(data)
-            tx.table("aws_job_activity").update(
-                sanitized_data, {"job_id": self.postdata("job_id")}
-            )
+            job_id = self.postdata("job_id")
+            tx.table("aws_job_activity").update(sanitized_data, {"job_id": job_id})
+            self._job_record_cache.pop(job_id, None)
             tx.commit()
 
     def create_job(self, tx, job_data=None):
@@ -98,6 +101,9 @@ class Context:
             return
         sanitized_data = self._sanitize_job_data(job_data)
         tx.table("aws_job_activity").insert(sanitized_data)
+        job_id = sanitized_data.get("job_id")
+        if job_id:
+            self._job_record_cache.pop(job_id, None)
         tx.commit()
 
     def _sanitize_job_data(self, data):
@@ -183,6 +189,84 @@ class Context:
 
         return sanitized
 
+    def _get_job_record(self, tx, job_id=None, refresh=False):
+        job_id = job_id or self.postdata("job_id")
+        if not job_id:
+            return None
+
+        if refresh or job_id not in self._job_record_cache:
+            record = tx.table("aws_job_activity").find({"job_id": job_id})
+            if record is not None:
+                self._job_record_cache[job_id] = record
+            elif job_id in self._job_record_cache:
+                del self._job_record_cache[job_id]
+
+        return self._job_record_cache.get(job_id)
+
+    def is_job_cancel_requested(self, tx, force_refresh=False):
+        job = self._get_job_record(tx, refresh=force_refresh)
+        if not job:
+            return False
+
+        status = (job.get("status") or "").lower()
+        if status in {"cancelrequested", "cancelled"}:
+            return True
+
+        message_raw = job.get("message")
+        if not message_raw:
+            return False
+
+        if isinstance(message_raw, dict):
+            message = message_raw
+        else:
+            try:
+                message = json.loads(message_raw)
+            except (TypeError, ValueError, json.JSONDecodeError):
+                return False
+
+        return bool(message.get("cancel_requested") or message.get("cancelled"))
+
+    def mark_job_cancelled(self, tx, detail=None, requested_by=None):
+        job_id = self.postdata("job_id")
+        if not job_id:
+            return
+
+        job = self._get_job_record(tx, refresh=True) or {}
+        message_raw = job.get("message")
+        if isinstance(message_raw, dict):
+            message = dict(message_raw)
+        else:
+            try:
+                message = json.loads(message_raw) if message_raw else {}
+            except (TypeError, ValueError, json.JSONDecodeError):
+                message = {}
+
+        message.update(
+            {
+                "detail": detail or "Job cancelled",
+                "cancelled": True,
+            }
+        )
+
+        tx.table("aws_job_activity").update(
+            {
+                "status": "Cancelled",
+                "message": to_json(message),
+                "handler_complete_timestamp": datetime.now(),
+                "sys_modified": datetime.now(),
+                "sys_modified_by": requested_by
+                or self.session().get("email_address")
+                or "system",
+            },
+            {"job_id": job_id},
+        )
+        tx.commit()
+        self._job_record_cache.pop(job_id, None)
+        self._job_cancelled_flag = True
+
+    def was_job_cancelled(self):
+        return self._job_cancelled_flag
+
     def enqueue(self, action, payload={}, user=None, suppress_job_activity=False):
         """
         Enqueue jobs to SQS with independent job activity tracking.

{velocity_python-0.0.157 → velocity_python-0.0.159}/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.159}/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.159
 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.159}/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.159/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()