velocity-python 0.1.113__tar.gz → 0.1.115__tar.gz

{velocity_python-0.1.113/src/velocity_python.egg-info → velocity_python-0.1.115}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.113
+Version: 0.1.115
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -252,6 +252,7 @@ Full documentation is included in the `docs/` directory of the source distributi
 | Configuration Reference | `docs/configuration.md` | All environment variables, engine options, and connection settings |
 | AWS Lambda Handlers | `docs/aws-handlers.md` | LambdaHandler, SqsHandler, auth modes, per-record transactions, async jobs (JobHandler + job result stores) |
 | Cross-database Mirroring | `docs/mirroring.md` | Keep a table identical in two databases (demo ↔ production) by natural key; rwx hooks, FK translation, reconcile |
+| Operations Dashboard | `docs/operations.md` | What the automation is doing: schedules, jobs, failures, stuck work, with drill-down (`velocity.aws.ops` + velocity-react `OpsDashboard`) |
 | NoSQL Adapters | `docs/nosql.md` | Redis, DynamoDB, MongoDB, Elasticsearch, Cassandra, Couchbase behind one capability-honest contract |
 | Payment Processing | `docs/payment.md` | Stripe and Braintree adapters, payment lifecycle |
 | Utilities | `docs/utilities.md` | Excel export, data conversion, formatting, timers, email parsing and SMTP sending |

{velocity_python-0.1.113 → velocity_python-0.1.115}/README.md

@@ -158,6 +158,7 @@ Full documentation is included in the `docs/` directory of the source distributi
 | Configuration Reference | `docs/configuration.md` | All environment variables, engine options, and connection settings |
 | AWS Lambda Handlers | `docs/aws-handlers.md` | LambdaHandler, SqsHandler, auth modes, per-record transactions, async jobs (JobHandler + job result stores) |
 | Cross-database Mirroring | `docs/mirroring.md` | Keep a table identical in two databases (demo ↔ production) by natural key; rwx hooks, FK translation, reconcile |
+| Operations Dashboard | `docs/operations.md` | What the automation is doing: schedules, jobs, failures, stuck work, with drill-down (`velocity.aws.ops` + velocity-react `OpsDashboard`) |
 | NoSQL Adapters | `docs/nosql.md` | Redis, DynamoDB, MongoDB, Elasticsearch, Cassandra, Couchbase behind one capability-honest contract |
 | Payment Processing | `docs/payment.md` | Stripe and Braintree adapters, payment lifecycle |
 | Utilities | `docs/utilities.md` | Excel export, data conversion, formatting, timers, email parsing and SMTP sending |

{velocity_python-0.1.113 → velocity_python-0.1.115}/pyproject.toml

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

{velocity_python-0.1.113 → velocity_python-0.1.115}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.113"
+__version__ = version = "0.1.115"
 
 import importlib as _importlib
 

velocity_python-0.1.115/src/velocity/aws/ops.py

@@ -0,0 +1,500 @@
+"""Operations read model: what the automation is doing, from velocity's own tables.
+
+Every velocity app already records its automated work — schedules in
+``sys_task_triggers`` (run by ``program_objects`` stubs), queued work in
+``aws_job_activity`` (JobHandler), guard refusals in ``sys_security_events``,
+the capabilities switched on in ``sys_capabilities`` — but nothing read those
+tables *together*. This module is that read model: one overview for a
+dashboard, and the three drill-downs under it. It owns no table and writes
+nothing; an app gets the whole feature by mixing :class:`OpsDashboardMixin`
+into a web handler (velocity-react's ``OpsDashboard`` is the matching UI).
+
+* :func:`overview` — headline tiles, a zero-filled runs-over-time series,
+  per-action rollups (runs, failures, p50/p95/max duration, last outcome),
+  schedule health, the latest failures, stuck work, enabled capabilities.
+* :func:`action_runs` — the recent runs of one action.
+* :func:`job_detail` — one run in full (payload, message, error, traceback).
+* :func:`schedule_detail` — one schedule, its program, and its recent runs.
+
+Timestamps are the database's (naive UTC) and leave here as ISO-8601 with a
+``Z``. The aggregate SQL is PostgreSQL (``filter``, ``percentile_cont``); every
+statement carries an ``/* ops:<name> */`` marker so it is recognisable in
+``pg_stat_activity`` and slow-query logs. A section whose table does not exist
+is simply empty — an app that has never provisioned security still gets a
+dashboard.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+from decimal import Decimal
+
+from velocity.aws.job_lifecycle import (
+    DEFAULT_STALE_AFTER,
+    JOB_ACTIVITY_TABLE,
+    STALE_JOB_STATUSES,
+)
+from velocity.cache import db_identity, memo
+
+TRIGGERS_TABLE = "sys_task_triggers"
+PROGRAMS_TABLE = "program_objects"
+SECURITY_EVENTS_TABLE = "sys_security_events"
+CAPABILITIES_TABLE = "sys_capabilities"
+
+DEFAULT_HOURS = 24
+MAX_HOURS = 24 * 30
+OVERVIEW_CACHE_SECONDS = 15  # absorbs several tabs polling the same window
+SCHEMA_CACHE_SECONDS = 300
+OVERDUE_GRACE = datetime.timedelta(minutes=10)
+RECENT_FAILURES = 10
+PROGRAM_JOB_ACTION = "run-program-object"
+PROGRAM_JOB_DESCRIPTION = "Program Object: {handle}"
+
+
+# ── small shapes ─────────────────────────────────────────────────────────
+
+
+def _utcnow():
+    return datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None)
+
+
+def _iso(value):
+    """Database timestamps are naive UTC; say so on the wire."""
+    if value is None:
+        return None
+    if isinstance(value, datetime.datetime):
+        if value.tzinfo is not None:
+            value = value.astimezone(datetime.timezone.utc).replace(tzinfo=None)
+        return value.isoformat(timespec="seconds") + "Z"
+    return str(value)
+
+
+def _num(value, digits=2):
+    if value is None:
+        return None
+    if isinstance(value, Decimal):
+        value = float(value)
+    return round(value, digits) if isinstance(value, float) else value
+
+
+def _seconds(value):
+    """An INTERVAL (timedelta) or number as seconds."""
+    if value is None:
+        return None
+    if isinstance(value, datetime.timedelta):
+        return round(value.total_seconds(), 2)
+    return _num(value)
+
+
+def _first_line(text, limit=240):
+    if not text:
+        return None
+    line = str(text).strip().splitlines()[0] if str(text).strip() else ""
+    return line[:limit] or None
+
+
+def _maybe_json(text):
+    if not isinstance(text, str) or not text.strip():
+        return text
+    try:
+        return json.loads(text)
+    except ValueError:
+        return text
+
+
+def clamp_hours(value, default=DEFAULT_HOURS):
+    try:
+        hours = int(value)
+    except (TypeError, ValueError):
+        return default
+    return max(1, min(MAX_HOURS, hours))
+
+
+def bucket_minutes(hours):
+    """Bucket width for the runs-over-time series: about 24-56 columns."""
+    if hours <= 6:
+        return 15
+    if hours <= 48:
+        return 60
+    if hours <= 24 * 7:
+        return 180
+    return 720
+
+
+def _has(tx, table):
+    try:
+        return bool(tx.table(table).exists(cache_ttl=SCHEMA_CACHE_SECONDS))
+    except Exception:
+        return False
+
+
+def _rows(tx, sql, params=()):
+    return [dict(row) for row in tx.execute(sql, list(params)).as_dict().all()]
+
+
+# ── pure shaping (unit-tested without a database) ────────────────────────
+
+
+def fill_timeline(rows, *, since, until, minutes):
+    """Zero-filled buckets from ``since`` to ``until`` — a gap in the data is a
+    real zero on the chart, not a missing column."""
+    step = datetime.timedelta(minutes=minutes)
+    epoch = datetime.datetime(1970, 1, 1)
+    start = epoch + step * ((since - epoch) // step)
+    by_bucket = {}
+    for row in rows:
+        bucket = row.get("bucket")
+        if isinstance(bucket, datetime.datetime) and bucket.tzinfo is not None:
+            bucket = bucket.astimezone(datetime.timezone.utc).replace(tzinfo=None)
+        by_bucket[bucket] = row
+    out = []
+    cursor = start
+    while cursor <= until:
+        row = by_bucket.get(cursor, {})
+        out.append(
+            {
+                "bucket": _iso(cursor),
+                "completed": int(row.get("completed") or 0),
+                "failed": int(row.get("failed") or 0),
+                "other": int(row.get("other") or 0),
+            }
+        )
+        cursor += step
+    return out
+
+
+def schedule_health(trigger, *, now, grace=OVERDUE_GRACE):
+    """``disabled`` | ``never`` (enabled, never ran) | ``overdue`` (its next
+    run is in the past beyond the grace) | ``ok``."""
+    if not trigger.get("enabled"):
+        return "disabled"
+    next_run = trigger.get("next_run")
+    if next_run is not None and next_run + grace < now:
+        return "overdue"
+    if not trigger.get("run_count") and trigger.get("last_run") is None:
+        return "never"
+    return "ok"
+
+
+def shape_action(row, last_status=None):
+    runs = int(row.get("runs") or 0)
+    failed = int(row.get("failed") or 0)
+    return {
+        "action": row.get("action"),
+        "runs": runs,
+        "completed": int(row.get("completed") or 0),
+        "failed": failed,
+        "cancelled": int(row.get("cancelled") or 0),
+        "open": int(row.get("open") or 0),
+        "stale": int(row.get("stale") or 0),
+        "fail_rate": round(failed / runs, 4) if runs else 0.0,
+        "p50_seconds": _num(row.get("p50_seconds")),
+        "p95_seconds": _num(row.get("p95_seconds")),
+        "max_seconds": _num(row.get("max_seconds")),
+        "last_run": _iso(row.get("last_run")),
+        "last_status": last_status,
+    }
+
+
+def shape_run(row):
+    return {
+        "job_id": row.get("job_id"),
+        "action": row.get("action"),
+        "status": row.get("status"),
+        "created": _iso(row.get("sys_created")),
+        "started": _iso(row.get("handler_start_timestamp")),
+        "completed": _iso(row.get("handler_complete_timestamp")),
+        "duration_seconds": _seconds(row.get("handler_duration")),
+        "created_by": row.get("created_by"),
+        "description": row.get("description"),
+        "error": _first_line(row.get("error")),
+    }
+
+
+def shape_schedule(trigger, program=None, *, now):
+    program = program or {}
+    return {
+        "name": trigger.get("name"),
+        "trigger_name": trigger.get("trigger_name"),
+        "description": trigger.get("description"),
+        "cron": trigger.get("cron_expression"),
+        "enabled": bool(trigger.get("enabled")),
+        "run_count": int(trigger.get("run_count") or 0),
+        "last_run": _iso(trigger.get("last_run")),
+        "next_run": _iso(trigger.get("next_run")),
+        "health": schedule_health(trigger, now=now),
+        "program": program.get("program_handle"),
+        "program_name": program.get("program_name"),
+    }
+
+
+# ── the read model ───────────────────────────────────────────────────────
+
+_RUN_COLUMNS = (
+    "job_id, action, status, sys_created, handler_start_timestamp, "
+    "handler_complete_timestamp, handler_duration, created_by, description, error"
+)
+
+
+def _open_statuses():
+    return sorted(STALE_JOB_STATUSES)
+
+
+def overview(tx, *, hours=DEFAULT_HOURS, now=None):
+    """The dashboard in one call. Cached per container for a few seconds, so
+    several tabs polling the same window cost one set of queries."""
+    hours = clamp_hours(hours)
+    if now is not None:
+        return _overview(tx, hours, now)
+    key = ("ops", "overview", db_identity(getattr(tx, "engine", None)), hours)
+    return memo(key, lambda: _overview(tx, hours, _utcnow()), OVERVIEW_CACHE_SECONDS)
+
+
+def _overview(tx, hours, now):
+    since = now - datetime.timedelta(hours=hours)
+    stale_before = now - DEFAULT_STALE_AFTER
+    minutes = bucket_minutes(hours)
+    actions, timeline, failures, stuck = [], [], [], 0
+
+    if _has(tx, JOB_ACTIVITY_TABLE):
+        open_statuses = _open_statuses()
+        marks = ", ".join(["%s"] * len(open_statuses))
+        rollups = _rows(
+            tx,
+            f"/* ops:actions */ select action, count(*) as runs, "
+            "count(*) filter (where status = 'Completed') as completed, "
+            "count(*) filter (where status = 'Failed') as failed, "
+            "count(*) filter (where status = 'Cancelled') as cancelled, "
+            f"count(*) filter (where status in ({marks})) as open, "
+            f"count(*) filter (where status in ({marks}) and "
+            "coalesce(handler_start_timestamp, sys_created) < %s) as stale, "
+            "percentile_cont(0.5) within group (order by extract(epoch from "
+            "handler_duration)) as p50_seconds, "
+            "percentile_cont(0.95) within group (order by extract(epoch from "
+            "handler_duration)) as p95_seconds, "
+            "max(extract(epoch from handler_duration)) as max_seconds, "
+            "max(sys_created) as last_run "
+            f"from {JOB_ACTIVITY_TABLE} where sys_created >= %s "
+            "group by action order by failed desc, runs desc, action",
+            [*open_statuses, *open_statuses, stale_before, since],
+        )
+        last = {
+            row["action"]: row["status"]
+            for row in _rows(
+                tx,
+                "/* ops:last-status */ select distinct on (action) action, status "
+                f"from {JOB_ACTIVITY_TABLE} where sys_created >= %s "
+                "order by action, sys_id desc",
+                [since],
+            )
+        }
+        actions = [shape_action(row, last.get(row.get("action"))) for row in rollups]
+
+        seconds = minutes * 60
+        timeline = fill_timeline(
+            _rows(
+                tx,
+                "/* ops:timeline */ select to_timestamp(floor(extract(epoch from "
+                "sys_created) / %s) * %s) at time zone 'UTC' as bucket, "
+                "count(*) filter (where status = 'Completed') as completed, "
+                "count(*) filter (where status = 'Failed') as failed, "
+                "count(*) filter (where status not in ('Completed', 'Failed')) "
+                f"as other from {JOB_ACTIVITY_TABLE} where sys_created >= %s "
+                "group by 1 order by 1",
+                [seconds, seconds, since],
+            ),
+            since=since,
+            until=now,
+            minutes=minutes,
+        )
+        failures = [
+            shape_run(row)
+            for row in _rows(
+                tx,
+                f"/* ops:failures */ select {_RUN_COLUMNS} from {JOB_ACTIVITY_TABLE} "
+                "where status = 'Failed' and sys_created >= %s "
+                "order by sys_id desc limit %s",
+                [since, RECENT_FAILURES],
+            )
+        ]
+        # stuck work is counted over ALL time: a job abandoned last week is
+        # still stuck today, whatever window the dashboard is showing
+        stuck = int(
+            _rows(
+                tx,
+                f"/* ops:stuck */ select count(*) as n from {JOB_ACTIVITY_TABLE} "
+                f"where status in ({marks}) and "
+                "coalesce(handler_start_timestamp, sys_created) < %s",
+                [*open_statuses, stale_before],
+            )[0]["n"]
+            or 0
+        )
+
+    schedules = _schedules(tx, now)
+    refusals = None
+    if _has(tx, SECURITY_EVENTS_TABLE):
+        refusals = int(
+            _rows(
+                tx,
+                "/* ops:refusals */ select count(*) as n from "
+                f"{SECURITY_EVENTS_TABLE} where sys_created >= %s",
+                [since],
+            )[0]["n"]
+            or 0
+        )
+    capabilities = []
+    if _has(tx, CAPABILITIES_TABLE):
+        capabilities = [
+            {"name": row.get("name"), "enabled": row.get("enabled") is not False}
+            for row in tx.table(CAPABILITIES_TABLE).select(orderby="name")
+        ]
+
+    runs = sum(a["runs"] for a in actions)
+    failed = sum(a["failed"] for a in actions)
+    return {
+        "generated_at": _iso(now),
+        "window_hours": hours,
+        "bucket_minutes": minutes,
+        "tiles": {
+            "runs": runs,
+            "failed": failed,
+            "fail_rate": round(failed / runs, 4) if runs else 0.0,
+            "open": sum(a["open"] for a in actions),
+            "stuck": stuck,
+            "schedules_enabled": sum(1 for s in schedules if s["enabled"]),
+            "schedules_overdue": sum(1 for s in schedules if s["health"] == "overdue"),
+            "refusals": refusals,
+        },
+        "timeline": timeline,
+        "actions": actions,
+        "schedules": schedules,
+        "failures": failures,
+        "capabilities": capabilities,
+    }
+
+
+def _schedules(tx, now):
+    if not _has(tx, TRIGGERS_TABLE):
+        return []
+    programs = {}
+    if _has(tx, PROGRAMS_TABLE):
+        for row in tx.table(PROGRAMS_TABLE).select(
+            ["program_name", "program_handle", "trigger"]
+        ):
+            programs[row.get("trigger")] = dict(row)
+    return [
+        shape_schedule(dict(row), programs.get(row.get("trigger_name")), now=now)
+        for row in tx.table(TRIGGERS_TABLE).select(orderby="name")
+    ]
+
+
+def action_runs(tx, action, *, hours=DEFAULT_HOURS, limit=50, now=None):
+    """The recent runs of one action, newest first."""
+    hours = clamp_hours(hours)
+    now = now or _utcnow()
+    limit = max(1, min(200, int(limit or 50)))
+    runs = []
+    if action and _has(tx, JOB_ACTIVITY_TABLE):
+        runs = [
+            shape_run(row)
+            for row in _rows(
+                tx,
+                f"/* ops:action-runs */ select {_RUN_COLUMNS} from "
+                f"{JOB_ACTIVITY_TABLE} where action = %s and sys_created >= %s "
+                "order by sys_id desc limit %s",
+                [action, now - datetime.timedelta(hours=hours), limit],
+            )
+        ]
+    return {"action": action, "window_hours": hours, "runs": runs}
+
+
+def job_detail(tx, job_id):
+    """One run in full; ``None`` when there is no such job."""
+    if not job_id or not _has(tx, JOB_ACTIVITY_TABLE):
+        return None
+    row = tx.table(JOB_ACTIVITY_TABLE).find({"job_id": job_id})
+    if not row:
+        return None
+    row = dict(row)
+    detail = shape_run(row)
+    detail.update(
+        {
+            "batch_id": row.get("batch_id"),
+            "payload": _maybe_json(row.get("payload")),
+            "message": _maybe_json(row.get("message")),
+            "error": row.get("error"),
+            "traceback": row.get("traceback"),
+        }
+    )
+    return detail
+
+
+def schedule_detail(tx, trigger_name, *, limit=20, now=None):
+    """One schedule, the program it runs, and that program's recent runs."""
+    now = now or _utcnow()
+    if not trigger_name or not _has(tx, TRIGGERS_TABLE):
+        return None
+    trigger = tx.table(TRIGGERS_TABLE).find({"trigger_name": trigger_name})
+    if not trigger:
+        return None
+    program = None
+    if _has(tx, PROGRAMS_TABLE):
+        program = tx.table(PROGRAMS_TABLE).find({"trigger": trigger_name})
+    program = dict(program) if program else {}
+    detail = shape_schedule(dict(trigger), program, now=now)
+    detail["program_description"] = program.get("program_description")
+    detail["source_code"] = program.get("source_code")
+    runs = []
+    if program.get("program_handle") and _has(tx, JOB_ACTIVITY_TABLE):
+        runs = [
+            shape_run(row)
+            for row in _rows(
+                tx,
+                f"/* ops:schedule-runs */ select {_RUN_COLUMNS} from "
+                f"{JOB_ACTIVITY_TABLE} where action = %s and description = %s "
+                "order by sys_id desc limit %s",
+                [
+                    PROGRAM_JOB_ACTION,
+                    PROGRAM_JOB_DESCRIPTION.format(handle=program["program_handle"]),
+                    max(1, min(100, int(limit or 20))),
+                ],
+            )
+        ]
+    detail["runs"] = runs
+    return detail
+
+
+# ── the handler mixin ────────────────────────────────────────────────────
+
+
+class OpsDashboardMixin:
+    """Web-handler mixin: the operations read model as four read-only actions
+    (``ops-overview``, ``ops-action-runs``, ``ops-job``, ``ops-schedule``).
+    Payloads: ``{hours}``, ``{action, hours, limit}``, ``{job_id}``,
+    ``{trigger_name}``. velocity-react's ``OpsDashboard`` consumes them."""
+
+    def OnActionOpsOverview(self, tx, context):
+        payload = context.payload() or {}
+        context.response().set_body(overview(tx, hours=payload.get("hours")))
+
+    def OnActionOpsActionRuns(self, tx, context):
+        payload = context.payload() or {}
+        context.response().set_body(
+            action_runs(
+                tx,
+                payload.get("action"),
+                hours=payload.get("hours"),
+                limit=payload.get("limit"),
+            )
+        )
+
+    def OnActionOpsJob(self, tx, context):
+        payload = context.payload() or {}
+        context.response().set_body({"job": job_detail(tx, payload.get("job_id"))})
+
+    def OnActionOpsSchedule(self, tx, context):
+        payload = context.payload() or {}
+        context.response().set_body(
+            {"schedule": schedule_detail(tx, payload.get("trigger_name"))}
+        )

{velocity_python-0.1.113 → velocity_python-0.1.115}/src/velocity/db/core/result.py

@@ -81,10 +81,19 @@ class Result:
         if self._first_row_fetched or not self._cursor:
             return
 
-        # Don't try to fetch from INSERT/UPDATE/DELETE operations
-        # These operations don't return rows, only rowcount
-        if self.__sql and self.__sql.strip().upper().startswith(
-            ("INSERT", "UPDATE", "DELETE", "TRUNCATE")
+        # A write returns rows exactly when the driver describes a result set:
+        # INSERT/UPDATE/DELETE ... RETURNING (PostgreSQL), OUTPUT (SQL Server).
+        # Judging by the verb alone marked EVERY write as row-less, so
+        # `UPDATE ... RETURNING sys_id` silently reported nothing — a claim taken
+        # that way looked refused forever (tenspace.gmail, 2026-09-17). A write
+        # with no described columns has only a rowcount, and fetchone() on it
+        # raises on most drivers, so that case is still short-circuited.
+        if (
+            self.__sql
+            and self.__sql.strip()
+            .upper()
+            .startswith(("INSERT", "UPDATE", "DELETE", "TRUNCATE"))
+            and not self._headers
         ):
             self._exhausted = True
             self._first_row_fetched = True

{velocity_python-0.1.113 → velocity_python-0.1.115/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.113
+Version: 0.1.115
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -252,6 +252,7 @@ Full documentation is included in the `docs/` directory of the source distributi
 | Configuration Reference | `docs/configuration.md` | All environment variables, engine options, and connection settings |
 | AWS Lambda Handlers | `docs/aws-handlers.md` | LambdaHandler, SqsHandler, auth modes, per-record transactions, async jobs (JobHandler + job result stores) |
 | Cross-database Mirroring | `docs/mirroring.md` | Keep a table identical in two databases (demo ↔ production) by natural key; rwx hooks, FK translation, reconcile |
+| Operations Dashboard | `docs/operations.md` | What the automation is doing: schedules, jobs, failures, stuck work, with drill-down (`velocity.aws.ops` + velocity-react `OpsDashboard`) |
 | NoSQL Adapters | `docs/nosql.md` | Redis, DynamoDB, MongoDB, Elasticsearch, Cassandra, Couchbase behind one capability-honest contract |
 | Payment Processing | `docs/payment.md` | Stripe and Braintree adapters, payment lifecycle |
 | Utilities | `docs/utilities.md` | Excel export, data conversion, formatting, timers, email parsing and SMTP sending |

{velocity_python-0.1.113 → velocity_python-0.1.115}/src/velocity_python.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ src/velocity/aws/feature_flags.py
 src/velocity/aws/job_lifecycle.py
 src/velocity/aws/job_results.py
 src/velocity/aws/mirror.py
+src/velocity/aws/ops.py
 src/velocity/aws/s3.py
 src/velocity/aws/sms.py
 src/velocity/aws/ssm_config.py
@@ -259,6 +260,7 @@ tests/test_nosql_translation.py
 tests/test_nosql_where.py
 tests/test_observability.py
 tests/test_on_commit.py
+tests/test_ops.py
 tests/test_payment_authorizenet_adapter.py
 tests/test_payment_braintree_adapter.py
 tests/test_payment_braintree_mirror.py
@@ -273,6 +275,7 @@ tests/test_query_missing_table_unlocked.py
 tests/test_read_cache.py
 tests/test_response.py
 tests/test_restricted_direct_tables.py
+tests/test_result_returning.py
 tests/test_retry_side_effect_guard.py
 tests/test_return_default_safety.py
 tests/test_row_batch_update.py