velocity-python 0.1.100__tar.gz → 0.1.102__tar.gz

{velocity_python-0.1.100 → velocity_python-0.1.102}/PKG-INFO

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

{velocity_python-0.1.100 → velocity_python-0.1.102}/pyproject.toml

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

{velocity_python-0.1.100 → velocity_python-0.1.102}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.100"
+__version__ = version = "0.1.102"
 
 import importlib as _importlib
 

velocity_python-0.1.102/src/velocity/aws/blobs.py

@@ -0,0 +1,91 @@
+"""Content-addressed S3 blob store.
+
+For offloading large row payloads (raw emails, documents, exports) out of
+Postgres while the row keeps only the content hash. Keys are derived from
+the sha256 of the content, so storage is idempotent and deduplicating by
+construction: the same bytes always land on the same key, and a re-upload
+of an existing object is skipped.
+
+    store = BlobStore("my-bucket", prefix="demo/gmail-raw", suffix=".eml")
+    sha, key = store.put_bytes(raw)      # no-op if already stored
+    raw = store.get_bytes(sha)           # or get_bytes(key)
+    url = store.presigned_get(sha)       # hand-off to a browser
+"""
+
+from __future__ import annotations
+
+import hashlib
+from typing import Optional, Tuple
+
+
+class BlobStore:
+    def __init__(
+        self,
+        bucket: str,
+        prefix: str = "",
+        suffix: str = "",
+        region: Optional[str] = None,
+        client=None,
+    ):
+        if not bucket:
+            raise ValueError("BlobStore requires a bucket name")
+        self.bucket = bucket
+        self.prefix = prefix.strip("/")
+        self.suffix = suffix
+        self.region = region
+        self._client = client
+
+    @property
+    def client(self):
+        if self._client is None:
+            import boto3
+
+            kwargs = {"region_name": self.region} if self.region else {}
+            self._client = boto3.client("s3", **kwargs)
+        return self._client
+
+    def key_for(self, sha256_hex: str) -> str:
+        name = f"{sha256_hex}{self.suffix}"
+        return f"{self.prefix}/{name}" if self.prefix else name
+
+    def _resolve_key(self, sha_or_key: str) -> str:
+        # A bare 64-hex-char sha resolves through key_for; anything else is
+        # treated as a full key (lets callers store either form).
+        value = str(sha_or_key)
+        if len(value) == 64 and all(c in "0123456789abcdef" for c in value.lower()):
+            return self.key_for(value.lower())
+        return value
+
+    def exists(self, sha_or_key: str) -> bool:
+        try:
+            self.client.head_object(
+                Bucket=self.bucket, Key=self._resolve_key(sha_or_key)
+            )
+            return True
+        except Exception:
+            return False
+
+    def put_bytes(self, data: bytes, content_type: Optional[str] = None) -> Tuple[str, str]:
+        """Store ``data`` (idempotent); returns (sha256_hex, key)."""
+        payload = bytes(data or b"")
+        sha = hashlib.sha256(payload).hexdigest()
+        key = self.key_for(sha)
+        if not self.exists(key):
+            params = {"Bucket": self.bucket, "Key": key, "Body": payload}
+            if content_type:
+                params["ContentType"] = content_type
+            self.client.put_object(**params)
+        return sha, key
+
+    def get_bytes(self, sha_or_key: str) -> bytes:
+        response = self.client.get_object(
+            Bucket=self.bucket, Key=self._resolve_key(sha_or_key)
+        )
+        return response["Body"].read()
+
+    def presigned_get(self, sha_or_key: str, expires_seconds: int = 900) -> str:
+        return self.client.generate_presigned_url(
+            "get_object",
+            Params={"Bucket": self.bucket, "Key": self._resolve_key(sha_or_key)},
+            ExpiresIn=expires_seconds,
+        )

{velocity_python-0.1.100 → velocity_python-0.1.102}/src/velocity/aws/handlers/mixins/data_service.py

@@ -15,7 +15,7 @@ import re
 import xml.etree.ElementTree as ET
 from io import BytesIO, StringIO
 
-from velocity.aws import dirty_pipeline
+from velocity.aws import dirty_pipeline, ssm_config
 from velocity.aws.handlers.exceptions import AlertError
 from velocity.db.exceptions import DbDataIntegrityError
 from velocity.misc import export
@@ -48,6 +48,85 @@ def _fk_blocked_delete_message(table, exc):
     )
 
 
+_IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def _bump_sys_id_sequence(tx, table):
+    """Keep the table's serial/identity sequence ahead of MAX(sys_id) so a
+    future auto-generated id can never collide with an explicitly chosen one
+    (renumber, Save-As)."""
+    if not _IDENTIFIER_RE.match(table or ""):
+        raise AlertError(f"'{table}' is not a valid table name.")
+    tx.execute(
+        f"""select setval(s.seq, greatest((select coalesce(max(sys_id), 1) from "{table}"), 1))
+            from (select pg_get_serial_sequence(%s, 'sys_id') as seq) s
+            where s.seq is not null""",
+        (table,),
+    )
+
+
+def renumber_row(tx, table, old_sys_id, new_sys_id, overwrite=False):
+    """Assign a CHOSEN sys_id to an existing row (admin surgery).
+
+    Rules (deliberately simple):
+    - refused when any real foreign-key constraint references this table's
+      sys_id (renumbering under FKs is a cascade problem for another day);
+    - when the target sys_id already exists: refused unless ``overwrite`` —
+      which DELETES the occupying row first;
+    - the table's sys_id sequence is bumped past MAX(sys_id) afterwards so
+      future inserts can never collide with the chosen id.
+
+    Returns "renumbered" on success, or "exists" when the target id is
+    occupied and overwrite was not requested (the caller asks the user).
+    Raises AlertError for every refusal.
+    """
+    if not _IDENTIFIER_RE.match(table or ""):
+        raise AlertError(f"'{table}' is not a valid table name.")
+    try:
+        old_id = int(old_sys_id)
+        new_id = int(new_sys_id)
+    except (TypeError, ValueError):
+        raise AlertError("sys_id values must be integers.")
+    if new_id <= 0:
+        raise AlertError("The new sys_id must be a positive integer.")
+    if new_id == old_id:
+        raise AlertError("That is already this record's sys_id.")
+
+    if not tx.table(table).find(old_id):
+        raise AlertError(f"Record {old_id} was not found in {table}.")
+
+    referencing = tx.execute(
+        """select con.conrelid::regclass::text as referencing_table
+           from pg_constraint con
+           join pg_class rel on rel.oid = con.confrelid
+           join pg_namespace nsp on nsp.oid = rel.relnamespace
+           where con.contype = 'f' and nsp.nspname = 'public'
+             and rel.relname = %s
+           limit 5""",
+        (table,),
+    ).all()
+    if referencing:
+        tables = ", ".join(sorted({r["referencing_table"] for r in referencing}))
+        raise AlertError(
+            f"Renumbering is not allowed: {tables} reference(s) {table} "
+            "through a foreign key. (Denied for now — reassigning "
+            "references is not implemented.)"
+        )
+
+    if tx.table(table).find(new_id):
+        if not overwrite:
+            return "exists"
+        tx.execute(f'DELETE FROM "{table}" WHERE sys_id = %s', (new_id,))
+
+    tx.execute(
+        f'UPDATE "{table}" SET sys_id = %s WHERE sys_id = %s',
+        (new_id, old_id),
+    )
+
+    _bump_sys_id_sequence(tx, table)
+    return "renumbered"
+
+
 class DataServiceMixin:
     """
     Mixin providing generic CRUD operations for Lambda handlers.
@@ -77,6 +156,12 @@ class DataServiceMixin:
     # which DO run hooks — remain the supported path for them.
     restricted_direct_tables = frozenset()
 
+    # Ceiling on rows a single un-paginated `query` may materialize (None =
+    # no cap). Apps set the class attribute; the `QueryMaxRows` config key
+    # overrides it per environment. Promoted 2026-09-04 from BackOffice's
+    # full query_hook override, which existed largely to carry this.
+    query_max_rows = None
+
     # PostgreSQL type mappings for frontend display
     _pg_types = {
         "bool": "string",
@@ -94,6 +179,22 @@ class DataServiceMixin:
         "timestamp": "string",
     }
 
+    def _resolve_query_max_rows(self):
+        """Effective query row ceiling: `QueryMaxRows` config key first, then
+        the class attribute. Returns a positive int or None (no cap)."""
+        raw = None
+        try:
+            raw = ssm_config.getenv("QueryMaxRows", None)
+        except Exception:
+            raw = None
+        if raw in (None, ""):
+            raw = self.query_max_rows
+        try:
+            value = int(raw) if raw not in (None, "") else None
+        except (TypeError, ValueError):
+            return None
+        return value if value and value > 0 else None
+
     def _assert_direct_access_allowed(self, table):
         """Reject hook-bypassing direct access to a restricted table."""
         if table in self.restricted_direct_tables:
@@ -185,7 +286,7 @@ class DataServiceMixin:
             row = row.to_dict()
         return row
 
-    def write_hook(self, tx, table, sys_id, incoming, context):
+    def write_hook(self, tx, table, sys_id, incoming, context, save_as=False):
         row = {}
         incoming.pop("sys_id", None)
         if sys_id == "@new":
@@ -223,9 +324,23 @@ class DataServiceMixin:
             # error rather than a phantom row inserted with a client-chosen PK.
             row = tx.table(table).find(sys_id)
             if not row:
-                raise AlertError(
-                    f"Cannot update {table}: record {sys_id} no longer exists."
+                if not save_as:
+                    raise AlertError(
+                        f"Cannot update {table}: record {sys_id} no longer exists."
+                    )
+                # Save-As: the user explicitly chose this id — claim it, then
+                # fall through to the shared update tail. before_new is skipped
+                # (the data comes from a populated form, not a blank create);
+                # after_new still fires so create-time defaults apply. The
+                # sequence is bumped past MAX(sys_id) so future auto-ids can
+                # never collide with the chosen one.
+                tx.table(table).insert({"sys_id": sys_id})
+                _bump_sys_id_sequence(tx, table)
+                row = tx.table(table).find(sys_id)
+                self._call_rwx_hook(
+                    "after_new", "common", tx, table, sys_id, row, context
                 )
+                self._call_rwx_hook("after_new", table, tx, table, sys_id, row, context)
         else:
             raise Exception("Object sys_id was not supplied on write operation.")
         row.update(incoming)
@@ -436,6 +551,23 @@ class DataServiceMixin:
                     },
                 }
 
+        # Optional ceiling on un-paginated queries: fetch one row past the cap
+        # so truncation is detectable and reportable rather than silent.
+        max_rows = self._resolve_query_max_rows()
+        requested_qty = params.get("qty")
+        try:
+            requested_qty = (
+                int(requested_qty) if requested_qty not in (None, "") else None
+            )
+        except (TypeError, ValueError):
+            requested_qty = None
+        cap_applied = bool(max_rows) and (
+            requested_qty is None or requested_qty > max_rows
+        )
+        if cap_applied:
+            params = dict(params)
+            params["qty"] = max_rows + 1
+
         result = tx.table(obj).select(**params)
 
         swallowed_error = getattr(tx, "_last_return_default_error", None)
@@ -514,6 +646,23 @@ class DataServiceMixin:
                     },
                 }
             )
+        if (
+            cap_applied
+            and isinstance(data.get("rows"), list)
+            and len(data["rows"]) > max_rows
+        ):
+            data["rows"] = data["rows"][:max_rows]
+            truncation = {"truncated": True, "maxRows": max_rows}
+            if isinstance(data.get("config"), dict):
+                data["config"]["truncated"] = truncation
+                context.response().toast(
+                    f"Showing the first {max_rows:,} rows — refine the search "
+                    "or paginate to see the rest.",
+                    "warning",
+                )
+            else:
+                data["truncated"] = truncation
+
         if payload.get("count"):
             data["count"] = tx.table(payload["obj"]).count(
                 where=params.get("where", None)
@@ -640,6 +789,29 @@ class DataServiceMixin:
         if not any(value is not None for value in incoming.values()):
             raise ValueError("Parameter 'object' cannot contain only None values")
 
+        # Save-As: the client chose the target sys_id. When that id is already
+        # taken, answer "exists" so the UI can confirm the overwrite instead of
+        # silently clobbering; with saveAsOverwrite the normal update path
+        # writes the full object onto the existing row. A free id is created
+        # by write_hook (save_as=True).
+        save_as = bool(payload.get("saveAs"))
+        if save_as:
+            target_sys_id = incoming.get("sys_id")
+            if target_sys_id not in (None, "", "@new"):
+                try:
+                    chosen = int(target_sys_id)
+                except (TypeError, ValueError):
+                    raise AlertError("Save-As ID must be a positive integer.")
+                if chosen <= 0:
+                    raise AlertError("Save-As ID must be a positive integer.")
+                if not payload.get("saveAsOverwrite") and tx.table(table_name).find(
+                    chosen
+                ):
+                    context.response().set_body(
+                        {"saveAsStatus": "exists", "sys_id": chosen}
+                    )
+                    return
+
         logger.debug(
             "Writing to table",
             extra={
@@ -656,6 +828,7 @@ class DataServiceMixin:
                 incoming.get("sys_id"),
                 incoming,
                 context,
+                save_as=save_as,
             )
 
             if not row:
@@ -964,6 +1137,42 @@ class DataServiceMixin:
         if not deleteList:
             context.response().toast("No items were selected.", "warning")
 
+    def OnActionRenumberObject(self, tx, context):
+        """Assign a chosen sys_id to one row.
+
+        Payload: tableName, sys_id (current), new_sys_id, overwrite (bool).
+        Responds {status: "exists"} when the target id is occupied and
+        overwrite was not requested; on success reloads the renumbered row
+        into the form (load-object) and reports the change.
+        """
+        payload = context.payload()
+        for field in ("tableName", "sys_id", "new_sys_id"):
+            if field not in payload:
+                raise ValueError(f"Missing required parameter '{field}' in payload")
+        table = payload["tableName"]
+        self._assert_direct_access_allowed(table)
+
+        result = renumber_row(
+            tx,
+            table,
+            payload["sys_id"],
+            payload["new_sys_id"],
+            overwrite=bool(payload.get("overwrite")),
+        )
+        if result == "exists":
+            context.response().set_body(
+                {"status": "exists", "new_sys_id": payload["new_sys_id"]}
+            )
+            return
+
+        row = tx.table(table).find(int(payload["new_sys_id"]))
+        context.response().set_body({"status": "renumbered", "object": dict(row)})
+        context.response().load_object(dict(row))
+        context.response().toast(
+            f"Record renumbered: {payload['sys_id']} → {payload['new_sys_id']}.",
+            "success",
+        )
+
     def OnActionGetTables(self, tx, context):
         """Get list of all tables in the database."""
         context.response().set_body({"tables": tx.tables()})

{velocity_python-0.1.100 → velocity_python-0.1.102}/src/velocity/aws/handlers/response.py

@@ -36,9 +36,16 @@ class Response:
         """
         Finalize the response body as JSON and return the complete response dictionary.
 
+        When a raw body has been set via :meth:`set_raw_body`, it is returned
+        verbatim (no JSON encoding, no actions envelope) — the escape hatch
+        for non-JSON responses like TwiML or plain text.
+
         Returns:
-            Dict[str, Any]: The complete HTTP response with headers, status code, and JSON body.
+            Dict[str, Any]: The complete HTTP response with headers, status code, and body.
         """
+        if getattr(self, "_raw_body", None) is not None:
+            self.raw["body"] = self._raw_body
+            return self.raw
         if self.actions:
             self.body["actions"] = self.actions
         if self.jobs.events:
@@ -46,6 +53,25 @@ class Response:
         self.raw["body"] = to_json(self.body)
         return self.raw
 
+    def set_raw_body(self, body: str, content_type: str = "text/plain") -> "Response":
+        """
+        Send a non-JSON body verbatim (e.g. TwiML, plain text, XML).
+
+        Bypasses the JSON envelope entirely: render() returns this body
+        unencoded and skips actions/jobs. Added 2026-09-04 — apps previously
+        had to override serve() to do this.
+
+        Args:
+            body (str): The exact body string to return.
+            content_type (str): Content-Type header value. Defaults to "text/plain".
+
+        Returns:
+            Response: The current Response object, allowing method chaining.
+        """
+        self._raw_body = body
+        self.raw["headers"]["Content-Type"] = content_type
+        return self
+
     def alert(self, message: str, title: str = "Notification") -> "Response":
         """
         Add an alert action to the response.

{velocity_python-0.1.100 → velocity_python-0.1.102}/src/velocity/aws/ssm_config.py

@@ -122,6 +122,15 @@ def get_stage(default: Optional[str] = None) -> Optional[str]:
     return _first_nonempty_env(*_STAGE_ENV_KEYS) or default
 
 
+def is_production() -> bool:
+    """True when the resolved stage is the production branch.
+
+    The missing primitive behind six per-app ``runtime_config`` copies: apps
+    kept re-wrapping :func:`get_stage` just to ask this one question.
+    """
+    return (get_stage() or "").strip().lower() == "production"
+
+
 def get_region(default: Optional[str] = "us-east-1") -> Optional[str]:
     return _first_nonempty_env("AWS_REGION", "REGION", "USER_REGION") or default
 

{velocity_python-0.1.100 → velocity_python-0.1.102}/src/velocity/payment/braintree_adapter.py

@@ -14,6 +14,8 @@ Key Features:
 - Authorization with later capture support
 """
 
+import time
+
 import braintree
 from typing import Dict, Any, Optional
 from datetime import datetime, timezone, timedelta
@@ -66,6 +68,33 @@ class BraintreeAdapter(PaymentProcessorAdapter):
         self.environment = environment_name
         self.platform = config.get("platform")
 
+    def generate_client_token(
+        self,
+        customer_id: Optional[str] = None,
+        attempts: int = 3,
+        backoff_seconds: float = 0.25,
+    ) -> str:
+        """Generate a Braintree client token, retrying transient failures.
+
+        The retry policy lives here, once — apps were hand-rolling identical
+        backoff loops around raw ``client_token.generate()`` calls (promoted
+        2026-09-04 from DonateMain / BackOffice copies).
+        """
+        params: Dict[str, Any] = {"customer_id": customer_id} if customer_id else {}
+        last_exc: Optional[Exception] = None
+        for attempt in range(max(1, attempts)):
+            try:
+                return self.gateway.client_token.generate(params)
+            except Exception as exc:
+                last_exc = exc
+                if attempt < attempts - 1:
+                    time.sleep(backoff_seconds * (attempt + 1))
+        raise ProcessorError(
+            "braintree",
+            "client_token_unavailable",
+            f"Client token unavailable after {attempts} attempts: {last_exc}",
+        ) from last_exc
+
     # ========================================================================
     # ACCOUNT MANAGEMENT
     # ========================================================================

{velocity_python-0.1.100 → velocity_python-0.1.102}/src/velocity/payment/stripe_adapter.py

@@ -853,6 +853,155 @@ class StripeAdapter(PaymentProcessorAdapter):
                 metadata={"charge_id": processor_charge_id},
             )
 
+    # ========================================================================
+    # CHECKOUT SESSIONS (hosted payment page)
+    # ========================================================================
+
+    def create_checkout_session(
+        self, tx, session_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Create a hosted Stripe Checkout Session for a one-off payment.
+
+        The buyer is redirected to Stripe's hosted page, so the application
+        never touches card data (minimal PCI scope). Works on a direct
+        account by default; pass ``processor_account_id`` (and optionally
+        ``application_fee_amount``) for a Connect destination charge.
+
+        Args:
+            tx: Database transaction (reserved for mirror hooks; may be None)
+            session_data: Dictionary containing:
+                - amount: Amount in cents (required)
+                - name: Line-item name shown on the Stripe page (required)
+                - success_url: Redirect after payment (required; include
+                  ``{CHECKOUT_SESSION_ID}`` to receive the session id back)
+                - cancel_url: Redirect when the buyer backs out (required)
+                - currency: default 'usd'
+                - customer_email: prefills the Stripe page (optional)
+                - metadata: dict stamped on session AND payment intent
+                - processor_account_id / application_fee_amount: Connect only
+                - idempotency_key: collapses double-submits (optional)
+
+        Returns:
+            {"success": True, "session_id", "url", "status", "payment_status"}
+        """
+        del tx  # no mirror writes at create time; nothing has settled yet
+        try:
+            metadata = dict(session_data.get("metadata") or {})
+            metadata.setdefault("environment", self.environment)
+            if self.platform:
+                metadata.setdefault("platform", str(self.platform))
+
+            params: Dict[str, Any] = {
+                "mode": "payment",
+                "line_items": [
+                    {
+                        "quantity": 1,
+                        "price_data": {
+                            "currency": session_data.get("currency", "usd"),
+                            "unit_amount": int(session_data["amount"]),
+                            "product_data": {"name": session_data["name"]},
+                        },
+                    }
+                ],
+                "success_url": session_data["success_url"],
+                "cancel_url": session_data["cancel_url"],
+                "metadata": metadata,
+                "payment_intent_data": {"metadata": metadata},
+                "api_key": self._api_key,
+            }
+            if session_data.get("customer_email"):
+                params["customer_email"] = session_data["customer_email"]
+            processor_account_id = session_data.get("processor_account_id")
+            if processor_account_id:
+                transfer: Dict[str, Any] = {
+                    "transfer_data": {"destination": processor_account_id}
+                }
+                fee = session_data.get("application_fee_amount")
+                if fee is not None:
+                    transfer["application_fee_amount"] = int(fee)
+                params["payment_intent_data"] = {
+                    **params["payment_intent_data"],
+                    **transfer,
+                }
+            idempotency_key = session_data.get("idempotency_key")
+            if idempotency_key:
+                params["idempotency_key"] = str(idempotency_key)
+
+            session = stripe.checkout.Session.create(**params)
+            return {
+                "success": True,
+                "session_id": session.id,
+                "url": session.url,
+                "status": session.status,
+                "payment_status": session.payment_status,
+            }
+        except KeyError as e:
+            raise ProcessorError(
+                processor="stripe",
+                error_code="missing_field",
+                error_message=f"checkout session requires {e}",
+                metadata={},
+            )
+        except stripe.error.StripeError as e:
+            raise ProcessorError(
+                processor="stripe",
+                error_code=getattr(e, "code", None) or "unknown",
+                error_message=str(e),
+                metadata={},
+            )
+
+    def retrieve_checkout_session(self, tx, session_id: str) -> Dict[str, Any]:
+        """
+        Retrieve a Checkout Session and report whether it is paid.
+
+        Server-side verification for the success redirect: the client hands
+        back only the session id; the truth (``payment_status``) comes from
+        Stripe. A settled session's PaymentIntent artifacts are mirrored
+        when a transaction is supplied.
+
+        Returns:
+            {"success": True, "session_id", "status", "payment_status",
+             "paid": bool, "amount_total", "currency",
+             "payment_intent_id", "customer_email", "metadata"}
+        """
+        try:
+            # latest_charge stays an ID on purpose: the mirror helper
+            # re-retrieves it with balance_transaction expanded (real fees).
+            session = stripe.checkout.Session.retrieve(
+                session_id,
+                expand=["payment_intent"],
+                api_key=self._api_key,
+            )
+            payment_intent = session.payment_intent
+            paid = session.payment_status == "paid"
+            if paid and tx is not None and payment_intent is not None:
+                self._mirror_payment_intent_artifacts(
+                    tx,
+                    payment_intent,
+                    source="api:stripe_adapter.retrieve_checkout_session",
+                )
+            details = session.get("customer_details") or {}
+            return {
+                "success": True,
+                "session_id": session.id,
+                "status": session.status,
+                "payment_status": session.payment_status,
+                "paid": paid,
+                "amount_total": session.amount_total,
+                "currency": session.currency,
+                "payment_intent_id": getattr(payment_intent, "id", payment_intent),
+                "customer_email": session.get("customer_email") or details.get("email"),
+                "metadata": dict(session.metadata or {}),
+            }
+        except stripe.error.StripeError as e:
+            raise ProcessorError(
+                processor="stripe",
+                error_code=getattr(e, "code", None) or "unknown",
+                error_message=str(e),
+                metadata={"session_id": session_id},
+            )
+
     # ========================================================================
     # UTILITY METHODS
     # ========================================================================

{velocity_python-0.1.100 → velocity_python-0.1.102}/src/velocity_python.egg-info/PKG-INFO

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