velocity-python 0.0.203__tar.gz → 0.0.205__tar.gz

{velocity_python-0.0.203 → velocity_python-0.0.205}/PKG-INFO

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

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

{velocity_python-0.0.203 → velocity_python-0.0.205}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.203"
+__version__ = version = "0.0.205"
 
 from . import aws
 from . import db

{velocity_python-0.0.203 → velocity_python-0.0.205}/src/velocity/aws/handlers/base_handler.py

@@ -221,17 +221,61 @@ class BaseHandler:
             local_context: The context object
             exception: The exception that occurred
         """
+        # Always log the original exception so it isn't lost if the error-path
+        # (e.g. job-status updates) fails due to a transient DB disconnect.
+        logger.exception(
+            "Unhandled exception during action execution",
+            extra={
+                "handler": self.__class__.__name__,
+                "action": getattr(local_context, "action", lambda: None)(),
+                "tx_present": tx is not None,
+            },
+        )
+
         if hasattr(self, "onError"):
-            self.onError(
-                tx,
-                local_context,
-                exc=exception.__class__.__name__,
-                tb=traceback.format_exc(),
-            )
+            try:
+                self.onError(
+                    tx,
+                    local_context,
+                    exc=exception.__class__.__name__,
+                    tb=traceback.format_exc(),
+                )
+            except Exception as on_error_exc:
+                if self._is_transient_db_disconnect(on_error_exc):
+                    logger.warning(
+                        "onError failed due to transient DB disconnect; continuing",
+                        exc_info=True,
+                        extra={
+                            "handler": self.__class__.__name__,
+                            "action": getattr(local_context, "action", lambda: None)(),
+                            "original_exc": exception.__class__.__name__,
+                            "onerror_exc": on_error_exc.__class__.__name__,
+                        },
+                    )
+                    return
+                raise
         else:
             # Re-raise if no error handler is defined
             raise exception
 
+    @staticmethod
+    def _is_transient_db_disconnect(exc: Exception) -> bool:
+        """Return True if an exception looks like a transient DB disconnect.
+
+        This is intentionally message-based so it works even if the originating
+        exception type comes from psycopg2 / SQLAlchemy / wrapped Velocity errors.
+        """
+        try:
+            from velocity.db import exceptions as db_exceptions
+
+            if isinstance(exc, db_exceptions.DbConnectionError):
+                return True
+        except Exception:
+            # Avoid import-time coupling; fall back to message matching.
+            pass
+
+        return False
+
     def log(
         self, tx, message: str, function: Optional[str] = None, level: str = "info"
     ):

{velocity_python-0.0.203 → velocity_python-0.0.205}/src/velocity/db/core/engine.py

@@ -1,5 +1,6 @@
 import inspect
 import re
+import time
 from contextlib import contextmanager
 from functools import wraps
 from velocity.db import exceptions
@@ -175,6 +176,7 @@ class Engine:
             else:
                 retry_count = 0
                 lock_timeout_count = 0
+                connection_retry_count = 0
                 while True:
                     try:
                         return function(*args, **kwds)
@@ -182,13 +184,37 @@ class Engine:
                         retry_count += 1
                         if retry_count > self.MAX_RETRIES:
                             raise
+                        # Back off a bit to reduce contention on hot DDL.
+                        time.sleep(min(2.0, 0.05 * (2**min(retry_count, 6))))
                         _tx.rollback()
                     except exceptions.DbLockTimeoutError:
                         lock_timeout_count += 1
                         if lock_timeout_count > self.MAX_RETRIES:
                             raise
+                        time.sleep(min(2.0, 0.05 * (2**min(lock_timeout_count, 6))))
                         _tx.rollback()
                         continue
+                    except exceptions.DbConnectionError as e:
+                        # Transient disconnects can happen during maintenance / restarts.
+                        # Retrying the entire top-level function is the safest option.
+                        msg = str(e).strip().lower()
+                        if not getattr(
+                            self.sql, "is_transient_connection_error_message", lambda _m: False
+                        )(msg):
+                            raise
+
+                        connection_retry_count += 1
+                        if connection_retry_count > 6:
+                            raise
+
+                        # Force a reconnect on the next attempt.
+                        try:
+                            _tx.close()
+                        except Exception:
+                            _tx.connection = None
+
+                        time.sleep(min(2.0, 0.1 * (2**min(connection_retry_count, 5))))
+                        continue
                     except Exception:
                         raise
         finally:
@@ -440,19 +466,8 @@ class Engine:
             raise exceptions.DbDatabaseMissingError(enhanced_message) from exception
         if re.findall(r"already exists", msg, re.M):
             raise exceptions.DbObjectExistsError(enhanced_message) from exception
-        if re.findall(r"server closed the connection unexpectedly", msg, re.M):
-            raise exceptions.DbConnectionError(enhanced_message) from exception
-        if re.findall(r"no connection to the server", msg, re.M):
-            raise exceptions.DbConnectionError(enhanced_message) from exception
-        if re.findall(r"connection timed out", msg, re.M):
-            raise exceptions.DbConnectionError(enhanced_message) from exception
-        if re.findall(r"could not connect to server", msg, re.M):
-            raise exceptions.DbConnectionError(enhanced_message) from exception
-        if re.findall(r"cannot connect to server", msg, re.M):
-            raise exceptions.DbConnectionError(enhanced_message) from exception
-        if re.findall(r"connection already closed", msg, re.M):
-            raise exceptions.DbConnectionError(enhanced_message) from exception
-        if re.findall(r"cursor already closed", msg, re.M):
+        # Dialect-specific connection error message classification (fallback when no/unknown code).
+        if getattr(self.sql, "is_connection_error_message", lambda _m: False)(msg):
             raise exceptions.DbConnectionError(enhanced_message) from exception
         if "no such table:" in msg:
             raise exceptions.DbTableMissingError(enhanced_message) from exception

{velocity_python-0.0.203 → velocity_python-0.0.205}/src/velocity/db/core/transaction.py

@@ -2,6 +2,7 @@ import traceback
 
 from velocity.db.core.row import Row
 from velocity.db.core.table import Table
+from velocity.db.core.view import View
 from velocity.db.core.result import Result
 from velocity.db.core.column import Column
 from velocity.db.core.database import Database
@@ -47,6 +48,16 @@ class Transaction:
         """
         Retrieves a database cursor, opening a connection if necessary.
         """
+        # Lazily connect, and also recover if the driver reports a closed connection.
+        # (psycopg2 uses `connection.closed != 0` to indicate closed.)
+        if self.connection is not None:
+            try:
+                if getattr(self.connection, "closed", 0):
+                    self.connection = None
+            except Exception:
+                # If the driver object is in a bad state, force a reconnect.
+                self.connection = None
+
         if not self.connection:
             self.connection = self.engine.connect()
         if debug:
@@ -157,6 +168,10 @@ class Transaction:
         """
         return Table(self, tablename)
 
+    def view(self, viewname, schema=None):
+        """Returns a View helper for the given view name."""
+        return View(self, viewname, schema=schema)
+
     def sequence(self, name):
         """
         Returns a Sequence object for the given sequence name.

velocity_python-0.0.205/src/velocity/db/core/view.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from velocity.db import exceptions
+
+
+def _quote_ident(identifier: str) -> str:
+    return '"' + str(identifier).replace('"', '""') + '"'
+
+
+def _grantee_sql(grantee: str) -> str:
+    normalized = str(grantee).strip()
+    if not normalized:
+        raise ValueError("grantee cannot be empty")
+
+    keyword = normalized.upper()
+    if keyword in {"PUBLIC", "CURRENT_USER", "SESSION_USER"}:
+        return keyword
+
+    return _quote_ident(normalized)
+
+
+@dataclass
+class Grant:
+    privilege: str
+    grantee: str
+
+
+class View:
+    """PostgreSQL view helper.
+
+    This is intentionally lightweight and uses catalog queries directly rather than
+    embedding view DDL in the dialect.
+
+    Primary goals:
+    - Create views in an idempotent way (CREATE OR REPLACE).
+    - If the view already exists, "enhance" it by applying missing grants.
+
+    Notes:
+    - For updating the view definition, pass replace_existing=True.
+    - Privilege checks use has_table_privilege().
+    """
+
+    def __init__(self, tx, name: str, schema: str | None = None):
+        self.tx = tx
+        self.name = str(name).lower()
+        self.schema = (schema or getattr(tx.engine.sql, "default_schema", None) or "public").lower()
+
+    @property
+    def qualified_name(self) -> str:
+        return f"{_quote_ident(self.schema)}.{_quote_ident(self.name)}"
+
+    def exists(self) -> bool:
+        result = self.tx.execute(
+            """
+            SELECT 1
+            FROM information_schema.views
+            WHERE table_schema = %s AND table_name = %s
+            LIMIT 1
+            """,
+            [self.schema, self.name],
+        )
+        try:
+            rows = result.as_dict().all()
+        except Exception:
+            rows = []
+        return bool(rows)
+
+    def create_or_replace(self, select_sql: str) -> None:
+        if self.tx.engine.schema_locked:
+            raise exceptions.DbSchemaLockedError(
+                f"Cannot create/replace view {self.schema}.{self.name}: schema is locked"
+            )
+
+        sql = (select_sql or "").strip().rstrip(";")
+        if not sql:
+            raise ValueError("select_sql cannot be empty")
+
+        # If caller already provided CREATE VIEW, execute as-is.
+        lowered = sql.lower().lstrip()
+        if lowered.startswith("create"):
+            self.tx.execute(sql)
+            return
+
+        ddl = f"CREATE OR REPLACE VIEW {self.qualified_name} AS\n{sql}"
+        self.tx.execute(ddl)
+
+    def _has_privilege(self, grantee: str, privilege: str) -> bool:
+        # PUBLIC is a PostgreSQL pseudo-role for GRANT, but it's not necessarily a
+        # real role that can be passed to has_table_privilege() in all setups.
+        # GRANT itself is idempotent, so for PUBLIC we just apply it unconditionally.
+        if str(grantee).strip().upper() == "PUBLIC":
+            return False
+
+        # has_table_privilege(role, table, privilege)
+        # Note: privilege must be like 'SELECT'.
+        result = self.tx.execute(
+            "SELECT has_table_privilege(%s, %s, %s) as ok",
+            [grantee, f"{self.schema}.{self.name}", privilege],
+        )
+        try:
+            rows = result.as_dict().all()
+        except Exception:
+            rows = []
+        row = rows[0] if rows else None
+        return bool(row.get("ok")) if isinstance(row, dict) and row else False
+
+    def grant(self, privilege: str = "SELECT", grantee: str = "PUBLIC") -> None:
+        if self.tx.engine.schema_locked:
+            raise exceptions.DbSchemaLockedError(
+                f"Cannot grant privileges on {self.schema}.{self.name}: schema is locked"
+            )
+        privilege = str(privilege).upper().strip()
+        if not privilege:
+            raise ValueError("privilege cannot be empty")
+        self.tx.execute(
+            f"GRANT {privilege} ON {self.qualified_name} TO {_grantee_sql(grantee)}"
+        )
+
+    def ensure(
+        self,
+        select_sql: str | None = None,
+        *,
+        replace_existing: bool = False,
+        grants: list[Grant] | None = None,
+        grant_public_select: bool = True,
+    ) -> None:
+        """Ensure the view exists and has required grants.
+
+        - If the view does not exist, it is created using select_sql (required).
+        - If it exists, it is not modified unless replace_existing=True.
+        - Missing privileges are granted.
+        """
+
+        exists = self.exists()
+
+        if not exists:
+            if select_sql is None:
+                raise ValueError("select_sql is required when creating a missing view")
+            self.create_or_replace(select_sql)
+        elif replace_existing and select_sql is not None:
+            self.create_or_replace(select_sql)
+
+        desired_grants: list[Grant] = []
+        if grant_public_select:
+            desired_grants.append(Grant("SELECT", "PUBLIC"))
+        if grants:
+            desired_grants.extend(grants)
+
+        for g in desired_grants:
+            privilege = str(g.privilege).upper().strip()
+            grantee = str(g.grantee).strip()
+            if not privilege or not grantee:
+                continue
+
+            if not self._has_privilege(grantee, privilege):
+                self.grant(privilege=privilege, grantee=grantee)

{velocity_python-0.0.203 → velocity_python-0.0.205}/src/velocity/db/servers/base/sql.py

@@ -52,6 +52,43 @@ class BaseSQLDialect(ABC):
         """
         pass
 
+    @classmethod
+    def is_connection_error_message(cls, msg: str) -> bool:
+        """Return True if an error message indicates a connection-level failure.
+
+        Dialects should override/extend this if they can do better than message matching.
+        Engine uses this only as a fallback when no/unknown error code is available.
+        """
+        if not msg:
+            return False
+        m = str(msg).strip().lower()
+        needles = (
+            "server closed the connection unexpectedly",
+            "no connection to the server",
+            "connection timed out",
+            "could not connect to server",
+            "cannot connect to server",
+            "connection already closed",
+            "cursor already closed",
+            "ssl syscall error",
+            "eof detected",
+            "connection reset by peer",
+            "broken pipe",
+            "terminating connection due to administrator command",
+            "could not receive data from server",
+            "could not send data to server",
+        )
+        return any(n in m for n in needles)
+
+    @classmethod
+    def is_transient_connection_error_message(cls, msg: str) -> bool:
+        """Return True if a connection error looks transient/retryable.
+
+        Default implementation treats most low-level disconnects as transient.
+        Dialects may override to be stricter.
+        """
+        return cls.is_connection_error_message(msg)
+
     # Core CRUD Operations
     @classmethod
     @abstractmethod

velocity_python-0.0.205/src/velocity/db/tests/test_view_helper.py

@@ -0,0 +1,97 @@
+import unittest
+from types import SimpleNamespace
+
+from velocity.db.core.view import View
+
+
+class FakeResult:
+    def __init__(self, rows):
+        self._rows = rows
+
+    def as_dict(self):
+        return self
+
+    def all(self):
+        return list(self._rows)
+
+
+class FakeTx:
+    def __init__(self):
+        self.executed = []
+        self.engine = SimpleNamespace(
+            schema_locked=False,
+            sql=SimpleNamespace(default_schema="public"),
+        )
+
+        # Toggleable responses
+        self._view_exists = False
+        self._has_priv = False
+
+    def execute(self, sql, parms=None, *args, **kwargs):
+        self.executed.append((sql, parms))
+
+        text = str(sql)
+        if "information_schema.views" in text:
+            return FakeResult([{"ok": True}]) if self._view_exists else FakeResult([])
+
+        if "has_table_privilege" in text:
+            return FakeResult([{"ok": bool(self._has_priv)}])
+
+        return FakeResult([])
+
+
+class TestViewHelper(unittest.TestCase):
+    def test_ensure_creates_missing_view_and_grants(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = False
+        tx._has_priv = False
+
+        v.ensure("select 1 as one")
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertIn("CREATE OR REPLACE VIEW", statements)
+        self.assertIn('"public"."my_view"', statements)
+        self.assertIn("GRANT SELECT ON", statements)
+
+    def test_ensure_existing_view_does_not_replace_by_default(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = True
+        tx._has_priv = False
+
+        v.ensure("select 1 as one")
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertNotIn("CREATE OR REPLACE VIEW", statements)
+        self.assertIn("GRANT SELECT ON", statements)
+
+    def test_ensure_existing_view_replaces_when_requested(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = True
+        tx._has_priv = True
+
+        v.ensure("select 1 as one", replace_existing=True)
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertIn("CREATE OR REPLACE VIEW", statements)
+
+    def test_ensure_skips_grant_if_already_present(self):
+        tx = FakeTx()
+        v = View(tx, "my_view")
+
+        tx._view_exists = True
+        tx._has_priv = True
+
+        v.ensure("select 1 as one")
+
+        statements = "\n".join(s for s, _ in tx.executed)
+        self.assertNotIn("GRANT SELECT ON", statements)
+
+
+if __name__ == "__main__":
+    unittest.main()

{velocity_python-0.0.203 → velocity_python-0.0.205}/src/velocity_python.egg-info/PKG-INFO

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

@@ -42,6 +42,7 @@ src/velocity/db/core/row.py
 src/velocity/db/core/sequence.py
 src/velocity/db/core/table.py
 src/velocity/db/core/transaction.py
+src/velocity/db/core/view.py
 src/velocity/db/servers/__init__.py
 src/velocity/db/servers/tablehelper.py
 src/velocity/db/servers/base/__init__.py
@@ -83,6 +84,7 @@ src/velocity/db/tests/test_schema_locking_initializers.py
 src/velocity/db/tests/test_schema_locking_simple.py
 src/velocity/db/tests/test_sql_builder.py
 src/velocity/db/tests/test_tablehelper.py
+src/velocity/db/tests/test_view_helper.py
 src/velocity/db/tests/postgres/__init__.py
 src/velocity/db/tests/postgres/common.py
 src/velocity/db/tests/postgres/test_column.py