velocity-python 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.2.3"
+__version__ = version = "0.2.4"
 
 import importlib as _importlib
 

velocity/aws/handlers/context.py

@@ -1093,6 +1093,9 @@ class Context:
                 "enabled": response.get("Enabled"),
                 "user_status": response.get("UserStatus"),
                 "sub": attributes.get("sub", user_sub),
+                # the token issuer for this pool: with "sub", the identity
+                # the provider never reassigns (velocity.aws.identity)
+                "issuer": f"https://{user_pool_segment}",
             }
 
             return user

velocity/aws/handlers/lambda_handler.py

@@ -177,10 +177,15 @@ class LambdaHandler(BaseHandler):
                 )
 
             context.perf.start("user lookup")
-            user = self._cached_user(tx, session.get("email_address"))
+            user = self._find_current_user(tx, session, masquerade)
             context.perf.log("user lookup")
             if not user and not masquerade and _stage_allows_provisioning():
-                user = self._provision_and_reload(tx, session)
+                if self._by_subject(masquerade):
+                    # the hook's new row is bound on this, its first, sign-in
+                    self.provision_missing_user(tx, session)
+                    user = self._find_current_user(tx, session, masquerade)
+                else:
+                    user = self._provision_and_reload(tx, session)
             if not user:
                 raise UserNotProvisionedError(
                     "A valid user with permission is required to access this function [DB]"
@@ -245,6 +250,59 @@ class LambdaHandler(BaseHandler):
             )
         return user
 
+    # How a request finds its user row (velocity.aws.identity): "email" (the
+    # default) or "subject" — the identity provider's issuer + subject, the
+    # row bound once by verified email on the first sign-in after the switch.
+    # The IdentityMode config key (per environment) overrides this.
+    identity_mode = "email"
+
+    def _by_subject(self, masquerade):
+        from velocity.aws import identity
+
+        # a masquerade identity is the grant's user, not a provider subject;
+        # the mode is the IdentityMode config key, else identity_mode
+        return not masquerade and identity.mode_of(self) == identity.IDENTITY_SUBJECT
+
+    def _find_current_user(self, tx, session, masquerade=False):
+        """The signed-in caller's user row (dict) or None, by email or — in
+        ``identity_mode = "subject"`` — by issuer + subject."""
+        if not self._by_subject(masquerade):
+            return self._cached_user(tx, session.get("email_address"))
+        from velocity.aws import identity
+
+        issuer, subject, email, verified = identity.claims_of(self.cognito_user)
+        session["iss"], session["sub"] = issuer, subject
+        if not (issuer and subject):
+            return None
+        return self._cached_subject_user(tx, issuer, subject, email, verified)
+
+    def _cached_subject_user(self, tx, issuer, subject, email, verified):
+        """``_cached_user`` by issuer + subject. A first sign-in binds its row
+        inside the load; a miss is never cached."""
+        from velocity.cache import memo
+
+        from velocity.aws import identity
+        from velocity.aws.handlers.context import user_cache_seconds
+
+        def load():
+            return identity.find_user(
+                tx, self.user_table, issuer, subject, email, verified
+            )
+
+        key = ("user-subject", self.user_table, issuer, subject)
+        if getattr(self, "permission_source", None) == "tables":
+            from velocity.aws import permissions as _grants
+
+            key = (*key, _grants.cached_version(tx))
+        user = memo(
+            key,
+            load,
+            user_cache_seconds(),
+            tables=(self.user_table,),
+            cache_none=False,
+        )
+        return dict(user) if user else None
+
     def _cached_user(self, tx, email_address):
         """The user-table row for the signed-in user as a dict, through the
         process read cache (velocity.cache) for ``UserCacheSeconds``: one

velocity/aws/handlers/mixins/__init__.py

@@ -23,8 +23,9 @@ from .row_scoped import RowScopedDataService
 from .audit_trail import AuditTrailMixin
 from .job_handler import JobHandler
 from .session_control import SessionControlMixin
-from .permissions_actions import PermissionsMixin
-from .tiles_actions import TilesMixin
+from .action_names import action_names
+from .permissions_actions import PERMISSION_ACTIONS, PermissionsMixin
+from .tiles_actions import TILE_ACTIONS, TilesMixin
 from .client_errors import ClientErrorReporting, AnonymousClientErrorReporting
 
 __all__ = [
@@ -37,7 +38,10 @@ __all__ = [
     "JobHandler",
     "SessionControlMixin",
     "PermissionsMixin",
+    "PERMISSION_ACTIONS",
     "TilesMixin",
+    "TILE_ACTIONS",
+    "action_names",
     "ClientErrorReporting",
     "AnonymousClientErrorReporting",
 ]

velocity/aws/handlers/mixins/action_names.py

@@ -0,0 +1,30 @@
+"""The client action names a handler class serves, from its methods.
+
+``BaseHandler.format_action_name`` turns ``"tiles-load"`` into
+``"OnActionTilesLoad"``; this is the inverse, for a site's ``client_actions``
+allow-list: ``client_actions = MINE | TILE_ACTIONS | PERMISSION_ACTIONS``
+picks up every action a mixin gains with a release, instead of a list each
+site copies by hand (and forgets to extend: admin refused every tile action
+until its list was edited, 2026-10-14).
+"""
+
+from __future__ import annotations
+
+import re
+
+_PREFIX = "OnAction"
+_WORD = re.compile(r"[A-Z][a-z0-9]*")
+
+
+def action_names(cls) -> frozenset:
+    """The kebab-case action of every ``OnAction<Name>`` method ``cls``
+    itself defines (not inherited ones; not ``OnActionDefault``)."""
+    names = set()
+    for attr, value in vars(cls).items():
+        if not attr.startswith(_PREFIX) or not callable(value):
+            continue
+        rest = attr[len(_PREFIX) :]
+        if not rest or rest == "Default":
+            continue
+        names.add("-".join(word.lower() for word in _WORD.findall(rest)))
+    return frozenset(names)

velocity/aws/handlers/mixins/data_service.py

@@ -426,6 +426,19 @@ def plan_row_number(params):
 
 # result_formats query answers with a file download (velocity.misc.export).
 FILE_EXPORT_FORMATS = frozenset(export.EXPORT_FORMATS)
+# Formats written as XLSX cells, which carry no time zone: aware values are
+# converted to the handler's display_timezone() first.
+XLSX_EXPORT_FORMATS = frozenset({"excel", "xlsx"})
+
+
+def _export_zone(handler, result_format, context):
+    """The display zone for an export: the handler's ``display_timezone``
+    for the XLSX formats, ``None`` for the text formats (which write values
+    as given and need no SSM read)."""
+    if result_format not in XLSX_EXPORT_FORMATS:
+        return None
+    zone_for = getattr(handler, "display_timezone", None)
+    return zone_for(context) if zone_for is not None else None
 
 
 def _positive_int(value):
@@ -679,7 +692,11 @@ class ExportStream:
         """The whole export as one file: :func:`velocity.misc.export.build_buffer`
         over :meth:`rows` (line formats are written as the batches arrive)."""
         built = export.build_buffer(
-            result_format, self.headers, self.rows(), filename_base
+            result_format,
+            self.headers,
+            self.rows(),
+            filename_base,
+            display_timezone=_export_zone(self.handler, result_format, self.context),
         )
         if built is None:
             raise BadRequestError(f"Unsupported export format: {result_format!r}")
@@ -838,6 +855,24 @@ class DataServiceMixin:
         "timestamp": "string",
     }
 
+    def display_timezone(self, context=None):
+        """The zone XLSX exports show times in: Excel cells carry no zone,
+        so an aware value (every ``timestamptz``) is written as its wall time
+        here. Default: the site's ``SiteTimezone`` config key (an IANA name
+        such as ``America/Denver``, read through ``ssm_config.getenv``, which
+        caches it per process); UTC, with a warning, when it is unset or not
+        a zone. Override to choose per request (``context`` is the request
+        context) or per handler. Returns a ``tzinfo``."""
+        try:
+            name = ssm_config.getenv("SiteTimezone", None)
+        except Exception:
+            logger.warning("SiteTimezone could not be read; exports use UTC")
+            name = None
+        if not name:
+            logger.warning("SiteTimezone is not set; exports show times in UTC")
+            return datetime.timezone.utc
+        return export.resolve_display_timezone(name)
+
     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)."""
@@ -2231,6 +2266,7 @@ class DataServiceMixin:
                 data.get("headers", []),
                 data.get("rows", []),
                 filename_base,
+                display_timezone=_export_zone(self, result_format, context),
             )
             if result_format == "excel":
                 # the legacy excel download keeps its caller-chosen filename
@@ -2412,7 +2448,12 @@ class DataServiceMixin:
             )
             rows = result.as_list().all()
             filebuffer = BytesIO()
-            export.create_spreadsheet(headers, rows, filebuffer)
+            export.create_spreadsheet(
+                headers,
+                rows,
+                filebuffer,
+                display_timezone=self.display_timezone(context),
+            )
             context.response().file_download(
                 {
                     "filename": payload.get("filename", "temp_file.xls"),

velocity/aws/handlers/mixins/permissions_actions.py

@@ -63,6 +63,7 @@ from types import SimpleNamespace
 
 from velocity.aws import authz, permissions
 from velocity.aws.handlers.exceptions import AlertError
+from .action_names import action_names
 
 READ = "permissions.read"
 READ_ACTION = "permissions.read"
@@ -804,3 +805,8 @@ class PermissionsMixin:
             )
         )
         context.response().set_body(self._inbox_body(tx, actor))
+
+
+# every action PermissionsMixin serves, for a site's ``client_actions``:
+# ``client_actions = MINE | PERMISSION_ACTIONS``
+PERMISSION_ACTIONS = action_names(PermissionsMixin)

velocity/aws/handlers/mixins/tiles_actions.py

@@ -39,6 +39,7 @@ from velocity.aws import authz, facets, permissions, tiles
 from velocity.aws.handlers.exceptions import AccessError, AlertError
 from velocity.db.fragments import Expr
 from velocity.db.servers.tablehelper import TableHelper
+from .action_names import action_names
 
 logger = logging.getLogger(__name__)
 
@@ -659,3 +660,8 @@ class TilesMixin:
             )
         )
         context.response().set_body(self._manage_body(tx, actor))
+
+
+# every action TilesMixin serves, for a site's ``client_actions``:
+# ``client_actions = MINE | TILE_ACTIONS``
+TILE_ACTIONS = action_names(TilesMixin)

velocity/aws/handlers/mixins/web_handler.py

@@ -621,6 +621,14 @@ Request Details:
             return
         session = context.session() or {}
         email = session.get("email_address")
+        if not email:
+            # Nobody is signed in (a public page that saves its layout as it
+            # goes): there is no owner, so nothing is saved. Rows mode used to
+            # upsert under a blank userid — one shared junk row per key that
+            # every anonymous visitor overwrote. Not an error, so a public
+            # page does not report a failure on every change.
+            context.response().set_body({"saved": False, "reason": "signed_out"})
+            return
         if self.user_data_mode == USER_DATA_DOCUMENT:
             owner = (getattr(self, "current_user", None) or {}).get("sys_id")
             decision = authz.decide(

velocity/aws/identity.py

@@ -0,0 +1,138 @@
+"""Who is signed in: the user row bound to the identity provider's issuer and
+subject, never found by email.
+
+An email address can change, be reused, or be claimed by an external identity
+provider; the provider's issuer plus subject (``iss`` + ``sub``) is the one
+pair it guarantees never to reassign (OpenID Connect Core 1.0, section 5.7).
+So a user row carries the pair it is bound to, and each request finds its
+user by that pair.
+
+The mode is the ``IdentityMode`` config key (SSM ``/{Project}/{env}/`` then
+``/Global/{env}/``) when set, else the handler's ``identity_mode``
+(see ``LambdaHandler.beforeAction``), else ``"email"`` — so a site switches
+one environment at a time, demo first, with no code change:
+
+* ``"email"`` — the default and the behaviour before this module: the user
+  row is found by ``email_address``.
+* ``"subject"`` — the user row is found by :data:`ISSUER_COLUMN` +
+  :data:`SUBJECT_COLUMN`. The first sign-in after a site switches binds its
+  existing row ONCE, by the caller's *verified* email, and only a row not
+  yet bound to anyone; from then on email is never used to find that user.
+  A row already bound to another identity is never re-bound by email (the
+  address moved to a different account), and an unverified email binds
+  nothing.
+
+Both columns are TEXT on the site's user table. Declare them in the site's
+schema lane before switching a locked environment
+(``SCHEMA_COLUMNS``); in an unlocked one the first binding creates them.
+
+A masquerade session keeps the email path: its identity is the verified
+grant's user, not a provider subject.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from velocity.aws import ssm_config
+
+logger = logging.getLogger(__name__)
+
+IDENTITY_EMAIL = "email"
+IDENTITY_SUBJECT = "subject"
+IDENTITY_MODES = (IDENTITY_EMAIL, IDENTITY_SUBJECT)
+
+ISSUER_COLUMN = "identity_issuer"
+SUBJECT_COLUMN = "identity_subject"
+# for a site's schema lane: ensure_columns(tx, user_table, SCHEMA_COLUMNS)
+SCHEMA_COLUMNS = {ISSUER_COLUMN: "TEXT", SUBJECT_COLUMN: "TEXT"}
+
+
+def mode_of(handler):
+    """``IdentityMode`` config first, then the handler's ``identity_mode``,
+    then ``"email"``. A value that is not a mode is ``"email"`` (logged):
+    unlike authorization, the safe fallback is the established lookup, so a
+    typo never locks every user out."""
+    raw = None
+    try:
+        raw = ssm_config.getenv("IdentityMode", None)
+    except Exception:
+        raw = None
+    raw = str(raw or getattr(handler, "identity_mode", None) or IDENTITY_EMAIL)
+    mode = raw.strip().lower()
+    if mode not in IDENTITY_MODES:
+        logger.warning("identity: unknown IdentityMode %r; using email", raw)
+        return IDENTITY_EMAIL
+    return mode
+
+
+def claims_of(cognito_user):
+    """``(issuer, subject, email, email_verified)`` from a resolved Cognito
+    user (``Context.get_cognito_user``); ``None`` parts when absent."""
+    user = cognito_user if isinstance(cognito_user, dict) else {}
+    attributes = user.get("attributes") or {}
+    email = (attributes.get("email") or user.get("email") or "").strip().lower() or None
+    verified = str(attributes.get("email_verified", "")).strip().lower() == "true"
+    return user.get("issuer") or None, user.get("sub") or None, email, verified
+
+
+def _row(found):
+    if not found:
+        return None
+    return found.to_dict() if hasattr(found, "to_dict") else dict(found)
+
+
+def find_bound(tx, user_table, issuer, subject):
+    """The user row bound to ``issuer`` + ``subject``, or None."""
+    if not (issuer and subject):
+        return None
+    return _row(
+        tx.table(user_table).find({ISSUER_COLUMN: issuer, SUBJECT_COLUMN: subject})
+    )
+
+
+def bind_by_verified_email(tx, user_table, issuer, subject, email, verified):
+    """Bind the unbound row with this verified email to ``issuer`` +
+    ``subject`` and return it; None when there is nothing it may bind.
+
+    Refuses (returns None, logs why) when the email is not verified, when no
+    row has it, or when that row is already bound to a different identity —
+    the address now belongs to another account, and following it would hand
+    that account someone else's row.
+    """
+    if not (issuer and subject and email):
+        return None
+    if not verified:
+        logger.warning("identity: not binding %s — email not verified", email)
+        return None
+    row = _row(tx.table(user_table).find({"email_address": email}))
+    if not row:
+        return None
+    bound = (row.get(ISSUER_COLUMN), row.get(SUBJECT_COLUMN))
+    if any(bound):
+        if bound != (issuer, subject):
+            logger.warning(
+                "identity: %s row %s is bound to another identity; not re-binding by email",
+                user_table,
+                row.get("sys_id"),
+            )
+            return None
+        return row
+    tx.table(user_table).update(
+        {ISSUER_COLUMN: issuer, SUBJECT_COLUMN: subject}, {"sys_id": row["sys_id"]}
+    )
+    logger.info(
+        "identity: bound %s row %s to its sign-in (first sign-in by subject)",
+        user_table,
+        row.get("sys_id"),
+    )
+    row.update({ISSUER_COLUMN: issuer, SUBJECT_COLUMN: subject})
+    return row
+
+
+def find_user(tx, user_table, issuer, subject, email=None, verified=False):
+    """The signed-in caller's user row: by ``issuer`` + ``subject``, else (on
+    the first sign-in after the switch) the row its verified email binds."""
+    return find_bound(tx, user_table, issuer, subject) or bind_by_verified_email(
+        tx, user_table, issuer, subject, email, verified
+    )

velocity/aws/permissions.py

@@ -13,6 +13,8 @@ holds. This module is where those come from once a site keeps them as data
 ``sys_permission``        the catalog (:func:`velocity.aws.authz.catalog`),
                           materialised so it is a table like any other
 ``sys_authz_state``       one counter, bumped by every change
+``sys_permission_notice`` when each person was last told about waiting
+                          requests (:func:`waiting_notices`)
 
 **The rule.** Start with nothing. Add every *allow* from the user's current
 roles and direct grants. Remove everything matched by any *deny* — a deny
@@ -75,6 +77,7 @@ USER_ROLE_TABLE = "sys_user_role"
 USER_PERMISSION_TABLE = "sys_user_permission"
 REQUEST_TABLE = "sys_permission_request"
 STATE_TABLE = "sys_authz_state"
+NOTICE_TABLE = "sys_permission_notice"
 
 # The column on the site's user table that carries the compiled set.
 USER_COLUMN = "permissions"
@@ -188,6 +191,23 @@ SCHEMA = {
             {"columns": ["status"], "name": "idx__sys_permission_request__status"},
         ],
     },
+    # when a person was last told about something (waiting_notices): one row
+    # per person and kind of notice, so "at most once a day" survives restarts
+    NOTICE_TABLE: {
+        "columns": {
+            "user_sys_id": "BIGINT",
+            "notice": "TEXT",
+            "sent_at": "TIMESTAMPTZ",
+            "sent_to": "TEXT",
+            "waiting": "INTEGER",
+        },
+        "unique_indexes": [
+            {
+                "columns": ["user_sys_id", "notice"],
+                "name": "idx__sys_permission_notice__user_notice",
+            }
+        ],
+    },
 }
 
 GRANT_TABLES = (
@@ -203,7 +223,7 @@ GRANT_TABLES = (
 # (``DataServiceMixin``): a row written around the guards would be a grant
 # nobody was allowed to give.
 PROTECTED_TABLES = frozenset(
-    {STATE_TABLE, PERMISSION_TABLE, REQUEST_TABLE, *GRANT_TABLES}
+    {STATE_TABLE, PERMISSION_TABLE, REQUEST_TABLE, NOTICE_TABLE, *GRANT_TABLES}
 )
 authz.protect_tables(*PROTECTED_TABLES)
 
@@ -1801,3 +1821,171 @@ def requests(tx, *, status=None, user_sys_id=None) -> list:
     table = tx.table(REQUEST_TABLE)
     rows = _rows(table.select(where=where) if where else table.select())
     return sorted(rows, key=lambda row: row["sys_id"], reverse=True)
+
+
+# ── telling the people who decide ──────────────────────────────────────────
+
+# the kind of notice (sys_permission_notice.notice) for requests waiting
+REQUESTS_WAITING = "requests_waiting"
+# nobody is told about waiting requests more often than this
+NOTICE_INTERVAL = datetime.timedelta(days=1)
+DEFAULT_LABEL_COLUMNS = ("full_name", "email_address")
+
+
+@dataclass(frozen=True)
+class WaitingNotice:
+    """One person to tell that requests wait for them (:func:`waiting_notices`).
+
+    ``requests`` holds, oldest first, only what a notice may say: who asked
+    (``person``), what for (``asked_for``: the role's name or the
+    permission's label), where (``scope_type`` / ``scope_id``), and when
+    (``requested_at``). Never the reason."""
+
+    user_sys_id: Any
+    email: str
+    name: str
+    count: int
+    oldest_at: Optional[datetime.datetime]
+    requests: tuple
+    notice: str = REQUESTS_WAITING
+
+
+def _person_label(row, columns):
+    for column in columns:
+        value = str((row or {}).get(column) or "").strip()
+        if value:
+            return value
+    return f"User {(row or {}).get('sys_id')}"
+
+
+def _principal_of_row(row, principal_permissions=None):
+    """The principal a request by this user would have (the same rule as
+    :func:`velocity.aws.authz.principal_for`), never in a masquerade: a
+    notice goes to the person themselves."""
+    from types import SimpleNamespace
+
+    return authz.principal_for(
+        SimpleNamespace(
+            current_user=row,
+            principal_permissions=principal_permissions,
+            permission_source=TABLES,
+            context=None,
+        )
+    )
+
+
+def waiting_notices(
+    tx,
+    user_table,
+    *,
+    email_column="email_address",
+    label_columns=DEFAULT_LABEL_COLUMNS,
+    include=None,
+    principal_permissions=None,
+    every=NOTICE_INTERVAL,
+    now=None,
+) -> list:
+    """Who must be told that access requests are waiting, and what: one
+    :class:`WaitingNotice` per person due one. Reads only; record each
+    notice sent with :func:`record_notice`.
+
+    A person is told when they hold :data:`GRANT` the way deciding needs it
+    (site-wide, or as a super user), at least one pending request is theirs
+    to decide (not their own, a super user excepted, as
+    :func:`decide_request` has it), they have an address in
+    ``email_column``, ``include(row)`` (when given) says yes, and they were
+    not told within ``every``. ``principal_permissions`` is the handler hook
+    of the same name, for permissions a site's code hands out.
+
+    Nothing when the tables are not turned on or nothing waits. Nothing,
+    with a warning, when :data:`NOTICE_TABLE` is missing: without it nobody
+    could be told only once."""
+    if not tables_present(tx):
+        return []
+    # oldest first
+    pending = list(reversed(requests(tx, status=PENDING)))
+    if not pending:
+        return []
+    notices = tx.table(NOTICE_TABLE)
+    if not notices.exists():
+        logger.warning(
+            "permissions: %s is missing; nobody is told about waiting requests "
+            "until the schema step creates it",
+            NOTICE_TABLE,
+        )
+        return []
+    now = _now(now)
+    last = {
+        row.get("user_sys_id"): _aware(row.get("sent_at"))
+        for row in _rows(notices.select(where={"notice": REQUESTS_WAITING}))
+    }
+    people = {row.get("sys_id"): row for row in _rows(tx.table(user_table).select())}
+    roles = {
+        row["sys_id"]: row.get("name") for row in _rows(tx.table(ROLE_TABLE).select())
+    }
+    described = [
+        {
+            "sys_id": row["sys_id"],
+            "user_sys_id": row.get("user_sys_id"),
+            "person": _person_label(
+                people.get(row.get("user_sys_id"))
+                or {"sys_id": row.get("user_sys_id")},
+                label_columns,
+            ),
+            "asked_for": (
+                (roles.get(row.get("role_sys_id")) or f"Role {row.get('role_sys_id')}")
+                if row.get("role_sys_id")
+                else _label(row.get("permission"))
+            ),
+            "scope_type": row.get("scope_type"),
+            "scope_id": row.get("scope_id"),
+            "requested_at": _aware(row.get("requested_at")),
+        }
+        for row in pending
+    ]
+    due = []
+    for user_sys_id, row in sorted(people.items(), key=lambda item: str(item[0])):
+        principal = _principal_of_row(row, principal_permissions)
+        if principal.user_sys_id is None or not principal.holds(GRANT):
+            continue
+        email = str(row.get(email_column) or "").strip()
+        if not email or (include is not None and not include(row)):
+            continue
+        sent_at = last.get(principal.user_sys_id)
+        if sent_at is not None and sent_at > now - every:
+            continue
+        theirs = tuple(
+            entry
+            for entry in described
+            if principal.superuser or entry["user_sys_id"] != principal.user_sys_id
+        )
+        if not theirs:
+            continue
+        times = [e["requested_at"] for e in theirs if e["requested_at"] is not None]
+        due.append(
+            WaitingNotice(
+                user_sys_id=principal.user_sys_id,
+                email=email,
+                name=_person_label(row, label_columns),
+                count=len(theirs),
+                oldest_at=min(times) if times else None,
+                requests=theirs,
+            )
+        )
+    return due
+
+
+def record_notice(tx, notice, *, now=None):
+    """Record that ``notice`` (a :class:`WaitingNotice`) was sent, so the
+    person is not told again within the interval. Call it in the
+    transaction, in the same savepoint as the send."""
+    tx.table(NOTICE_TABLE).merge(
+        {
+            "user_sys_id": notice.user_sys_id,
+            "notice": notice.notice,
+            "sent_at": _now(now),
+            "sent_to": notice.email,
+            "waiting": notice.count,
+        },
+        pk={"user_sys_id": notice.user_sys_id, "notice": notice.notice},
+    )

velocity/misc/export.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
-from datetime import date, datetime, time, timedelta
+from datetime import date, datetime, time, timedelta, timezone, tzinfo
 from decimal import Decimal
 from io import BytesIO, StringIO
-from typing import TYPE_CHECKING, Dict, Iterable, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, Iterable, List, Optional, Tuple, Union
 import base64
 import csv
 import html
 import json
+import logging
 import re
 import xml.etree.ElementTree as ET
 
@@ -18,6 +19,81 @@ if TYPE_CHECKING:  # pragma: no cover
 
 NUMBER_FORMAT_RE = re.compile(r"[#0?][#0?,]*(?:\.[#0?]+)?")
 
+# Display formats for native date/time cells in XLSX exports: human readable,
+# 12-hour clock. The cell value stays a real Excel date/time.
+TIME_FORMAT = "h:mm AM/PM"
+DATE_FORMAT = "mmm d, yyyy"
+DATETIME_FORMAT = "mmm d, yyyy h:mm AM/PM"
+
+
+def _default_number_format(value) -> Optional[str]:
+    """The display format an XLSX data cell gets when its column has no
+    explicit one: ``time`` -> ``h:mm AM/PM``, ``date`` -> ``mmm d, yyyy``,
+    ``datetime`` -> ``mmm d, yyyy h:mm AM/PM``; ``None`` for anything else
+    (numbers, text, ``timedelta`` keep openpyxl's format)."""
+    if isinstance(value, datetime):
+        return DATETIME_FORMAT
+    if isinstance(value, date):
+        return DATE_FORMAT
+    if isinstance(value, time):
+        return TIME_FORMAT
+    return None
+
+
+logger = logging.getLogger(__name__)
+
+# A display zone for XLSX writers: a ``tzinfo``, an IANA name
+# (``"America/Denver"``) or ``None`` (UTC).
+DisplayZone = Union[tzinfo, str, None]
+
+
+def resolve_display_timezone(zone: DisplayZone) -> tzinfo:
+    """The ``tzinfo`` an XLSX writer converts aware values to: ``zone``
+    itself when it is a ``tzinfo``, the IANA zone it names when it is a
+    string, else UTC. An unknown or blank name logs a warning and gives UTC:
+    a bad setting must not fail an export."""
+    if isinstance(zone, tzinfo):
+        return zone
+    if isinstance(zone, str) and zone.strip():
+        try:
+            from zoneinfo import ZoneInfo
+
+            return ZoneInfo(zone.strip())
+        except Exception:  # ZoneInfoNotFoundError, ValueError on odd paths
+            logger.warning("unknown display timezone %r; using UTC", zone)
+    elif zone not in (None, ""):
+        logger.warning("display timezone %r is not a zone; using UTC", zone)
+    return timezone.utc
+
+
+def _excel_value(value, zone: tzinfo):
+    """``value`` as an XLSX cell can hold it. Excel has no time zones, so
+    an aware ``datetime`` becomes the naive wall time in ``zone``, and an
+    aware ``time`` the wall time in ``zone`` on today's date. Everything
+    else, naive values included, is returned unchanged."""
+    if isinstance(value, datetime):
+        if value.utcoffset() is not None:
+            return value.astimezone(zone).replace(tzinfo=None)
+        return value
+    if isinstance(value, time) and value.tzinfo is not None:
+        moment = datetime.combine(date.today(), value)
+        if moment.utcoffset() is None:  # a zone that needs a date to answer
+            return value.replace(tzinfo=None)
+        return moment.astimezone(zone).time().replace(tzinfo=None)
+    return value
+
+
+def _excel_row(row, zone: tzinfo) -> list:
+    return [_excel_value(v, zone) for v in row]
+
+
+def _format_data_row(ws) -> None:
+    """Apply :func:`_default_number_format` to the row just appended to ``ws``."""
+    for cell in ws[ws.max_row]:
+        code = _default_number_format(cell.value)
+        if code:
+            cell.number_format = code
+
 
 def extract(d: dict, keys: List[str]) -> List:
     """Extract values from a dictionary based on a list of keys."""
@@ -161,8 +237,17 @@ def create_spreadsheet(
     freeze_panes: str = "A2",
     dimensions: dict = None,
     auto_size: bool = True,
+    display_timezone: DisplayZone = None,
 ):
-    """Create an Excel spreadsheet with specified headers, rows, and styles."""
+    """Create an Excel spreadsheet with specified headers, rows, and styles.
+
+    ``formats`` maps a cell reference (``"B2"``) to a number format. Native
+    ``date`` / ``time`` / ``datetime`` data cells otherwise display human
+    readable on a 12-hour clock (see :func:`_default_number_format`).
+    Timezone-aware values are written as the wall time in
+    ``display_timezone`` (a ``tzinfo`` or IANA name; UTC when ``None``),
+    since Excel cells carry no zone (see :func:`resolve_display_timezone`).
+    """
     import openpyxl
     from openpyxl.styles import Alignment, Border, Font, NamedStyle, Side
 
@@ -170,6 +255,7 @@ def create_spreadsheet(
     merge = merge or []
     formats = formats or {}
     named_styles = named_styles or []
+    zone = resolve_display_timezone(display_timezone)
 
     wb = openpyxl.Workbook()
     ws = wb.active
@@ -229,11 +315,13 @@ def create_spreadsheet(
     # Add headers and rows
     ws.append(headers)
     for row in rows:
-        ws.append(row)
+        ws.append(_excel_row(row, zone))
+        _format_data_row(ws)
 
     # Set freeze panes
     ws.freeze_panes = freeze_panes
 
+    # explicit per-cell formats win over the date/time defaults
     for cell, format_code in formats.items():
         ws[cell].number_format = format_code
 
@@ -279,12 +367,18 @@ def sheet_title(name, used: set | None = None, fallback: str = "Sheet") -> str:
     return title
 
 
-def _sheet_cell(value):
+def _sheet_cell(value, zone: tzinfo):
     # Decimal (every Postgres numeric) is written as a number cell.
-    return float(value) if isinstance(value, Decimal) else value
+    if isinstance(value, Decimal):
+        return float(value)
+    return _excel_value(value, zone)
 
 
-def create_workbook(sheets: Iterable[Dict], fileorbuffer=None) -> Optional[bytes]:
+def create_workbook(
+    sheets: Iterable[Dict],
+    fileorbuffer=None,
+    display_timezone: DisplayZone = None,
+) -> Optional[bytes]:
     """A multi-sheet XLSX: one worksheet per spec, in order.
 
     Each spec is a dict:
@@ -292,9 +386,15 @@ def create_workbook(sheets: Iterable[Dict], fileorbuffer=None) -> Optional[bytes
     - ``title`` (required) — made Excel-safe and unique (:func:`sheet_title`).
     - ``headers`` — the first row, bold unless ``bold_header`` is False.
     - ``rows`` — iterable of row value lists, in header order. ``Decimal`` is
-      written as a number; other values as openpyxl writes them.
+      written as a number; other values as openpyxl writes them. Native
+      ``date`` / ``time`` / ``datetime`` cells display human readable on a
+      12-hour clock (``Aug 17, 2026``, ``4:45 PM``, ``Aug 17, 2026 4:45 PM``)
+      unless their column has a ``number_formats`` entry. Timezone-aware
+      values are written as the wall time in ``display_timezone`` (a
+      ``tzinfo`` or IANA name; UTC when ``None``): Excel cells carry no zone.
     - ``number_formats`` — ``{header: format_code}`` applied to that column's
-      data cells (e.g. ``{"Total Sales": "$#,##0.00"}``).
+      data cells (e.g. ``{"Total Sales": "$#,##0.00"}``); wins over the
+      date/time defaults.
     - ``freeze`` — freeze-panes cell, default ``"A2"`` (``None`` for none).
     - ``tab_color`` — hex colour of the sheet tab (``"#1072BA"`` or ``"1072BA"``).
     - ``autosize`` (default True), ``max_width``, ``min_width`` — passed to
@@ -306,6 +406,7 @@ def create_workbook(sheets: Iterable[Dict], fileorbuffer=None) -> Optional[bytes
     import openpyxl
     from openpyxl.styles import Font
 
+    zone = resolve_display_timezone(display_timezone)
     wb = openpyxl.Workbook()
     wb.remove(wb.active)
     used: set = set()
@@ -318,7 +419,8 @@ def create_workbook(sheets: Iterable[Dict], fileorbuffer=None) -> Optional[bytes
                 for cell in ws[1]:
                     cell.font = Font(bold=True)
         for row in spec.get("rows") or ():
-            ws.append([_sheet_cell(v) for v in row])
+            ws.append([_sheet_cell(v, zone) for v in row])
+            _format_data_row(ws)
         formats = spec.get("number_formats") or {}
         if formats:
             first = 2 if headers else 1
@@ -361,6 +463,7 @@ def get_downloadable_spreadsheet(
     freeze_panes: str = "A2",
     dimensions: dict = None,
     auto_size: bool = True,
+    display_timezone: DisplayZone = None,
 ) -> str:
     """Generate a downloadable spreadsheet encoded in base64."""
     buffer = BytesIO()
@@ -375,6 +478,7 @@ def get_downloadable_spreadsheet(
         freeze_panes,
         dimensions,
         auto_size,
+        display_timezone=display_timezone,
     )
     return base64.b64encode(buffer.getvalue()).decode()
 
@@ -473,7 +577,12 @@ def _ods_document(headers, rows) -> bytes:
     return buf.getvalue()
 
 
-def _render(result_format: str, headers: List, rows: Iterable) -> bytes:
+def _render(
+    result_format: str,
+    headers: List,
+    rows: Iterable,
+    display_timezone: DisplayZone = None,
+) -> bytes:
     if result_format in ("csv", "tsv"):
         buf = StringIO()
         writer = csv.writer(buf, delimiter="\t" if result_format == "tsv" else ",")
@@ -522,7 +631,9 @@ def _render(result_format: str, headers: List, rows: Iterable) -> bytes:
         return "\n".join(lines).encode("utf-8")
     if result_format == "excel":
         buf = BytesIO()
-        create_spreadsheet(list(headers), list(rows), buf)
+        create_spreadsheet(
+            list(headers), list(rows), buf, display_timezone=display_timezone
+        )
         return buf.getvalue()
     if result_format == "xlsx":
         try:
@@ -531,11 +642,13 @@ def _render(result_format: str, headers: List, rows: Iterable) -> bytes:
             raise ImportError(
                 "openpyxl is required for xlsx export (install velocity-python[excel])"
             )
+        zone = resolve_display_timezone(display_timezone)
         wb = Workbook()
         ws = wb.active
         ws.append(list(headers))
         for row in rows:
-            ws.append(list(row))
+            ws.append(_excel_row(row, zone))
+            _format_data_row(ws)
         buf = BytesIO()
         wb.save(buf)
         return buf.getvalue()
@@ -545,7 +658,11 @@ def _render(result_format: str, headers: List, rows: Iterable) -> bytes:
 
 
 def build_buffer(
-    result_format: str, headers: List, rows: Iterable, filename_base: str
+    result_format: str,
+    headers: List,
+    rows: Iterable,
+    filename_base: str,
+    display_timezone: DisplayZone = None,
 ) -> Optional[Tuple[bytes, str, str]]:
     """A file export as ``(bytes, filename, mime_type)``.
 
@@ -554,10 +671,15 @@ def build_buffer(
     ``headers`` are the column labels and ``rows`` the row value lists, in
     header order — for :data:`LINE_FORMATS` any iterable, consumed once.
     ``filename_base`` is used as given: sanitise client-supplied names first.
-    HTML cell text is escaped and Markdown ``|`` is escaped.
+    HTML cell text is escaped and Markdown ``|`` is escaped. Excel/XLSX cells
+    stay native; date/time cells display human readable on a 12-hour clock,
+    and timezone-aware values are written as the wall time in
+    ``display_timezone`` (a ``tzinfo`` or IANA name; UTC when ``None``). The
+    text formats write values as given.
     """
     spec = EXPORT_FORMATS.get(result_format)
     if spec is None:
         return None
     extension, mime = spec
-    return _render(result_format, headers, rows), f"{filename_base}.{extension}", mime
+    body = _render(result_format, headers, rows, display_timezone)
+    return body, f"{filename_base}.{extension}", mime

velocity/misc/format.py

@@ -38,6 +38,35 @@ def currency(data: Union[None, str, float, decimal.Decimal]) -> str:
         return ""
 
 
+def format_time_of_day(value) -> str:
+    """A time of day in standard 12-hour form: ``"4:45 PM"``.
+
+    Takes a ``datetime.time`` / ``datetime.datetime`` or text such as
+    ``"16:45"`` / ``"16:45:00"``. Blank (``None`` or ``""``) gives ``""``;
+    anything unreadable comes back as text, unchanged. No time zone is
+    applied: a time of day is a wall-clock value. The same rule as
+    velocity-react's ``formatTimeOfDay``, for what a server writes itself
+    (sentences, workbooks, PDFs); a value sent to a screen is better sent raw
+    and formatted there.
+    """
+    if value is None or value == "":
+        return ""
+    if isinstance(value, (time, datetime)):
+        hour, minute = value.hour, value.minute
+    else:
+        text = str(value).strip()
+        parts = text.split(":")
+        if len(parts) < 2 or len(parts[1]) < 2:
+            return text
+        try:
+            hour, minute = int(parts[0]), int(parts[1][:2])
+        except ValueError:
+            return text
+        if not (0 <= hour <= 23 and 0 <= minute <= 59):
+            return text
+    return f"{(hour + 11) % 12 + 1}:{minute:02d} {'AM' if hour < 12 else 'PM'}"
+
+
 def human_delta(tdelta: timedelta) -> str:
     """Formats a timedelta object into a human-readable format."""
     d = {"days": tdelta.days, "hrs": 0, "min": 0, "sec": 0}

velocity/misc/tests/test_format.py

@@ -1,11 +1,40 @@
 import unittest
 import decimal
 from datetime import datetime, date, time, timedelta
-from ..format import gallons, gallons2liters, currency, human_delta, to_json
+from ..format import (
+    currency,
+    format_time_of_day,
+    gallons,
+    gallons2liters,
+    human_delta,
+    to_json,
+)
 
 
 class TestYourModule(unittest.TestCase):
 
+    def test_format_time_of_day(self):
+        """A time of day in standard 12-hour form, never zone-shifted."""
+        cases = [
+            ("16:45", "4:45 PM"),
+            ("16:45:00", "4:45 PM"),
+            ("09:05", "9:05 AM"),
+            ("00:00", "12:00 AM"),
+            ("12:00", "12:00 PM"),
+            ("23:59:59", "11:59 PM"),
+        ]
+        for text, expected in cases:
+            with self.subTest(text=text):
+                self.assertEqual(format_time_of_day(text), expected)
+        self.assertEqual(format_time_of_day(time(17, 30)), "5:30 PM")
+        self.assertEqual(format_time_of_day(datetime(2026, 9, 7, 8, 0)), "8:00 AM")
+        # blank stays blank; anything unreadable comes back unchanged
+        self.assertEqual(format_time_of_day(None), "")
+        self.assertEqual(format_time_of_day(""), "")
+        for text in ("soon", "25:00", "9:5", "16"):
+            with self.subTest(text=text):
+                self.assertEqual(format_time_of_day(text), text)
+
     def test_gallons(self):
         """Tests the gallons function with various inputs."""
         self.assertEqual(gallons("10.5"), "10.50")

{velocity_python-0.2.3.dist-info → velocity_python-0.2.4.dist-info}/METADATA

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

{velocity_python-0.2.3.dist-info → velocity_python-0.2.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-velocity/__init__.py,sha256=vPxGRTSBGj7ZKCOPBROmsFHLRQabf6Y6JEYuG4jpB6A,362
+velocity/__init__.py,sha256=84gbnHEUDdcmEw4DdO9GRo7A5VBhALffvnNP7_LlCW8,362
 velocity/cache.py,sha256=pthvw7gDVEXRzkTcQtA5YVf4Q1IxAamWsba4UReT0RE,8933
 velocity/logging.py,sha256=MAsZap1cDSdOBNRc_9ezQxup5dHOS0ARxU9NI_-UK3E,4037
 velocity/aws/__init__.py,sha256=XJJ79gnPlhg3aJij713PB8-vjQOt-BkqxYeGCBOxAu8,3460
@@ -10,11 +10,12 @@ velocity/aws/email.py,sha256=CAvXTAUxJqMaT8ylpRwRcVEA4YLFMUuHCrwYLVE4G1E,6243
 velocity/aws/facets.py,sha256=vAXbp2PSjCTUzFpI84iUHvQoPXD1N-DJ6qIz9UhitFo,22574
 velocity/aws/failures.py,sha256=9H0yvo-mH2bfNytYAvDoocsOSjjGfDrRwwcAoB-SPrI,25172
 velocity/aws/feature_flags.py,sha256=G2S1Ifjjex1QEmaAnAwRISyawxfGTdzaKUh3150M5aw,9604
+velocity/aws/identity.py,sha256=u6f_oaVhDa3tNatsQkeXZPJDhMfXCzeDo1zGoTqW_Yo,5547
 velocity/aws/job_lifecycle.py,sha256=6ltzdrkSjU_pY0eU6UaGbGh_1X5RhE5F4hypEH6MoRA,2735
 velocity/aws/job_results.py,sha256=qHu2FDWi9zdqbo0C6k7NYGy7KE6FECkATZ0KkdJyFS0,20332
 velocity/aws/mirror.py,sha256=8Ik1_GVCcD7E2nCe1ci6sp56PEVBMYZF-alkMFlP4O4,8858
 velocity/aws/ops.py,sha256=re8e3LkkQwgNS1ZjtaZMPnKyPbi4PuUC4YeS0wZwg_Q,18701
-velocity/aws/permissions.py,sha256=kJ4RlesxF3H-O6VPYJW8jwKClXteArwG3oGOmS2r4s8,67318
+velocity/aws/permissions.py,sha256=peAJHQEWpP9wsm0i-Wq15E55Ze5w9CwAGVA5mmrZPtA,74152
 velocity/aws/queue_defaults.py,sha256=480V3pDvWBBamJ6hIJyVtPGJKMVmnP43otl3E9qnwfs,479
 velocity/aws/s3.py,sha256=Mn6rlK6sXykx32EjptFK2IRRBQZ9xijl9r33DUnKDzQ,30277
 velocity/aws/schema.py,sha256=6f6rdOAHfdYlq81CQtxXpYVcMeYUNDd5ch8UuSUgQeU,5143
@@ -47,25 +48,26 @@ velocity/aws/deploy/reconcile.py,sha256=3xZXXiiVeCw4nUV8lKyk1XCgRbpNCLVYXIXbOLXe
 velocity/aws/deploy/targets.py,sha256=vmZzGbLDKNtWkwd2ado_ZhT8AT6nXYbJD5nIgDiBzRc,6632
 velocity/aws/handlers/__init__.py,sha256=0yvVADxMHK8JOhgGRxMIz1XkNGlUk08AOmdR4qhNP2U,906
 velocity/aws/handlers/base_handler.py,sha256=xa1H5lS3CCxuM5_LXva2bmvWxUzxARIqkjnkp7bux3s,19143
-velocity/aws/handlers/context.py,sha256=tfotYkmRsIw6zp2Y2CLmhmu8kNmqL_GjbgXu-r3rnsk,46931
+velocity/aws/handlers/context.py,sha256=7tfhzhidxWEJExVpu5Uz_BWbGlC7Xj0n8sqyr67f0jI,47135
 velocity/aws/handlers/context_factory.py,sha256=8rhYKrylzwQxBFqBckmF7jgWGZhfomLOT_Yu404CtJQ,784
 velocity/aws/handlers/exceptions.py,sha256=vChotaBjpPhvb_g058fGTnOG-vH1ZDMmHVwlj980DEg,2731
-velocity/aws/handlers/lambda_handler.py,sha256=MOQLaIjun4dbaZmwEyyg02rQlKBfeqxA2nk6youlhW8,18818
+velocity/aws/handlers/lambda_handler.py,sha256=WfB_tBoLZsQREUR3ZS4pkLLwevqozjJsA_yfHBrcc5Y,21358
 velocity/aws/handlers/masquerade.py,sha256=ZMXGGB-w7pXRV8Fq0qBmJOL1Eq55hXP3Rq3dWjJk6Ck,5157
 velocity/aws/handlers/perf.py,sha256=zLAcr_IrvpnZS1zzzXi-YhopRgCv3OeetQgOx_S43Xw,1421
 velocity/aws/handlers/response.py,sha256=p2d2Omv2dH8aJ9ZO9vXsiCIAJRiLGmBpNmT-OPMLe-M,16996
 velocity/aws/handlers/sqs_handler.py,sha256=1A7pHnZ-gl6AGcdK5hWvNUg-s8IjRhrBeiQLacHHhHk,9669
-velocity/aws/handlers/mixins/__init__.py,sha256=j50JvNnil757XtoGcCADfojdPn-vio-PcjHJ9Reo2nk,1746
+velocity/aws/handlers/mixins/__init__.py,sha256=xhVfpkqNQuDq2v0cQJFcUGmnwtFHEHeJb82vWS03kaw,1885
+velocity/aws/handlers/mixins/action_names.py,sha256=6RYAdromGcDD9Fv6tYKAtgzLhKx8gf5oG-7K67roWqI,1112
 velocity/aws/handlers/mixins/audit_trail.py,sha256=D8BHuBfa2EXAcC4NtV_0Gie22zshhalcscf7L1MEDVw,16873
 velocity/aws/handlers/mixins/client_errors.py,sha256=0LqIRm1gZRwzHH32ravGHAgcQqJzjh5p6M_ptuL2Tto,20105
 velocity/aws/handlers/mixins/client_input.py,sha256=UhfwsRiztOYDrJnQPZhQ6J71NAmCyrXjMgxbko2rnfQ,24225
-velocity/aws/handlers/mixins/data_service.py,sha256=EobIrZiTX_IyxmogKLjtGfme3Ic8wmFiO6LeXFBpQFk,106397
+velocity/aws/handlers/mixins/data_service.py,sha256=zJGgL1w70L9KqyYNPR2HehR-zvnAPruO_xCLrsxvfD8,108299
 velocity/aws/handlers/mixins/job_handler.py,sha256=yIbNcIg5pKXtZeQFNW7B4xqJJTjtjIxI8HRQsbMWixA,8095
-velocity/aws/handlers/mixins/permissions_actions.py,sha256=lAquZuFGKPd_yzHzfRNzSEd3Lyvaos6HxbhW5so3GJs,32194
+velocity/aws/handlers/mixins/permissions_actions.py,sha256=KjWKu4in0OvczEqO4JpVkmBPL_C0I1qOAraBeW21XvI,32409
 velocity/aws/handlers/mixins/row_scoped.py,sha256=f7N70RjzlHIVyjDsEI1oImCdjyFsgoP9aIvYXUXD5-Q,12967
 velocity/aws/handlers/mixins/session_control.py,sha256=w2wGC_XiM-W-tL5mhZvVCt_GiQjE3Gao0Ut7tx6JdLk,12937
-velocity/aws/handlers/mixins/tiles_actions.py,sha256=MG1D85m9aCqD4etSTDkymXaJ9ZQACLhqBBkGjdxOoP0,27804
-velocity/aws/handlers/mixins/web_handler.py,sha256=6hA7GUSj_6y0U2fnhGFvuzHRH73RUOdvjxaH3ZZZ-Qg,36549
+velocity/aws/handlers/mixins/tiles_actions.py,sha256=6476EeGZK1W-bRlFjzqu2WYaOPN6HuLfA3Zev9ZCPnc,27995
+velocity/aws/handlers/mixins/web_handler.py,sha256=NYYdtNbMQyVkDEJVntEzrPVx6DYQ1E_lJaz7hn1Vj04,37044
 velocity/aws/tests/__init__.py,sha256=hk-efPTkFb_py5ouA5d1OuPVQzaa5Wa01Wsc1oQ9dhY,19
 velocity/aws/tests/test_base_handler_error_response.py,sha256=CgnTMzxGkd4ArUHvsuiO_iQsiQMSlZSX_fM0YrMVRrc,2408
 velocity/aws/tests/test_deploy_least_privilege.py,sha256=ShdsbNwl2qzPaeQp2ZcMqtWRSoIB0DM0GmX0EUGJOUk,15947
@@ -164,8 +166,8 @@ velocity/db/tests/sql/test_postgres_select_advanced.py,sha256=xODItdjxYBg1kdpmiE
 velocity/db/tests/sql/test_postgres_select_variances.py,sha256=F3d6TleZVtYnWndvEqeamvn5BteILyHfUAlUegiZMvA,17611
 velocity/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 velocity/misc/db.py,sha256=MPgt-kkukKR_Wh_S_5W-MyDgaeoZ4YLoDJ54wU2ppm4,2830
-velocity/misc/export.py,sha256=o_6fllHarvODQlrpvBnCnNlrc1b_48wTn9_it1dYp9g,19805
-velocity/misc/format.py,sha256=7RyEj85_5NJXAr9UdkNVdmkdw__D9g6hrcWBvvH2V9s,3182
+velocity/misc/export.py,sha256=DbrhNFH3MQPA6DC222KSRhjwqQYrGnGYOtiz7zCfEac,24692
+velocity/misc/format.py,sha256=YHkmeUeBPBaM3auwZYu3z4-qCGTfQiNJNC1CjaqDgs0,4332
 velocity/misc/mail.py,sha256=h-CbGVCNLpIol3PIkCPcySomTxJivBg0rDxZZhstNKQ,20097
 velocity/misc/merge.py,sha256=J5WIKWLs6t1jZg0BNiI0OJ962mYa16liHlBwxlFSmK8,2144
 velocity/misc/pdf.py,sha256=7tlD9bUVtfHp9buXRuYIPM86C5tu1hd-gmX5kKs_HbU,13453
@@ -177,7 +179,7 @@ velocity/misc/conv/oconv.py,sha256=tq6JVNQmK6YK62nO5FnnpnG4jgX0lQsvjD-W92wsK4I,6
 velocity/misc/tests/__init__.py,sha256=uUg-3PgXRGan21wF2k-1GG0WBCdVuwtoRrJZbz_yet0,20
 velocity/misc/tests/test_db.py,sha256=yGGthOlwzT2reXTHPxNfmmvUpAbQIt4-K9bhFYGylMs,2671
 velocity/misc/tests/test_fix.py,sha256=D63WZDKFm4oYkZL4dmotnvIPUmXMJveS8k1__7fcm-U,2293
-velocity/misc/tests/test_format.py,sha256=PeDtJo7n-3XJ0YaaZRj0DIedwnDK4k29W7_vJ49shac,2667
+velocity/misc/tests/test_format.py,sha256=EQGbJidpuWBgzD4HOckf68t6TdJuSgVLJKBjB9qDQCk,3710
 velocity/misc/tests/test_iconv.py,sha256=lblHkTDr0yuTOlMuUCBwGRmz1G-ufsKn5xElZSnewq4,7119
 velocity/misc/tests/test_mail_send.py,sha256=Sa9Q4SRhxRG9gnFn7c2j0tb1XJofJ2gFHEW8tJi-u84,12528
 velocity/misc/tests/test_merge.py,sha256=Vm5_jY5cVczw0hZF-3TYzmxFw81heJOJB-dvhCgXh_k,3042
@@ -221,9 +223,9 @@ velocity/payment/stripe_adapter.py,sha256=6EmVBZZchg2s3Teya0eQGA_8pvSK_teizr036U
 velocity/payment/stripe_mirror.py,sha256=6GKJk_PjAgySqFEuxbcuV423OfuGXupVTiGu9QwS5W8,12320
 velocity/testing/__init__.py,sha256=WtYMDHgCLxOq6mlemcOYV5Y9HqF_2QQgSfuAjFRg69Q,731
 velocity/testing/fake_db.py,sha256=phgdulk5owf3noUDpEfI7yFsVcKxRGZ82f2BJPYnaiU,53226
-velocity_python-0.2.3.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
-velocity_python-0.2.3.dist-info/METADATA,sha256=MJ9lXm16krWeQ0drqTBqQykR2ZtqTKW9yZe9GdMi738,17782
-velocity_python-0.2.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-velocity_python-0.2.3.dist-info/entry_points.txt,sha256=nXUKJHkOGQCSPoagdmMNd_qycrle1LVU-GhYknLGM1M,56
-velocity_python-0.2.3.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
-velocity_python-0.2.3.dist-info/RECORD,,
+velocity_python-0.2.4.dist-info/licenses/LICENSE,sha256=aoN245GG8s9oRUU89KNiGTU4_4OtnNmVi4hQeChg6rM,1076
+velocity_python-0.2.4.dist-info/METADATA,sha256=wYu_9tM6EPj1sLFlthIKiPxjPin8VYr3h-TBzoteM5I,17782
+velocity_python-0.2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+velocity_python-0.2.4.dist-info/entry_points.txt,sha256=nXUKJHkOGQCSPoagdmMNd_qycrle1LVU-GhYknLGM1M,56
+velocity_python-0.2.4.dist-info/top_level.txt,sha256=JW2vJPmodgdgSz7H6yoZvnxF8S3fTMIv-YJWCT1sNW0,9
+velocity_python-0.2.4.dist-info/RECORD,,