velocity-python 0.0.152__tar.gz → 0.0.154__tar.gz

{velocity_python-0.0.152 → velocity_python-0.0.154}/PKG-INFO

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

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

{velocity_python-0.0.152 → velocity_python-0.0.154}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.152"
+__version__ = version = "0.0.154"
 
 from . import aws
 from . import db

{velocity_python-0.0.152 → velocity_python-0.0.154}/src/velocity/db/core/table.py

@@ -321,51 +321,88 @@ class Table:
         sys_id = self.tx.execute(sql, vals).scalar()
         return self.row(sys_id, lock=lock)
 
+    def _normalize_lookup_where(self, where):
+        if where is None:
+            raise Exception("None is not allowed as a primary key.")
+        if isinstance(where, Row):
+            return dict(where.pk)
+        if isinstance(where, int):
+            return {"sys_id": where}
+        if not isinstance(where, Mapping):
+            raise TypeError(
+                "Lookup criteria must be an int, Row, or mapping of column -> value."
+            )
+        return dict(where)
+
+    def _select_sys_ids(
+        self,
+        where,
+        *,
+        lock=None,
+        orderby=None,
+        skip_locked=None,
+        limit=2,
+    ):
+        select_kwargs = {
+            "where": where,
+            "lock": lock,
+            "orderby": orderby,
+            "skip_locked": skip_locked,
+        }
+        if limit is not None:
+            select_kwargs["qty"] = limit
+        return self.select("sys_id", **select_kwargs).all()
+
+    def _clean_where_for_insert(self, where):
+        clean = {}
+        for key, val in where.items():
+            if not isinstance(key, str):
+                continue
+            if set("<>!=%").intersection(key):
+                continue
+            clean.setdefault(key, val)
+        return clean
+
     def get(self, where, lock=None, use_where=False):
         """
         Gets or creates a row matching `where`. If multiple rows match, raises DuplicateRowsFoundError.
         If none match, a new row is created with the non-operator aspects of `where`.
         """
-        if where is None:
-            raise Exception("None is not allowed as a primary key.")
-        if isinstance(where, int):
-            where = {"sys_id": where}
-        result = self.select("sys_id", where=where, lock=lock).all()
+        lookup = self._normalize_lookup_where(where)
+        result = self._select_sys_ids(lookup, lock=lock, limit=2)
         if len(result) > 1:
-            sql = self.select("sys_id", sql_only=True, where=where, lock=lock)
+            sql = self.select("sys_id", sql_only=True, where=lookup, lock=lock)
             raise exceptions.DuplicateRowsFoundError(
                 f"More than one entry found. {sql}"
             )
         if not result:
-            new_data = where.copy()
-            for k in list(new_data.keys()):
-                if set("<>!=%").intersection(k):
-                    new_data.pop(k)
+            new_data = self._clean_where_for_insert(lookup)
             return self.new(new_data, lock=lock)
         if use_where:
-            return Row(self, where, lock=lock)
+            return Row(self, lookup, lock=lock)
         return Row(self, result[0]["sys_id"], lock=lock)
 
     @return_default(None)
-    def find(self, where, lock=None, use_where=False):
+    def find(self, where, lock=None, use_where=False, raise_if_missing=False):
         """
-        Finds a single row matching `where`, or returns None if none found.
-        Raises DuplicateRowsFoundError if multiple rows match.
+        Finds a single row matching `where`, or returns None if none found unless
+        ``raise_if_missing`` is True. Raises DuplicateRowsFoundError if multiple rows match.
         """
-        if where is None:
-            raise Exception("None is not allowed as a primary key.")
-        if isinstance(where, int):
-            where = {"sys_id": where}
-        result = self.select("sys_id", where=where, lock=lock).all()
+        lookup = self._normalize_lookup_where(where)
+        result = self._select_sys_ids(lookup, lock=lock, limit=2)
         if not result:
+            if raise_if_missing:
+                raise LookupError(
+                    f"No rows found in `{self.name}` for criteria: {lookup!r}"
+                )
             return None
         if len(result) > 1:
-            sql = self.select("sys_id", sql_only=True, where=where, lock=lock)
+            sql = self.select("sys_id", sql_only=True, where=lookup, lock=lock)
             raise exceptions.DuplicateRowsFoundError(
                 f"More than one entry found. {sql}"
             )
         if use_where:
-            return Row(self, where, lock=lock)
+            return Row(self, lookup, lock=lock)
         return Row(self, result[0]["sys_id"], lock=lock)
 
     one = find
@@ -383,23 +420,21 @@ class Table:
         """
         Finds the first matching row (by `orderby`) or creates one if `create_new=True` and none found.
         """
-        if where is None:
-            raise Exception("None is not allowed as a where clause.")
-        if isinstance(where, int):
-            where = {"sys_id": where}
-        results = self.select(
-            "sys_id", where=where, orderby=orderby, skip_locked=skip_locked
-        ).all()
+        lookup = self._normalize_lookup_where(where)
+        results = self._select_sys_ids(
+            lookup,
+            lock=lock,
+            orderby=orderby,
+            skip_locked=skip_locked,
+            limit=1,
+        )
         if not results:
             if create_new:
-                new_data = where.copy()
-                for k in list(new_data.keys()):
-                    if set("<>!=%").intersection(k):
-                        new_data.pop(k)
+                new_data = self._clean_where_for_insert(lookup)
                 return self.new(new_data, lock=lock)
             return None
         if use_where:
-            return Row(self, where, lock=lock)
+            return Row(self, lookup, lock=lock)
         return Row(self, results[0]["sys_id"], lock=lock)
 
     def primary_keys(self):

{velocity_python-0.0.152 → velocity_python-0.0.154}/src/velocity/db/core/transaction.py

@@ -168,9 +168,21 @@ class Transaction:
         """Shortcut to table.get() with optional ``use_where`` passthrough."""
         return self.table(tablename).get(where, lock=lock, use_where=use_where)
 
-    def find(self, tablename, where, lock=None, use_where=False):
-        """Shortcut to table.find() with optional ``use_where`` passthrough."""
-        return self.table(tablename).find(where, lock=lock, use_where=use_where)
+    def find(
+        self,
+        tablename,
+        where,
+        lock=None,
+        use_where=False,
+        raise_if_missing=False,
+    ):
+        """Shortcut to table.find() with ``use_where``/``raise_if_missing`` passthrough."""
+        return self.table(tablename).find(
+            where,
+            lock=lock,
+            use_where=use_where,
+            raise_if_missing=raise_if_missing,
+        )
 
     def column(self, tablename, colname):
         """

{velocity_python-0.0.152 → velocity_python-0.0.154}/src/velocity_python.egg-info/PKG-INFO

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