velocity-python 0.1.27__tar.gz → 0.1.29__tar.gz

{velocity_python-0.1.27/src/velocity_python.egg-info → velocity_python-0.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.27
+Version: 0.1.29
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT
@@ -27,6 +27,10 @@ Requires-Dist: boto3>=1.35.0; extra == "aws"
 Requires-Dist: requests>=2.32.0; extra == "aws"
 Provides-Extra: excel
 Requires-Dist: openpyxl>=3.1.0; extra == "excel"
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=15.0.0; extra == "parquet"
+Provides-Extra: ods
+Requires-Dist: odfpy>=1.4.0; extra == "ods"
 Provides-Extra: templates
 Requires-Dist: jinja2>=3.1.0; extra == "templates"
 Provides-Extra: pdf

{velocity_python-0.1.27 → velocity_python-0.1.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.27"
+version = "0.1.29"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]
@@ -45,6 +45,12 @@ aws = [
 excel = [
   "openpyxl>=3.1.0",
 ]
+parquet = [
+  "pyarrow>=15.0.0",
+]
+ods = [
+  "odfpy>=1.4.0",
+]
 templates = [
   "jinja2>=3.1.0",
 ]

{velocity_python-0.1.27 → velocity_python-0.1.29}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.27"
+__version__ = version = "0.1.29"
 
 import importlib as _importlib
 

{velocity_python-0.1.27 → velocity_python-0.1.29}/src/velocity/aws/handlers/mixins/data_service.py

@@ -6,11 +6,14 @@ that uses velocity.db for database access.
 """
 
 import base64
+import csv
 import datetime
 import importlib
+import json
 import logging
 import re
-from io import BytesIO
+import xml.etree.ElementTree as ET
+from io import BytesIO, StringIO
 
 from velocity.aws import dirty_pipeline
 from velocity.misc import export
@@ -333,7 +336,8 @@ class DataServiceMixin:
                     "message": message,
                     "missing": missing,
                 }
-                if result_format == "excel":
+                _file_export_formats_early = {"excel", "csv", "tsv", "json", "jsonl", "xml", "html", "markdown", "xlsx", "parquet", "ods"}
+                if result_format in _file_export_formats_early:
                     return {
                         "headers": payload.get("headers", []),
                         "rows": [],
@@ -354,7 +358,10 @@ class DataServiceMixin:
         swallowed_error = getattr(tx, "_last_return_default_error", None)
         if swallowed_error:
             tx._last_return_default_error = None
-        if result_format == "excel":
+
+        _file_export_formats = {"excel", "csv", "tsv", "json", "jsonl", "xml", "html", "markdown", "xlsx", "parquet", "ods"}
+
+        if result_format in _file_export_formats:
             data = {
                 "headers": payload.get(
                     "headers", [x.replace("_", " ").title() for x in result.headers]
@@ -373,7 +380,7 @@ class DataServiceMixin:
 
         # If the DB call failed but was swallowed (return_default), surface a reason.
         # Common symptoms are empty rows + null SQL.
-        if swallowed_error and result_format == "excel":
+        if swallowed_error and result_format in _file_export_formats:
             error_message = swallowed_error.get("message") or "Unknown database error"
             context.response().toast(
                 f"Query failed for '{obj}': {error_message.splitlines()[0]}",
@@ -575,6 +582,143 @@ class DataServiceMixin:
     #
     # Payload parameters
 
+    # ---------------------------------------------------------------------------
+    # Export format helpers
+    # ---------------------------------------------------------------------------
+
+    @staticmethod
+    def _safe_xml_tag(name):
+        """Sanitise a column name so it is a valid XML element name."""
+        tag = re.sub(r"[^a-zA-Z0-9_.-]", "_", str(name))
+        if tag and tag[0].isdigit():
+            tag = "_" + tag
+        return tag or "_col"
+
+    @classmethod
+    def _build_export_buffer(cls, result_format, headers, rows, filename_base):
+        """
+        Build a (bytes_buffer, filename, mime_type) tuple for the given
+        result_format.  Returns None if the format is not handled here.
+        """
+        if result_format == "csv":
+            buf = StringIO()
+            writer = csv.writer(buf)
+            writer.writerow(headers)
+            writer.writerows(rows)
+            return buf.getvalue().encode("utf-8"), f"{filename_base}.csv", "text/csv"
+
+        if result_format == "tsv":
+            buf = StringIO()
+            writer = csv.writer(buf, delimiter="\t")
+            writer.writerow(headers)
+            writer.writerows(rows)
+            return buf.getvalue().encode("utf-8"), f"{filename_base}.tsv", "text/tab-separated-values"
+
+        if result_format == "json":
+            data = [dict(zip(headers, row)) for row in rows]
+            return json.dumps(data, default=str).encode("utf-8"), f"{filename_base}.json", "application/json"
+
+        if result_format == "jsonl":
+            lines = [json.dumps(dict(zip(headers, row)), default=str) for row in rows]
+            return "\n".join(lines).encode("utf-8"), f"{filename_base}.jsonl", "application/x-ndjson"
+
+        if result_format == "xml":
+            root = ET.Element("rows")
+            for row in rows:
+                row_el = ET.SubElement(root, "row")
+                for header, value in zip(headers, row):
+                    col_el = ET.SubElement(row_el, cls._safe_xml_tag(header))
+                    col_el.text = "" if value is None else str(value)
+            xml_bytes = ET.tostring(root, encoding="unicode").encode("utf-8")
+            return xml_bytes, f"{filename_base}.xml", "application/xml"
+
+        if result_format == "html":
+            th_cells = "".join(f"<th>{h}</th>" for h in headers)
+            tr_rows = "".join(
+                "<tr>" + "".join(f"<td>{'' if v is None else str(v)}</td>" for v in row) + "</tr>"
+                for row in rows
+            )
+            html = (
+                f"<!DOCTYPE html><html><head><meta charset='utf-8'></head>"
+                f"<body><table border='1'><thead><tr>{th_cells}</tr></thead>"
+                f"<tbody>{tr_rows}</tbody></table></body></html>"
+            )
+            return html.encode("utf-8"), f"{filename_base}.html", "text/html"
+
+        if result_format == "markdown":
+            header_row = "| " + " | ".join(str(h) for h in headers) + " |"
+            separator = "| " + " | ".join("---" for _ in headers) + " |"
+            data_rows = [
+                "| " + " | ".join("" if v is None else str(v) for v in row) + " |"
+                for row in rows
+            ]
+            md = "\n".join([header_row, separator] + data_rows)
+            return md.encode("utf-8"), f"{filename_base}.md", "text/markdown"
+
+        if result_format == "xlsx":
+            try:
+                from openpyxl import Workbook
+            except ImportError:
+                raise ImportError("openpyxl is required for xlsx export (install velocity-python[excel])")
+            wb = Workbook()
+            ws = wb.active
+            ws.append(list(headers))
+            for row in rows:
+                ws.append(list(row))
+            buf = BytesIO()
+            wb.save(buf)
+            return (
+                buf.getvalue(),
+                f"{filename_base}.xlsx",
+                "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            )
+
+        if result_format == "parquet":
+            try:
+                import pyarrow as pa
+                import pyarrow.parquet as pq
+            except ImportError:
+                raise ImportError("pyarrow is required for parquet export (install velocity-python[parquet])")
+            table = pa.table({h: [row[i] for row in rows] for i, h in enumerate(headers)})
+            buf = BytesIO()
+            pq.write_table(table, buf)
+            return buf.getvalue(), f"{filename_base}.parquet", "application/octet-stream"
+
+        if result_format == "ods":
+            try:
+                from odf.opendocument import OpenDocumentSpreadsheet
+                from odf.table import Table, TableRow, TableCell
+                from odf.text import P
+            except ImportError:
+                raise ImportError("odfpy is required for ods export (install velocity-python[ods])")
+            doc = OpenDocumentSpreadsheet()
+            sheet = Table(name="Sheet1")
+            doc.spreadsheet.addElement(sheet)
+            header_row_el = TableRow()
+            for h in headers:
+                cell = TableCell()
+                cell.addElement(P(text=str(h)))
+                header_row_el.addElement(cell)
+            sheet.addElement(header_row_el)
+            for row in rows:
+                tr = TableRow()
+                for v in row:
+                    cell = TableCell()
+                    cell.addElement(P(text="" if v is None else str(v)))
+                    tr.addElement(cell)
+                sheet.addElement(tr)
+            buf = BytesIO()
+            doc.save(buf)
+            return (
+                buf.getvalue(),
+                f"{filename_base}.ods",
+                "application/vnd.oasis.opendocument.spreadsheet",
+            )
+
+        return None
+
+    # ---------------------------------------------------------------------------
+
     def OnActionQuery(self, tx, context):
         payload = context.payload()
 
@@ -586,8 +730,10 @@ class DataServiceMixin:
         if not table:
             raise ValueError("Parameter 'obj' cannot be empty")
 
+        result_format = payload.get("result_format")
         data = self.query_hook(tx, table, payload, context)
-        if payload.get("result_format") == "excel":
+
+        if result_format == "excel":
             filebuffer = BytesIO()
             export.create_spreadsheet(data["headers"], data["rows"], filebuffer)
             context.response().file_download(
@@ -598,7 +744,20 @@ class DataServiceMixin:
             )
             return
 
-        if payload.get("result_format") == "raw":
+        if result_format in ("csv", "tsv", "json", "jsonl", "xml", "html", "markdown", "xlsx", "parquet", "ods"):
+            filename_base = payload.get("filename_base") or table
+            built = self._build_export_buffer(result_format, data.get("headers", []), data.get("rows", []), filename_base)
+            if built is not None:
+                file_bytes, filename, _mime = built
+                context.response().file_download(
+                    {
+                        "filename": filename,
+                        "data": base64.b64encode(file_bytes).decode(),
+                    }
+                )
+                return
+
+        if result_format == "raw":
             context.response().set_body(data)
         else:
             context.response().set_table(

{velocity_python-0.1.27 → velocity_python-0.1.29}/src/velocity/payment/authorizenet_adapter.py

@@ -29,6 +29,13 @@ from typing import Any, Dict, List, Optional
 from authorizenet import apicontractsv1, apicontrollers
 
 from .base_adapter import PaymentProcessorAdapter, ProcessorError
+from .authorizenet_mirror import (
+    sync_client_payment_account_from_authorize_account,
+    upsert_authorize_account_record,
+    upsert_authorize_customer_profile_record,
+    upsert_authorize_payment_profile_record,
+    upsert_authorize_transaction_record,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -132,20 +139,25 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
         placeholder record so the routing layer can treat it uniformly.
         """
         client_id = client_data["client_id"]
-
-        payment_account = tx.table("client_payment_accounts").new()
-        payment_account["client_id"] = client_id
-        payment_account["processor_type"] = "authorize_net"
-        payment_account["processor_account_id"] = f"an_{client_id}"
-        payment_account["account_status"] = "active"
-        payment_account["charges_enabled"] = True
-        payment_account["payouts_enabled"] = False
-        payment_account["details_submitted"] = True
-        payment_account["requirements_data"] = {}
-        payment_account["capabilities"] = {
-            "card_payments": True,
-            "manual_settlement": True,
+        account = {
+            "client_id": client_id,
+            "processor_account_id": f"an_{client_id}",
+            "status": "active",
+            "charges_enabled": True,
+            "payouts_enabled": False,
+            "verification_status": "verified",
+            "metadata": {"account_type": "shared_merchant"},
         }
+        upsert_authorize_account_record(
+            tx,
+            account,
+            source="api:authorizenet_adapter.create_account",
+        )
+        sync_client_payment_account_from_authorize_account(
+            tx,
+            account,
+            client_id=client_id,
+        )
 
         return {
             "processor_account_id": f"an_{client_id}",
@@ -161,7 +173,7 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
         """
         Authorize.Net shared merchant is always active if credentials are valid.
         """
-        return {
+        account = {
             "account_id": processor_account_id,
             "status": "active",
             "charges_enabled": True,
@@ -172,6 +184,26 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             "verification_status": "verified",
             "metadata": {"account_type": "shared_merchant"},
         }
+        payment_account = tx.table("client_payment_accounts").find(
+            {
+                "processor_account_id": processor_account_id,
+                "processor_type": "authorize_net",
+            }
+        )
+        client_id = payment_account.get("client_id") if payment_account else None
+        if client_id:
+            account["client_id"] = client_id
+        upsert_authorize_account_record(
+            tx,
+            account,
+            source="api:authorizenet_adapter.get_account_status",
+        )
+        sync_client_payment_account_from_authorize_account(
+            tx,
+            account,
+            client_id=client_id,
+        )
+        return account
 
     def create_onboarding_link(
         self, tx, processor_account_id: str, return_url: str, refresh_url: str
@@ -225,12 +257,33 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
                 parts = e.error_message.split()
                 for part in parts:
                     if part.strip().isdigit():
+                        upsert_authorize_customer_profile_record(
+                            tx,
+                            {
+                                "customer_profile_id": part.strip(),
+                                "email_address": email_address,
+                                "description": customer_data.get(
+                                    "name", email_address
+                                ),
+                            },
+                            source="api:authorizenet_adapter.get_or_create_customer_profile",
+                        )
                         return {
                             "customer_profile_id": part.strip(),
                             "created": False,
                         }
             raise
 
+        upsert_authorize_customer_profile_record(
+            tx,
+            {
+                "customer_profile_id": response["customerProfileId"],
+                "email_address": email_address,
+                "description": customer_data.get("name", email_address),
+            },
+            source="api:authorizenet_adapter.get_or_create_customer_profile",
+        )
+
         return {
             "customer_profile_id": response["customerProfileId"],
             "created": True,
@@ -287,6 +340,24 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
 
         controller = apicontrollers.createCustomerPaymentProfileController(request)
         response = self._execute(controller)
+        upsert_authorize_payment_profile_record(
+            tx,
+            {
+                "customer_profile_id": customer_profile_id,
+                "payment_profile_id": response["customerPaymentProfileId"],
+                "last4": str(payment_data.get("card_number") or "")[-4:] or None,
+                "expiration_date": payment_data.get("expiration_date"),
+                "billing_first_name": payment_data.get("first_name"),
+                "billing_last_name": payment_data.get("last_name"),
+                "billing_address": payment_data.get("address"),
+                "billing_city": payment_data.get("city"),
+                "billing_state": payment_data.get("state"),
+                "billing_zip": payment_data.get("zip"),
+                "is_default": payment_data.get("set_default", True),
+                "metadata": payment_data.get("metadata") or {},
+            },
+            source="api:authorizenet_adapter.attach_payment_method",
+        )
 
         return {
             "customer_profile_id": customer_profile_id,
@@ -326,6 +397,16 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             else:
                 raise
 
+        upsert_authorize_payment_profile_record(
+            tx,
+            {
+                "customer_profile_id": customer_profile_id,
+                "payment_profile_id": payment_method_id,
+                "detached": True,
+            },
+            source="api:authorizenet_adapter.detach_payment_method",
+        )
+
         return {"payment_profile_id": payment_method_id, "detached": True}
 
     def delete_customer_profile(self, tx, customer_profile_id: str) -> Dict[str, Any]:
@@ -343,6 +424,12 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             else:
                 raise
 
+        upsert_authorize_customer_profile_record(
+            tx,
+            {"customer_profile_id": customer_profile_id, "deleted": True},
+            source="api:authorizenet_adapter.delete_customer_profile",
+        )
+
         return {"customer_profile_id": customer_profile_id, "deleted": True}
 
     # ========================================================================
@@ -385,6 +472,24 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            status = "authorized" if RESPONSE_CODES.get(code) == "Approved" else "failed"
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId"),
+                    "amount": float(amount_dollars),
+                    "status": status,
+                    "reason_for_transaction": payment_data.get("description"),
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "supported_id": payment_data.get("client_id"),
+                    "supported_name": payment_data.get("description"),
+                    "email_address": payment_data.get("customer_email")
+                    or payment_data.get("donor_email"),
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.authorize_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {
@@ -492,6 +597,24 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            status = RESPONSE_CODES.get(code, "Error")
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId"),
+                    "amount": float(amount_dollars),
+                    "status": status,
+                    "reason_for_transaction": order.description if client_id or campaign else None,
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "supported_id": client_id or None,
+                    "supported_name": campaign or None,
+                    "email_address": payment_data.get("customer_email")
+                    or payment_data.get("donor_email"),
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.charge_stored_payment_method",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {
@@ -581,6 +704,23 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId")
+                    or processor_transaction_id,
+                    "amount": float(decimal.Decimal(amount) / 100)
+                    if amount is not None
+                    else None,
+                    "status": "captured"
+                    if RESPONSE_CODES.get(code) == "Approved"
+                    else "failed",
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.capture_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 captured_cents = amount if amount is not None else 0
@@ -635,6 +775,20 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId")
+                    or processor_transaction_id,
+                    "status": "cancelled"
+                    if RESPONSE_CODES.get(code) == "Approved"
+                    else "failed",
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.cancel_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {
@@ -695,6 +849,23 @@ class AuthorizeNetAdapter(PaymentProcessorAdapter):
             response = self._execute(controller)
             trans = response.get("transactionResponse", {})
             code = int(trans.get("responseCode", 3))
+            upsert_authorize_transaction_record(
+                tx,
+                {
+                    "processor_transaction_id": trans.get("transId")
+                    or processor_charge_id,
+                    "amount": float(decimal.Decimal(amount) / 100)
+                    if amount is not None
+                    else None,
+                    "status": "Refunded"
+                    if RESPONSE_CODES.get(code) == "Approved"
+                    else "Error",
+                    "remote_authcode": trans.get("authCode"),
+                    "remote_responsecode": code,
+                    "raw_payload": response,
+                },
+                source="api:authorizenet_adapter.refund_payment",
+            )
 
             if RESPONSE_CODES.get(code) == "Approved":
                 return {