velocity-python 0.1.107__tar.gz → 0.1.109__tar.gz

{velocity_python-0.1.107 → velocity_python-0.1.109}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.107
+Version: 0.1.109
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -251,6 +251,7 @@ Full documentation is included in the `docs/` directory of the source distributi
 | Async Support | `docs/async.md` | AsyncTransaction, AsyncTable, AsyncResult, parallel queries with gather() |
 | 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 |
 | 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.107 → velocity_python-0.1.109}/README.md

@@ -157,6 +157,7 @@ Full documentation is included in the `docs/` directory of the source distributi
 | Async Support | `docs/async.md` | AsyncTransaction, AsyncTable, AsyncResult, parallel queries with gather() |
 | 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 |
 | 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.107 → velocity_python-0.1.109}/pyproject.toml

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

{velocity_python-0.1.107 → velocity_python-0.1.109}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.107"
+__version__ = version = "0.1.109"
 
 import importlib as _importlib
 

{velocity_python-0.1.107 → velocity_python-0.1.109}/src/velocity/aws/capabilities/__init__.py

@@ -20,6 +20,7 @@ from .base import (  # noqa: F401
     load_config,
     policy_field,
     resolve_config,
+    summarize_policy,
     validate_policy,
 )
 from .dispatch import (  # noqa: F401
@@ -52,6 +53,7 @@ __all__ = [
     "provision",
     "resolve_config",
     "run_capability",
+    "summarize_policy",
     "trigger_key",
     "validate_policy",
     "NIGHTLY",

{velocity_python-0.1.107 → velocity_python-0.1.109}/src/velocity/aws/capabilities/base.py

@@ -161,6 +161,54 @@ def load_config(raw) -> dict:
     return value
 
 
+def summarize_policy(name, config, *, max_items=3) -> str:
+    """One line a list can show for a row's policy — "Tables: aws_api_activity
+    7d, filebuffer 14d · IP deny list: 2" — built from the declared fields so
+    it reads the same for every capability. Empty string for an empty policy;
+    undeclared keys are counted, not shown."""
+    cap = REGISTRY.get(name)
+    try:
+        config = load_config(config)
+    except ValueError:
+        return "invalid JSON"
+    if cap is None or not config:
+        return ""
+    parts = []
+    declared = set()
+    for field in cap.policy:
+        declared.add(field["name"])
+        value = config.get(field["name"])
+        if value in (None, "", [], {}):
+            continue
+        parts.append(f"{field['label']}: {_brief(field, value, max_items)}")
+    extra = len([key for key in config if key not in declared])
+    if extra:
+        parts.append(f"+{extra} other key{'s' if extra > 1 else ''}")
+    return " · ".join(parts)
+
+
+def _brief(field, value, max_items):
+    kind = field["kind"]
+    if kind == TABLE_DAYS and isinstance(value, dict):
+        items = [
+            f"{table} {days}d" if days not in (None, "", 0) else f"{table} (default)"
+            for table, days in value.items()
+        ]
+        return _clip(items, max_items)
+    if kind in (CIDR_LIST, COUNTRY_LIST, LIST) and isinstance(value, (list, tuple)):
+        return _clip([str(v) for v in value], max_items)
+    if kind == BOOLEAN:
+        return "on" if str(value).lower() in ("true", "1", "yes", "on") else "off"
+    text = str(value)
+    return text if len(text) <= 40 else text[:37] + "..."
+
+
+def _clip(items, max_items):
+    if len(items) <= max_items:
+        return ", ".join(items)
+    return ", ".join(items[:max_items]) + f" (+{len(items) - max_items} more)"
+
+
 def validate_policy(name, config) -> list:
     """Check a site's ``config`` against the capability's declared policy.
 

{velocity_python-0.1.107 → velocity_python-0.1.109}/src/velocity/aws/capabilities/security.py

@@ -66,7 +66,9 @@ _cache: dict = {}
 
 
 def clear_cache():
+    """Forget the cached site row AND the shared flags row (tests)."""
     _cache.clear()
+    feature_flags.clear_cache()
 
 
 # ── request facts ───────────────────────────────────────────────────────
@@ -201,7 +203,10 @@ def _site_row(tx):
 
 
 def _flags(tx):
-    return _cached(("flags",), lambda: feature_flags.get(tx))
+    """The stage's flags row from velocity's container cache — shared with
+    the handler context and session control, so the guards add no read of
+    their own to a request."""
+    return feature_flags.get_cached(tx)
 
 
 def _row_config(row) -> dict:

{velocity_python-0.1.107 → velocity_python-0.1.109}/src/velocity/aws/feature_flags.py

@@ -23,19 +23,31 @@ carries one row per stage and each environment reads its own; the alternate
 database name comes from config (:data:`ALTERNATE_DB_CONFIG_KEY`). (An app that
 one day consolidates several systems into one database can widen the key then;
 today the stage is the whole identity.)
+
+The mirroring itself is the generic :mod:`velocity.aws.mirror` (any table,
+any natural key, optional foreign-key translation); this module is that
+mechanism applied to the flags table, keyed by ``applied_system``.
 """
 
 from __future__ import annotations
 
 import logging
+import time
+
+from velocity.aws import mirror as _mirror
 
 log = logging.getLogger(__name__)
 
 SYSTEM_COLUMN = "applied_system"
 DEFAULT_TABLE = "sys_feature_flags"
-ALTERNATE_DB_CONFIG_KEY = "DBAlternate"
+ALTERNATE_DB_CONFIG_KEY = _mirror.ALTERNATE_DB_CONFIG_KEY
+# how long a warm container may reuse the flags row before re-reading it
+CACHE_SECONDS_CONFIG_KEY = "FeatureFlagCacheSeconds"
+DEFAULT_CACHE_SECONDS = 60
 
-_alternate_engines: dict = {}
+_alternate_engines = _mirror._alternate_engines
+_cache: dict = {}  # (system, table) -> (expires_at, row)
+_cache_seconds: float | None = None
 
 
 def current_system(default: str | None = None) -> str | None:
@@ -68,20 +80,76 @@ def get(
     return dict(row)
 
 
+def cache_seconds() -> float:
+    """Seconds a warm container may reuse the flags row: the
+    ``FeatureFlagCacheSeconds`` config key, default 60; ``0`` reads the row
+    on every call. Resolved once per container."""
+    global _cache_seconds
+    if _cache_seconds is None:
+        raw = None
+        try:
+            from velocity.aws import ssm_config
+
+            raw = ssm_config.getenv(CACHE_SECONDS_CONFIG_KEY, None)
+        except Exception:
+            raw = None
+        try:
+            _cache_seconds = (
+                float(raw) if raw not in (None, "") else float(DEFAULT_CACHE_SECONDS)
+            )
+        except (TypeError, ValueError):
+            _cache_seconds = float(DEFAULT_CACHE_SECONDS)
+    return _cache_seconds
+
+
+def clear_cache() -> None:
+    """Forget cached rows (after a local flags write; tests)."""
+    global _cache_seconds
+    _cache.clear()
+    _cache_seconds = None
+
+
+def get_cached(
+    tx, system: str | None = None, *, table: str = DEFAULT_TABLE, now: float | None = None
+) -> dict:
+    """:func:`get` behind a per-container TTL cache — the hot-path reader.
+
+    The flags row is ONE row per stage, and every reader in a request
+    (the handler context, the security guards, session control, any
+    capability knob) wants the same one: this makes it at most one read per
+    :func:`cache_seconds` per container, however many readers there are. A
+    flag saved through the mirror hook clears the local cache, so the
+    environment that made the change sees it at once; the other environment
+    sees it within the TTL.
+    """
+    system = system if system is not None else current_system()
+    ttl = cache_seconds()
+    if ttl <= 0:
+        return get(tx, system, table=table)
+    now = time.monotonic() if now is None else now
+    key = (system, table)
+    hit = _cache.get(key)
+    if hit and hit[0] > now:
+        return dict(hit[1])
+    row = get(tx, system, table=table)
+    _cache[key] = (now + ttl, dict(row))
+    return dict(row)
+
+
 def load(tx, loader=None) -> dict:
     """The request-time flag source used by handler contexts.
 
     An injected ``loader(tx)`` wins (apps that resolve flags their own way);
-    otherwise :func:`get` — velocity's stage-scoped reader — is the source,
-    never raising into the request. The legacy CaringCent
-    ``support.app.helpers`` loader remains only as a last resort when the
-    velocity reader finds no row (it raises on a missing row, which those
-    apps rely on); absent that package the answer is ``{}``.
+    otherwise :func:`get_cached` — velocity's stage-scoped reader behind the
+    container cache — is the source, never raising into the request. The
+    legacy CaringCent ``support.app.helpers`` loader remains only as a last
+    resort when the velocity reader finds no row (it raises on a missing
+    row, which those apps rely on); absent that package the answer is ``{}``.
     """
     if callable(loader):
         return loader(tx)
     try:
-        flags = get(tx)
+        flags = get_cached(tx)
     except Exception:
         flags = {}
     if flags:
@@ -101,28 +169,13 @@ def _legacy_support_loader(tx):
     return helpers.get_feature_flags(tx)
 
 
-def _without_sys(row) -> dict:
-    """A row's business columns — the ``sys_*`` bookkeeping never crosses over."""
-    return {k: v for k, v in dict(row).items() if not str(k).startswith("sys_")}
+_without_sys = _mirror.business_columns
+_toast = _mirror.toast
 
 
 def alternate_engine(alternate_db: str | None = None):
-    """Engine for the alternate database — same instance, other ``database``.
-
-    Host/port/user/password are inherited from the running config, so no
-    separate credentials are needed; only the database name changes. Cached per
-    database name so repeated mirrors in one process reuse the connection.
-    """
-    from velocity.aws import ssm_config
-    from velocity.db.servers import postgres
-
-    if alternate_db is None:
-        alternate_db = ssm_config.getenv(ALTERNATE_DB_CONFIG_KEY, raise_on_missing=True)
-    if alternate_db not in _alternate_engines:
-        _alternate_engines[alternate_db] = postgres.initialize(
-            {"database": alternate_db}
-        )
-    return _alternate_engines[alternate_db]
+    """Engine for the alternate database — see :func:`velocity.aws.mirror.alternate_engine`."""
+    return _mirror.alternate_engine(alternate_db)
 
 
 def mirror_row(
@@ -133,14 +186,9 @@ def mirror_row(
     Returns the mirrored key, or ``None`` when the row has no system key (a
     keyless row is skipped, never mirrored to an arbitrary target).
     """
-    data = _without_sys(row)
-    key = data.get(SYSTEM_COLUMN)
-    if not key:
-        return None
     engine = engine or alternate_engine(alternate_db)
-    with engine.transaction() as alt:
-        alt.table(table).merge(data, pk={SYSTEM_COLUMN: key})
-    return key
+    pk = _mirror.mirror_row(row, table=table, key=(SYSTEM_COLUMN,), engine=engine)
+    return pk[SYSTEM_COLUMN] if pk else None
 
 
 def reconcile(
@@ -149,27 +197,11 @@ def reconcile(
     """Mirror every flags row into the alternate database. Catch-up companion of
     :func:`mirror_row`. Returns ``{"synced": [...], "skipped": [...]}``."""
     engine = engine or alternate_engine(alternate_db)
-    synced: list = []
-    skipped: list = []
-    rows = list(tx.table(table).select())
-    with engine.transaction() as alt:
-        for row in rows:
-            data = _without_sys(row)
-            key = data.get(SYSTEM_COLUMN)
-            if not key:
-                skipped.append(dict(row).get("sys_id"))
-                continue
-            alt.table(table).merge(data, pk={SYSTEM_COLUMN: key})
-            synced.append(key)
-    return {"synced": synced, "skipped": skipped}
-
-
-def _toast(context, message: str, level: str) -> None:
-    """Best-effort operator toast; a context without one is fine (a queue run)."""
-    response = getattr(context, "response", None)
-    toast = getattr(response() if callable(response) else None, "toast", None)
-    if callable(toast):
-        toast(message, level)
+    result = _mirror.reconcile(tx, table=table, key=(SYSTEM_COLUMN,), engine=engine)
+    return {
+        "synced": [pk[SYSTEM_COLUMN] for pk in result["synced"]],
+        "skipped": result["skipped"],
+    }
 
 
 def make_mirror_hook(
@@ -187,6 +219,7 @@ def make_mirror_hook(
 
     def hook(tx, table_name, sys_id, row, context):
         del tx, table_name, sys_id
+        clear_cache()  # the row just changed here: this container re-reads it
         try:
             key = mirror_row(row, alternate_db=alternate_db, table=table)
             if notify and key:

{velocity_python-0.1.107 → velocity_python-0.1.109}/src/velocity/aws/handlers/mixins/session_control.py

@@ -120,14 +120,15 @@ class SessionControlMixin:
     # ── switch resolution ────────────────────────────────────────────────
     def _session_flags(self, tx):
         """The stage's feature flags (the `single_session` capability's
-        knobs) — {} when there is no tx or no flags table, so sessions never
-        depend on the flag row existing."""
+        knobs) from velocity's container cache — no read of their own per
+        heartbeat; {} when there is no tx or no flags table, so sessions
+        never depend on the flag row existing."""
         if tx is None:
             return {}
         try:
             from velocity.aws import feature_flags
 
-            return feature_flags.get(tx) or {}
+            return feature_flags.get_cached(tx) or {}
         except Exception:
             return {}
 

velocity_python-0.1.109/src/velocity/aws/mirror.py

@@ -0,0 +1,267 @@
+"""Cross-database row mirroring: one table, two databases on the same
+instance (demo <-> production), rows kept identical no matter where the
+edit happened.
+
+Generalised from the feature-flag mirror (:mod:`velocity.aws.feature_flags`
+now delegates here). A row crosses over by its **natural key** — the columns
+that identify it in either database (``applied_system`` for flags;
+``site_sys_id, env_name, capability`` for site capabilities) — never by
+``sys_id``, which differs per database; ``sys_*`` bookkeeping never crosses.
+
+Foreign keys whose ids differ between databases are the caller's to
+translate: ``translate(tx, alt, data)`` rewrites the outgoing row for the
+alternate database (map a site by its slug, say) or raises
+:class:`MirrorSkip` with the reason the row cannot cross — surfaced to the
+operator as a warning, never an error: the local save always stands.
+
+Writes into the alternate database go straight through the table API (no
+handler, no rwx hooks), so a mirror never triggers a mirror back. The hooks
+are warn-and-continue; :func:`reconcile` is the catch-up once an unreachable
+alternate is back.
+"""
+
+from __future__ import annotations
+
+import logging
+
+log = logging.getLogger(__name__)
+
+ALTERNATE_DB_CONFIG_KEY = "DBAlternate"
+SYS_PREFIX = "sys_"
+
+_alternate_engines: dict = {}
+
+
+class MirrorSkip(Exception):
+    """Raised by a ``translate`` to say this row cannot cross, and why."""
+
+
+def alternate_engine(alternate_db: str | None = None):
+    """Engine for the alternate database — same instance, other ``database``.
+
+    Host/port/user/password are inherited from the running config, so no
+    separate credentials are needed; only the database name changes (the
+    ``DBAlternate`` config key by default). Cached per database name so
+    repeated mirrors in one process reuse the connection.
+    """
+    from velocity.aws import ssm_config
+    from velocity.db.servers import postgres
+
+    if alternate_db is None:
+        alternate_db = ssm_config.getenv(ALTERNATE_DB_CONFIG_KEY, raise_on_missing=True)
+    if alternate_db not in _alternate_engines:
+        _alternate_engines[alternate_db] = postgres.initialize(
+            {"database": alternate_db}
+        )
+    return _alternate_engines[alternate_db]
+
+
+def business_columns(row) -> dict:
+    """A row's business columns — the ``sys_*`` bookkeeping never crosses over."""
+    return {k: v for k, v in dict(row).items() if not str(k).startswith(SYS_PREFIX)}
+
+
+def natural_key(data, key) -> dict | None:
+    """``{column: value}`` for the key columns, or None when any is unset — a
+    keyless row is skipped, never mirrored onto an arbitrary target."""
+    pk = {}
+    for column in key:
+        value = data.get(column)
+        if value in (None, ""):
+            return None
+        pk[column] = value
+    return pk
+
+
+def _outgoing(tx, alt, row, key, translate):
+    data = business_columns(row)
+    if translate is not None:
+        data = translate(tx, alt, data)
+        if data is None:
+            return None, None
+    return data, natural_key(data, key)
+
+
+def mirror_row(
+    row,
+    *,
+    table: str,
+    key,
+    alternate_db: str | None = None,
+    engine=None,
+    translate=None,
+    tx=None,
+) -> dict | None:
+    """Upsert one row into the alternate database by its natural key.
+
+    Returns the key used, or None when the row was skipped (keyless, or
+    ``translate`` returned None). A ``MirrorSkip`` from ``translate``
+    propagates — the hooks turn it into a warning for the operator.
+    """
+    engine = engine or alternate_engine(alternate_db)
+    with engine.transaction() as alt:
+        data, pk = _outgoing(tx, alt, row, key, translate)
+        if pk is None:
+            return None
+        alt.table(table).merge(data, pk=pk)
+    return pk
+
+
+def delete_mirror(
+    row,
+    *,
+    table: str,
+    key,
+    alternate_db: str | None = None,
+    engine=None,
+    translate=None,
+    tx=None,
+) -> dict | None:
+    """Delete the row's counterpart in the alternate database (by natural
+    key). Same skip/return contract as :func:`mirror_row`."""
+    engine = engine or alternate_engine(alternate_db)
+    with engine.transaction() as alt:
+        data, pk = _outgoing(tx, alt, row, key, translate)
+        if pk is None:
+            return None
+        alt.table(table).delete(pk)
+    return pk
+
+
+def reconcile(
+    tx,
+    *,
+    table: str,
+    key,
+    alternate_db: str | None = None,
+    engine=None,
+    translate=None,
+) -> dict:
+    """Mirror every row of ``table`` into the alternate database — the
+    catch-up companion of :func:`mirror_row` (after the alternate was
+    unreachable, or for a fresh environment). One-way: rows that exist only
+    in the alternate are left alone. Returns ``{"synced": [keys],
+    "skipped": [sys_ids]}``."""
+    engine = engine or alternate_engine(alternate_db)
+    synced: list = []
+    skipped: list = []
+    rows = list(tx.table(table).select())
+    with engine.transaction() as alt:
+        for row in rows:
+            try:
+                data, pk = _outgoing(tx, alt, row, key, translate)
+            except MirrorSkip:
+                pk = None
+            if pk is None:
+                skipped.append(dict(row).get("sys_id"))
+                continue
+            alt.table(table).merge(data, pk=pk)
+            synced.append(pk)
+    return {"synced": synced, "skipped": skipped}
+
+
+def toast(context, message: str, level: str) -> None:
+    """Best-effort operator toast; a context without one is fine (a queue run)."""
+    response = getattr(context, "response", None)
+    toaster = getattr(response() if callable(response) else None, "toast", None)
+    if callable(toaster):
+        toaster(message, level)
+
+
+def _run(operation, context, what, verbs, notify):
+    """Run one mirror operation warn-and-continue; tell the operator."""
+    done, undone = verbs
+    try:
+        pk = operation()
+    except MirrorSkip as skip:
+        log.warning("%s not %s the alternate database: %s", what, done, skip)
+        if notify:
+            toast(context, f"{what} {undone} the alternate database: {skip}.", "warning")
+        return None
+    except Exception as exc:  # never block the local write
+        log.warning("%s: mirror to the alternate database failed", what, exc_info=True)
+        if notify:
+            toast(
+                context,
+                f"{what} {undone} the alternate database ({exc}). Run the "
+                "reconcile once it is reachable.",
+                "warning",
+            )
+        return None
+    if pk is None:
+        return None  # keyless (an after_new stub, say): nothing to mirror
+    if notify:
+        toast(context, f"{what} {done} the alternate database.", "success")
+    return pk
+
+
+def make_mirror_hook(
+    *,
+    table: str,
+    key,
+    alternate_db: str | None = None,
+    translate=None,
+    notify: bool = True,
+    label: str | None = None,
+):
+    """An RWX ``after_write`` (or ``after_new``) callable that mirrors the
+    saved row. The app's ``rwx/<table>.py`` is a registration line; the
+    logic stays here."""
+    what = label or table
+
+    def hook(tx, table_name, sys_id, row, context):
+        del table_name, sys_id
+        return _run(
+            lambda: mirror_row(
+                row,
+                table=table,
+                key=key,
+                alternate_db=alternate_db,
+                translate=translate,
+                tx=tx,
+            ),
+            context,
+            what,
+            ("mirrored to", "saved here but not mirrored to"),
+            notify,
+        )
+
+    return hook
+
+
+def make_delete_hook(
+    *,
+    table: str,
+    key,
+    alternate_db: str | None = None,
+    translate=None,
+    notify: bool = True,
+    label: str | None = None,
+):
+    """An RWX ``before_delete`` callable that removes the row's counterpart.
+    ``before`` because the row must still exist here to read its natural
+    key; the local delete proceeds whatever happens on the other side."""
+    what = label or table
+
+    def hook(tx, table_name, sys_id, context):
+        if tx is None:
+            return None
+        row = tx.table(table_name).find({"sys_id": sys_id})
+        if not row:
+            return None
+        return _run(
+            lambda: delete_mirror(
+                row,
+                table=table,
+                key=key,
+                alternate_db=alternate_db,
+                translate=translate,
+                tx=tx,
+            ),
+            context,
+            what,
+            ("removed from", "deleted here but not removed from"),
+            notify,
+        )
+
+    return hook

{velocity_python-0.1.107 → velocity_python-0.1.109}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.107
+Version: 0.1.109
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -251,6 +251,7 @@ Full documentation is included in the `docs/` directory of the source distributi
 | Async Support | `docs/async.md` | AsyncTransaction, AsyncTable, AsyncResult, parallel queries with gather() |
 | 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 |
 | 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.107 → velocity_python-0.1.109}/src/velocity_python.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/velocity/aws/email.py
 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/s3.py
 src/velocity/aws/sms.py
 src/velocity/aws/ssm_config.py
@@ -242,6 +243,7 @@ tests/test_lambda_handler.py
 tests/test_lambda_handler_auth.py
 tests/test_lambda_handler_masquerade.py
 tests/test_masquerade_grant.py
+tests/test_mirror.py
 tests/test_mixins_import.py
 tests/test_n_plus_one.py
 tests/test_nosql_dynamodb.py