velocity-python 0.1.99__tar.gz → 0.1.101__tar.gz

{velocity_python-0.1.99 → velocity_python-0.1.101}/PKG-INFO

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

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

{velocity_python-0.1.99 → velocity_python-0.1.101}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.99"
+__version__ = version = "0.1.101"
 
 import importlib as _importlib
 

velocity_python-0.1.101/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.99 → velocity_python-0.1.101}/src/velocity/aws/handlers/mixins/data_service.py

@@ -442,6 +442,20 @@ class DataServiceMixin:
         if swallowed_error:
             tx._last_return_default_error = None
 
+        # A missing table under UNLOCKED auto-schema is a legitimate empty
+        # state, not an error: velocity creates tables on first write, so a
+        # table nothing has written to yet (user_data on a fresh site / for a
+        # new user) is simply empty — answer quietly instead of toasting a
+        # scary "relation does not exist" at the user. Under a LOCKED schema
+        # (production) tables exist only via ensure_schema, so a missing one
+        # is a real deploy bug and stays loud.
+        if (
+            swallowed_error
+            and swallowed_error.get("type") == "DbTableMissingError"
+            and not tx.engine.schema_locked
+        ):
+            swallowed_error = None
+
         _file_export_formats = {
             "excel",
             "csv",

{velocity_python-0.1.99 → velocity_python-0.1.101}/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.99 → velocity_python-0.1.101}/src/velocity_python.egg-info/PKG-INFO

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

@@ -6,6 +6,7 @@ src/velocity/logging.py
 src/velocity/aws/__init__.py
 src/velocity/aws/amplify.py
 src/velocity/aws/amplify_build.py
+src/velocity/aws/blobs.py
 src/velocity/aws/dirty_pipeline.py
 src/velocity/aws/email.py
 src/velocity/aws/job_results.py
@@ -195,6 +196,7 @@ tests/test_asset_references.py
 tests/test_assets_service.py
 tests/test_async_support.py
 tests/test_batch_operations.py
+tests/test_blob_store.py
 tests/test_column_tx_arg.py
 tests/test_concurrency_safety.py
 tests/test_connection_pool.py
@@ -239,6 +241,7 @@ tests/test_pdf.py
 tests/test_prepared_statements.py
 tests/test_psycopg3_upgrade.py
 tests/test_query_cache.py
+tests/test_query_missing_table_unlocked.py
 tests/test_restricted_direct_tables.py
 tests/test_retry_side_effect_guard.py
 tests/test_return_default_safety.py

velocity_python-0.1.101/tests/test_blob_store.py

@@ -0,0 +1,64 @@
+"""Content-addressed BlobStore: idempotent puts, sha/key duality."""
+
+import hashlib
+import unittest
+from unittest.mock import MagicMock
+
+from velocity.aws.blobs import BlobStore
+
+
+def make_client(existing_keys=()):
+    client = MagicMock()
+    existing = set(existing_keys)
+
+    def head_object(Bucket, Key):
+        if Key in existing:
+            return {}
+        raise Exception("404")
+
+    client.head_object.side_effect = head_object
+    return client
+
+
+PAYLOAD = b"raw email bytes"
+SHA = hashlib.sha256(PAYLOAD).hexdigest()
+
+
+class TestBlobStore(unittest.TestCase):
+    def test_put_is_content_addressed_and_uploads_once(self):
+        client = make_client()
+        store = BlobStore("bkt", prefix="demo/gmail-raw", suffix=".eml", client=client)
+        sha, key = store.put_bytes(PAYLOAD)
+        self.assertEqual(sha, SHA)
+        self.assertEqual(key, f"demo/gmail-raw/{SHA}.eml")
+        client.put_object.assert_called_once()
+        self.assertEqual(client.put_object.call_args.kwargs["Key"], key)
+
+    def test_put_skips_upload_when_object_exists(self):
+        key = f"demo/gmail-raw/{SHA}.eml"
+        client = make_client(existing_keys=[key])
+        store = BlobStore("bkt", prefix="demo/gmail-raw", suffix=".eml", client=client)
+        sha, got_key = store.put_bytes(PAYLOAD)
+        self.assertEqual((sha, got_key), (SHA, key))
+        client.put_object.assert_not_called()
+
+    def test_get_accepts_bare_sha_or_full_key(self):
+        client = make_client()
+        client.get_object.return_value = {"Body": MagicMock(read=lambda: PAYLOAD)}
+        store = BlobStore("bkt", prefix="p", suffix=".eml", client=client)
+        self.assertEqual(store.get_bytes(SHA), PAYLOAD)
+        self.assertEqual(
+            client.get_object.call_args.kwargs["Key"], f"p/{SHA}.eml"
+        )
+        store.get_bytes("explicit/key.eml")
+        self.assertEqual(
+            client.get_object.call_args.kwargs["Key"], "explicit/key.eml"
+        )
+
+    def test_requires_bucket(self):
+        with self.assertRaises(ValueError):
+            BlobStore("")
+
+
+if __name__ == "__main__":
+    unittest.main()

{velocity_python-0.1.99 → velocity_python-0.1.101}/tests/test_payment_stripe_adapter.py

@@ -597,3 +597,142 @@ def test_create_account_upserts_account_mirror_before_business_sync(
             },
         )
     ]
+
+
+class FakeCheckoutSession(dict):
+    """Attribute+item access like a Stripe object."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.__dict__.update(kwargs)
+
+
+def test_create_checkout_session_builds_hosted_payment(adapter, monkeypatch):
+    captured = {}
+
+    def fake_create(**params):
+        captured.update(params)
+        return FakeCheckoutSession(
+            id="cs_test_1",
+            url="https://checkout.stripe.com/pay/cs_test_1",
+            status="open",
+            payment_status="unpaid",
+        )
+
+    monkeypatch.setattr(
+        "velocity.payment.stripe_adapter.stripe.checkout.Session.create", fake_create
+    )
+    result = adapter.create_checkout_session(
+        None,
+        {
+            "amount": 12500,
+            "name": "2026/2027 School Year Registration",
+            "success_url": "https://x/register?session_id={CHECKOUT_SESSION_ID}",
+            "cancel_url": "https://x/register",
+            "customer_email": "ada@example.com",
+            "metadata": {"registration_sys_id": "55"},
+            "idempotency_key": "reg-55",
+        },
+    )
+    assert result["success"] is True
+    assert result["url"].startswith("https://checkout.stripe.com/")
+    assert captured["mode"] == "payment"
+    item = captured["line_items"][0]["price_data"]
+    assert item["unit_amount"] == 12500
+    assert item["product_data"]["name"] == "2026/2027 School Year Registration"
+    assert captured["customer_email"] == "ada@example.com"
+    # metadata rides on the session AND the payment intent, env stamped
+    assert captured["metadata"]["registration_sys_id"] == "55"
+    assert captured["metadata"]["environment"] == "test"
+    assert captured["payment_intent_data"]["metadata"]["registration_sys_id"] == "55"
+    assert captured["idempotency_key"] == "reg-55"
+    assert "transfer_data" not in captured["payment_intent_data"]  # direct account
+
+
+def test_create_checkout_session_connect_destination(adapter, monkeypatch):
+    captured = {}
+    monkeypatch.setattr(
+        "velocity.payment.stripe_adapter.stripe.checkout.Session.create",
+        lambda **p: captured.update(p)
+        or FakeCheckoutSession(
+            id="cs", url="u", status="open", payment_status="unpaid"
+        ),
+    )
+    adapter.create_checkout_session(
+        None,
+        {
+            "amount": 1000,
+            "name": "x",
+            "success_url": "https://x/s",
+            "cancel_url": "https://x/c",
+            "processor_account_id": "acct_123",
+            "application_fee_amount": 250,
+        },
+    )
+    intent_data = captured["payment_intent_data"]
+    assert intent_data["transfer_data"] == {"destination": "acct_123"}
+    assert intent_data["application_fee_amount"] == 250
+
+
+def test_create_checkout_session_missing_field_is_processor_error(adapter):
+    with pytest.raises(ProcessorError) as err:
+        adapter.create_checkout_session(None, {"amount": 100, "name": "x"})
+    assert err.value.error_code == "missing_field"
+
+
+def test_retrieve_checkout_session_verifies_paid_and_mirrors(adapter, monkeypatch):
+    intent = SimpleNamespace(id="pi_9", charges=None, latest_charge=None)
+    session = FakeCheckoutSession(
+        id="cs_test_1",
+        status="complete",
+        payment_status="paid",
+        amount_total=12500,
+        currency="usd",
+        payment_intent=intent,
+        metadata={"registration_sys_id": "55"},
+        customer_email=None,
+        customer_details={"email": "ada@example.com"},
+    )
+    monkeypatch.setattr(
+        "velocity.payment.stripe_adapter.stripe.checkout.Session.retrieve",
+        lambda sid, **kw: session,
+    )
+    mirrored = {}
+    monkeypatch.setattr(
+        adapter,
+        "_mirror_payment_intent_artifacts",
+        lambda tx, pi, source: mirrored.update({"pi": pi.id, "source": source}),
+    )
+    result = adapter.retrieve_checkout_session(object(), "cs_test_1")
+    assert result["paid"] is True
+    assert result["amount_total"] == 12500
+    assert result["payment_intent_id"] == "pi_9"
+    assert result["customer_email"] == "ada@example.com"
+    assert result["metadata"] == {"registration_sys_id": "55"}
+    assert mirrored["pi"] == "pi_9"
+
+
+def test_retrieve_checkout_session_unpaid_never_mirrors(adapter, monkeypatch):
+    session = FakeCheckoutSession(
+        id="cs_test_1",
+        status="open",
+        payment_status="unpaid",
+        amount_total=12500,
+        currency="usd",
+        payment_intent=None,
+        metadata={},
+        customer_email=None,
+        customer_details=None,
+    )
+    monkeypatch.setattr(
+        "velocity.payment.stripe_adapter.stripe.checkout.Session.retrieve",
+        lambda sid, **kw: session,
+    )
+    monkeypatch.setattr(
+        adapter,
+        "_mirror_payment_intent_artifacts",
+        lambda *a, **k: (_ for _ in ()).throw(AssertionError("must not mirror")),
+    )
+    result = adapter.retrieve_checkout_session(object(), "cs_test_1")
+    assert result["paid"] is False
+    assert result["payment_intent_id"] is None

velocity_python-0.1.101/tests/test_query_missing_table_unlocked.py

@@ -0,0 +1,98 @@
+"""A missing table under UNLOCKED auto-schema is empty, not an error.
+
+velocity creates tables on first write, so a table nothing has written to
+yet (``user_data`` on a fresh factory site / for a brand-new user) is
+semantically an empty table. The query path must answer with empty rows and
+NO error toast in that mode — the 2026-09-01 dance.10sp.us first sign-in
+toasted 'relation "user_data" does not exist' at the operator. Under a
+LOCKED schema (production), tables exist only via ensure_schema, so a
+missing one is a real deploy bug and must stay loud.
+"""
+
+import unittest
+from unittest.mock import MagicMock
+
+from velocity.aws.handlers.mixins.data_service import DataServiceMixin
+
+
+class _Service(DataServiceMixin):
+    pass
+
+
+def _harness(schema_locked):
+    service = _Service()
+    service._call_rwx_hook = MagicMock()
+
+    result = MagicMock()
+    result.all.return_value = []
+    result.sql = None
+    result.headers = []
+
+    table = MagicMock()
+    table.select.return_value = result
+
+    tx = MagicMock()
+    tx.table.return_value = table
+    tx.engine.schema_locked = schema_locked
+    # what @return_default records when the select swallowed 42P01
+    tx._last_return_default_error = None
+
+    def select_with_swallow(**params):
+        tx._last_return_default_error = {
+            "type": "DbTableMissingError",
+            "message": 'relation "user_data" does not exist',
+            "function": "velocity.db.core.table.Table.select",
+        }
+        return result
+
+    table.select.side_effect = select_with_swallow
+
+    context = MagicMock()
+    return service, tx, context
+
+
+class MissingTableUnlockedTest(unittest.TestCase):
+    def test_unlocked_missing_table_is_quiet_empty(self):
+        service, tx, context = _harness(schema_locked=False)
+        data = service.query_hook(
+            tx, "user_data", {"obj": "user_data", "params": {}}, context
+        )
+        self.assertEqual(data["rows"], [])
+        self.assertNotIn("error", data["config"])
+        context.response().toast.assert_not_called()
+
+    def test_locked_missing_table_stays_loud(self):
+        service, tx, context = _harness(schema_locked=True)
+        data = service.query_hook(
+            tx, "user_data", {"obj": "user_data", "params": {}}, context
+        )
+        self.assertEqual(data["rows"], [])
+        self.assertEqual(data["config"]["error"]["type"], "DbTableMissingError")
+        context.response().toast.assert_called()
+
+    def test_other_swallowed_errors_still_surface_when_unlocked(self):
+        service, tx, context = _harness(schema_locked=False)
+        tx.table.return_value.select.side_effect = None
+
+        def swallow_column_error(**params):
+            tx._last_return_default_error = {
+                "type": "DbColumnMissingError",
+                "message": 'column "bogus" does not exist',
+                "function": "velocity.db.core.table.Table.select",
+            }
+            result = MagicMock()
+            result.all.return_value = []
+            result.sql = None
+            result.headers = []
+            return result
+
+        tx.table.return_value.select.side_effect = swallow_column_error
+        data = service.query_hook(
+            tx, "user_data", {"obj": "user_data", "params": {}}, context
+        )
+        self.assertEqual(data["config"]["error"]["type"], "DbColumnMissingError")
+        context.response().toast.assert_called()
+
+
+if __name__ == "__main__":
+    unittest.main()