velocity-python 0.1.9__tar.gz → 0.1.11__tar.gz

{velocity_python-0.1.9/src/velocity_python.egg-info → velocity_python-0.1.11}/PKG-INFO

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

{velocity_python-0.1.9 → velocity_python-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.9"
+version = "0.1.11"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]
@@ -29,6 +29,9 @@ dependencies = [
   "sqlparse>=0.5.0"
 ]
 
+[project.scripts]
+velocity = "velocity.db.migrations:cli"
+
 [project.urls]
 Homepage = "https://codeclubs.org/projects/velocity"
 Documentation = "https://codeclubs.org/projects/velocity"

{velocity_python-0.1.9 → velocity_python-0.1.11}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.9"
+__version__ = version = "0.1.11"
 
 import importlib as _importlib
 

{velocity_python-0.1.9 → velocity_python-0.1.11}/src/velocity/db/core/row.py

@@ -1,6 +1,5 @@
 import pprint
 import time as _time
-import warnings
 from collections.abc import MutableMapping
 from velocity.db.exceptions import DbColumnMissingError
 
@@ -9,7 +8,7 @@ from velocity.db.exceptions import DbColumnMissingError
 # intercepted by __getattr__ / __setattr__.
 _INTERNAL_ATTRS = frozenset({
     "table", "pk", "_cache", "_column_set", "_batching", "_pending",
-    "_cache_ttl", "_cache_time", "_no_cache",
+    "_cache_ttl", "_cache_time", "_no_cache", "_dirty_tracking", "_dirty",
 })
 
 
@@ -25,7 +24,7 @@ class Row(MutableMapping):
     write-through (immediate UPDATE) and also update the local cache.
     """
 
-    def __init__(self, table, key, lock=None, cache_ttl=None, no_cache=False):
+    def __init__(self, table, key, lock=None, cache_ttl=None, no_cache=False, dirty_tracking=False):
         if isinstance(table, str):
             raise Exception("Table parameter must be a `table` instance.")
         object.__setattr__(self, "table", table)
@@ -48,6 +47,8 @@ class Row(MutableMapping):
         object.__setattr__(self, "_cache_ttl", cache_ttl)
         object.__setattr__(self, "_cache_time", None)
         object.__setattr__(self, "_no_cache", no_cache)
+        object.__setattr__(self, "_dirty_tracking", dirty_tracking)
+        object.__setattr__(self, "_dirty", {})
         if lock:
             self.lock()
 
@@ -78,6 +79,8 @@ class Row(MutableMapping):
         object.__setattr__(row, "_cache_ttl", None)
         object.__setattr__(row, "_cache_time", _time.monotonic())
         object.__setattr__(row, "_no_cache", False)
+        object.__setattr__(row, "_dirty_tracking", False)
+        object.__setattr__(row, "_dirty", {})
         return row
 
     # ------------------------------------------------------------------
@@ -144,6 +147,13 @@ class Row(MutableMapping):
                 self._cache[key] = val
                 object.__setattr__(self, "_column_set", None)
             return
+        if self._dirty_tracking:
+            self._dirty[key] = val
+            # Update local cache optimistically so reads see the dirty value
+            if self._cache is not None:
+                self._cache[key] = val
+                object.__setattr__(self, "_column_set", None)
+            return
         self.table.update_or_insert({key: val}, pk=self.pk)
         # Invalidate cache so trigger-computed columns are re-fetched
         object.__setattr__(self, "_cache", None)
@@ -394,6 +404,55 @@ class Row(MutableMapping):
         """
         return _BatchContext(self)
 
+    def save(self):
+        """Flush accumulated dirty-tracking changes to the database.
+
+        When ``dirty_tracking=True``, assignments to the row accumulate
+        in memory instead of writing through immediately.  Call
+        ``.save()`` to flush them all in a single UPDATE::
+
+            row = Row(table, 1, dirty_tracking=True)
+            row["name"] = "John"
+            row["email"] = "john@example.com"
+            row.save()  # Single UPDATE with both columns
+
+        Returns ``self`` for chaining.
+
+        Raises:
+            RuntimeError: If dirty tracking is not enabled on this row.
+        """
+        if not self._dirty_tracking:
+            raise RuntimeError(
+                "save() requires dirty_tracking=True. "
+                "Use Row(table, key, dirty_tracking=True) or row.update({...})."
+            )
+        dirty = self._dirty
+        object.__setattr__(self, "_dirty", {})
+        if dirty:
+            self.table.update_or_insert(dirty, pk=self.pk)
+            # Invalidate cache so trigger-computed columns are re-fetched
+            object.__setattr__(self, "_cache", None)
+            object.__setattr__(self, "_column_set", None)
+        return self
+
+    @property
+    def is_dirty(self):
+        """Return True if there are unsaved dirty-tracking changes."""
+        return bool(self._dirty)
+
+    def discard(self):
+        """Discard accumulated dirty-tracking changes without writing to DB.
+
+        Also invalidates the cache so the next read re-fetches from the
+        database, undoing any optimistic cache updates.
+
+        Returns ``self`` for chaining.
+        """
+        object.__setattr__(self, "_dirty", {})
+        object.__setattr__(self, "_cache", None)
+        object.__setattr__(self, "_column_set", None)
+        return self
+
     def touch(self):
         """
         Update sys_modified to current timestamp.
@@ -473,5 +532,7 @@ class _BatchContext:
 
         if pending:
             row.table.update_or_insert(pending, pk=row.pk)
-            # Cache was already updated optimistically in __setitem__
+            # Invalidate cache so trigger-computed columns are re-fetched
+            object.__setattr__(row, "_cache", None)
+            object.__setattr__(row, "_column_set", None)
         return False