velocity-python 0.2.4__tar.gz → 0.2.6__tar.gz

{velocity_python-0.2.4/src/velocity_python.egg-info → velocity_python-0.2.6}/PKG-INFO

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

{velocity_python-0.2.4 → velocity_python-0.2.6}/pyproject.toml

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

{velocity_python-0.2.4 → velocity_python-0.2.6}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.2.4"
+__version__ = version = "0.2.6"
 
 import importlib as _importlib
 

{velocity_python-0.2.4 → velocity_python-0.2.6}/src/velocity/aws/authz.py

@@ -80,6 +80,7 @@ from __future__ import annotations
 
 import logging
 import re
+import sys
 from dataclasses import dataclass, field, replace
 from fnmatch import fnmatchcase
 from typing import Any, Callable, Optional
@@ -379,22 +380,42 @@ BUILTIN_RULES = (permit("data.ordinary_tables", DATA_ACCESS, when=_ordinary_tabl
 
 _REGISTERED = {}
 _REGISTERED_TUPLE = None
+# name -> the globals of the module that registered it. A module imported a
+# second time (importlib.reload, a test that patches sys.modules) runs with
+# new globals under the same __name__ and builds new condition closures, so
+# its rules never compare equal to the first import's.
+_OWNERS = {}
 
 
 def register(*rules):
     """Add rules to the ones every handler evaluates. Registering the same
-    rule again is a no-op; a different rule under a taken name is an error."""
+    rule again is a no-op, and so is a module re-registering its own rules
+    when it is imported again (the new rules replace the old). A different
+    rule under a taken name is otherwise an error."""
     global _REGISTERED_TUPLE
+    caller = sys._getframe(1).f_globals
     for rule in rules:
         if not isinstance(rule, Rule):
             raise ValueError("register() takes rules made by permit() or forbid().")
         known = _REGISTERED.get(rule.name)
-        if known is not None and known != rule:
+        if known is not None and known != rule and not _reimported(rule.name, caller):
             raise ValueError(f"An authorization rule named '{rule.name}' exists.")
         _REGISTERED[rule.name] = rule
+        _OWNERS[rule.name] = caller
     _REGISTERED_TUPLE = None
 
 
+def _reimported(name, caller):
+    """True when ``caller`` is a fresh import of the module that registered
+    ``name``: same module name, different globals."""
+    owner = _OWNERS.get(name)
+    return (
+        owner is not None
+        and owner is not caller
+        and owner.get("__name__") == caller.get("__name__")
+    )
+
+
 def registered():
     """Every rule a handler evaluates before its own. The same tuple object
     until a rule is registered, so its action index is built once."""

{velocity_python-0.2.4 → velocity_python-0.2.6}/src/velocity/db/core/async_support.py

@@ -528,19 +528,9 @@ class AsyncTransaction:
 
         # R12 — Slow query logging
         if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
-            from velocity.db.core.transaction import _summarize_sql
-
-            sql_preview = _summarize_sql(sql)
-            _logger.warning(
-                "Slow async query: %.1f ms sql=%s",
-                elapsed_ms,
-                sql_preview,
-                extra={
-                    "query_duration_ms": round(elapsed_ms, 1),
-                    "sql_preview": sql_preview,
-                },
-                stack_info=True,
-            )
+            from velocity.db.core.transaction import _slow_query_log
+
+            _slow_query_log(_logger, sql, elapsed_ms)
 
         # R14 — N+1 detection / R33 — raw-write cache invalidation
         from velocity.db.core.transaction import _classify_sql, _extract_table_name

{velocity_python-0.2.4 → velocity_python-0.2.6}/src/velocity/db/core/transaction.py

@@ -30,6 +30,15 @@ _DEFAULT_QUERY_CACHE_SIZE = int(os.environ.get("VELOCITY_QUERY_CACHE_SIZE", "100
 # Slow-query threshold in milliseconds (0 = disabled).
 _SLOW_QUERY_MS = int(os.environ.get("VELOCITY_SLOW_QUERY_MS", "500"))
 _SLOW_QUERY_SQL_CHARS = int(os.environ.get("VELOCITY_SLOW_QUERY_SQL_CHARS", "4000"))
+# The slow-query line is for people: this much SQL, the caller's file:line,
+# no traceback unless VELOCITY_SLOW_QUERY_STACK=1 asks for one. The full
+# preview (VELOCITY_SLOW_QUERY_SQL_CHARS) still rides on the record's `extra`.
+_SLOW_QUERY_LINE_CHARS = 200
+_SLOW_QUERY_STACK = os.environ.get("VELOCITY_SLOW_QUERY_STACK", "").strip().lower() in (
+    "1",
+    "true",
+    "yes",
+)
 
 # N+1 detection: warn when the same table is SELECTed more than this many
 # times within a single transaction.  0 = disabled.  Only active when the
@@ -174,16 +183,79 @@ def _written_tables_from_sql(sql):
     return tags or None
 
 
+# a run of three or more bind placeholders: "IN (%s, %s, %s, …)"
+_PLACEHOLDER_RUN_RE = re.compile(r"(%s|\?)(?:\s*,\s*\1){2,}")
+
+
+def _collapse_placeholders(text):
+    """``%s, %s, … (812 of them)`` -> ``%s × 812``."""
+
+    def collapse(match):
+        token = match.group(1)
+        return f"{token} × {match.group(0).count(token)}"
+
+    return _PLACEHOLDER_RUN_RE.sub(collapse, text)
+
+
 def _summarize_sql(sql, limit=None):
     if not sql:
         return None
-    compact = " ".join(str(sql).split())
+    compact = _collapse_placeholders(" ".join(str(sql).split()))
     max_chars = _SLOW_QUERY_SQL_CHARS if limit is None else limit
     if max_chars and len(compact) > max_chars:
         return compact[:max_chars] + "... [truncated]"
     return compact
 
 
+_VELOCITY_DIR = os.path.dirname(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+)
+
+
+def _caller_location():
+    """``file.py:line`` of the first stack frame outside velocity (the code
+    that ran the query), or ``None``."""
+    import traceback
+
+    for frame in reversed(traceback.extract_stack()[:-1]):
+        filename = os.path.abspath(frame.filename)
+        if filename.startswith(_VELOCITY_DIR + os.sep) or "<frozen" in frame.filename:
+            continue
+        return f"{os.path.basename(frame.filename)}:{frame.lineno}"
+    return None
+
+
+def _slow_query_log(logger, sql, elapsed_ms, *, op=None, table=None):
+    """One readable line for a slow query: what, on which table, how long,
+    from where, and the start of the SQL (placeholders collapsed). The fields
+    for log tooling go in ``extra``; a traceback only with
+    VELOCITY_SLOW_QUERY_STACK=1."""
+    op = op or _classify_sql(sql)
+    table = table if table is not None else _extract_table_name(sql)
+    preview = _summarize_sql(sql)
+    line = _summarize_sql(sql, limit=_SLOW_QUERY_LINE_CHARS)
+    caller = _caller_location()
+    took = (
+        f"{elapsed_ms / 1000:.1f} s" if elapsed_ms >= 1000 else f"{elapsed_ms:.0f} ms"
+    )
+    logger.warning(
+        "Slow %s%s: %s%s — %s",
+        op or "query",
+        f" on {table}" if table else "",
+        took,
+        f" at {caller}" if caller else "",
+        line,
+        extra={
+            "query_duration_ms": round(elapsed_ms, 1),
+            "table_name": table,
+            "operation": op,
+            "sql_preview": preview,
+            "caller": caller,
+        },
+        stack_info=_SLOW_QUERY_STACK,
+    )
+
+
 def _is_prepare_kw_type_error(error):
     """True for the TypeError a DB-API driver raises when ``execute()`` has
     no ``prepare`` keyword (``unexpected keyword argument 'prepare'``)."""
@@ -650,23 +722,7 @@ class Transaction:
 
             # R12 — Slow query logging.
             if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
-                op = _classify_sql(sql)
-                tbl = _extract_table_name(sql)
-                sql_preview = _summarize_sql(sql)
-                _logger.warning(
-                    "Slow query (%s): %.1f ms table=%s sql=%s",
-                    op,
-                    elapsed_ms,
-                    tbl,
-                    sql_preview,
-                    extra={
-                        "query_duration_ms": round(elapsed_ms, 1),
-                        "table_name": tbl,
-                        "operation": op,
-                        "sql_preview": sql_preview,
-                    },
-                    stack_info=True,
-                )
+                _slow_query_log(_logger, sql, elapsed_ms)
 
             # R14 — N+1 detection (only when debug=True).
             if debug and _N_PLUS_1_THRESHOLD:

{velocity_python-0.2.4 → velocity_python-0.2.6/src/velocity_python.egg-info}/PKG-INFO

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

{velocity_python-0.2.4 → velocity_python-0.2.6}/tests/test_async_support.py

@@ -728,6 +728,8 @@ class TestAsyncSlowQueryLogging:
                 assert len(slow_calls) >= 1
                 args = slow_calls[0].args
                 kwargs = slow_calls[0].kwargs
-                assert args[2] == "SELECT * FROM large_table"
+                # the same one-line form as the sync path: op, table, SQL last
+                assert args[1:3] == ("SELECT", " on large_table")
+                assert args[-1] == "SELECT * FROM large_table"
                 assert kwargs["extra"]["sql_preview"] == "SELECT * FROM large_table"
-                assert kwargs["stack_info"] is True
+                assert kwargs["stack_info"] is False

{velocity_python-0.2.4 → velocity_python-0.2.6}/tests/test_authz.py

@@ -7,6 +7,7 @@ each ``_any`` permission, masquerade, and the audit row.
 """
 
 import logging
+import sys
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -137,6 +138,55 @@ def test_rules_are_validated_and_registered_once():
             authz.register(authz.permit("test.once", "t.write"))
     finally:
         authz._REGISTERED.pop("test.once", None)
+        authz._OWNERS.pop("test.once", None)
+
+
+_MODULE_SOURCE = """
+from velocity.aws import authz
+authz.register(
+    authz.permit(
+        "test.reimport",
+        "t.read",
+        when=authz.any_of(authz.signed_in, authz.holds("t.read")),
+    )
+)
+"""
+
+
+def _import_as(module_name):
+    """Run a module that registers a rule, as a fresh import would: new
+    globals (so new condition closures) under ``module_name``."""
+    exec(_MODULE_SOURCE, {"__name__": module_name})
+
+
+def test_a_module_imported_again_replaces_its_own_rules(_fresh_registry):
+    _import_as("tests.fake_rules")
+    first = authz._REGISTERED["test.reimport"]
+    _import_as("tests.fake_rules")  # a second import of the same module
+    second = authz._REGISTERED["test.reimport"]
+    assert first != second  # new closures: never equal
+    assert authz.registered().count(second) == 1
+    assert first not in authz.registered()
+
+
+def test_another_module_cannot_take_a_registered_name(_fresh_registry):
+    _import_as("tests.fake_rules")
+    with pytest.raises(ValueError, match="exists"):
+        _import_as("tests.other_rules")
+
+
+def test_velocity_handler_mixins_survive_a_second_import(_fresh_registry):
+    """A consumer test that patches sys.modules imports velocity's handler
+    mixins twice; the permissions rules must not refuse the second import."""
+    import importlib
+
+    name = "velocity.aws.handlers.mixins.permissions_actions"
+    original = sys.modules[name]
+    try:
+        sys.modules.pop(name)
+        importlib.import_module(name)
+    finally:
+        sys.modules[name] = original
 
 
 # ── on a handler ─────────────────────────────────────────────────────────────
@@ -484,10 +534,13 @@ def _fresh_registry():
         dict(authz._REGISTERED),
         authz._REGISTERED_TUPLE,
         dict(authz._PERMISSIONS),
+        dict(authz._OWNERS),
     )
     authz._INDEX.clear()
     authz._HANDLER_RULES.clear()
     yield
+    authz._OWNERS.clear()
+    authz._OWNERS.update(saved[3])
     authz._REGISTERED.clear()
     authz._REGISTERED.update(saved[0])
     authz._REGISTERED_TUPLE = saved[1]

{velocity_python-0.2.4 → velocity_python-0.2.6}/tests/test_observability.py

@@ -179,9 +179,14 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT * FROM big_table")
 
-        assert any("Slow query" in r.message for r in caplog.records)
-        assert any("big_table" in r.message for r in caplog.records)
-        assert any("sql=SELECT * FROM big_table" in r.message for r in caplog.records)
+        lines = [
+            r.getMessage() for r in caplog.records if r.getMessage().startswith("Slow ")
+        ]
+        assert len(lines) == 1
+        # one readable line: what, on which table, how long, from where, the SQL
+        assert lines[0].startswith("Slow SELECT on big_table: ")
+        assert " at test_observability.py:" in lines[0]
+        assert lines[0].endswith("— SELECT * FROM big_table")
 
     def test_fast_query_no_warning(self, caplog):
         tx = _make_tx()
@@ -192,7 +197,7 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT 1")
 
-        assert not any("Slow query" in r.message for r in caplog.records)
+        assert not any(r.getMessage().startswith("Slow ") for r in caplog.records)
 
     def test_slow_query_disabled_when_zero(self, caplog):
         tx = _make_tx()
@@ -211,7 +216,7 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT * FROM big_table")
 
-        assert not any("Slow query" in r.message for r in caplog.records)
+        assert not any(r.getMessage().startswith("Slow ") for r in caplog.records)
 
     def test_slow_query_structured_extra(self, caplog):
         """Verify structured logging extra fields on slow-query record."""
@@ -231,13 +236,39 @@ class TestSlowQueryLogging:
             with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
                 tx._execute("SELECT * FROM orders WHERE id = 1")
 
-        slow_records = [r for r in caplog.records if "Slow query" in r.message]
+        slow_records = [r for r in caplog.records if r.getMessage().startswith("Slow ")]
         assert len(slow_records) >= 1
         rec = slow_records[0]
         assert rec.query_duration_ms > 0
         assert rec.table_name == "orders"
         assert rec.operation == "SELECT"
         assert rec.sql_preview == "SELECT * FROM orders WHERE id = 1"
+        assert rec.caller.startswith("test_observability.py:")
+        # no traceback unless VELOCITY_SLOW_QUERY_STACK asks for one
+        assert not rec.stack_info
+
+    def test_slow_query_collapses_placeholders_and_can_add_the_stack(self, caplog):
+        tx = _make_tx()
+
+        class SlowCursor:
+            def execute(self, *a, **kw):
+                time.sleep(0.01)
+
+            @property
+            def description(self):
+                return None
+
+        tx.connection.cursor.return_value = SlowCursor()
+        sql = "SELECT * FROM links WHERE event_id IN (" + ", ".join(["%s"] * 812) + ")"
+        with (
+            patch("velocity.db.core.transaction._SLOW_QUERY_MS", 5),
+            patch("velocity.db.core.transaction._SLOW_QUERY_STACK", True),
+        ):
+            with caplog.at_level(logging.WARNING, logger="velocity.db.transaction"):
+                tx._execute(sql, tuple(range(812)))
+
+        rec = [r for r in caplog.records if r.getMessage().startswith("Slow ")][0]
+        assert rec.getMessage().endswith("IN (%s × 812)")
         assert rec.stack_info