aggregate_api 1.0.0__py3-none-any.whl

aggregate_api/tables.py

@@ -0,0 +1,316 @@
+"""Static tables as a semantic document, not as markup.
+
+The api's JSON wire format is lossy for presentation. ``serializers.py``
+flattens MultiIndex columns to dotted strings and resets the index into
+ordinary data columns, which is right for a grid and wrong for a printed
+exhibit: a portfolio's ``tail_df`` carries a two level row index, so the unit
+name would be reprinted on all ten of its return-period rows.
+
+So the static path does not go through that wire format at all. It hands the
+real DataFrame to ``greater_tables``, which returns a **table document**: an
+``ir_version`` 1 JSON structure carrying dtypes, resolved formats, hierarchy,
+spans and flags, and carrying no widths and no CSS. The browser owns geometry.
+A walker shipped in the same package renders it, so the renderer and the
+document can never version skew.
+
+Notes
+-----
+This replaces an evaluation path (``greater_tables`` 5.x) that returned an html
+blob and stamped row emphasis onto it with a positional BeautifulSoup pass. The
+emphasis now rides in the document as ``row_flags``, which is what deletes that
+pass rather than tidying it. See ``dev/plan-gt2-ir.md``.
+
+Row flags use the IR's own vocabulary (total / subtotal / emphasis / muted)
+rather than reproducing the old css class names, because the vocabulary happens
+to fit: a portfolio's ``total`` row is a total, a unit's ``Agg`` line is that
+unit's subtotal, and the capital anchors are the only rows left wanting plain
+emphasis. Styling those is the SPA's business, which is the separation the whole
+exercise is about.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable, Sequence
+
+import pandas as pd
+from greater_tables import TableSpec, build, canonical_json
+
+# Truncation ceiling, well above any frame that belongs in a static exhibit.
+# Unlike the 5.x path this does not refuse: ``build`` slices to the cap and
+# appends a note saying so, before doing any formatting work, so even a 65,536
+# row density frame is cheap to ask for. The SPA still routes big frames to the
+# grid, which is the honest answer for them, but a direct request degrades
+# rather than erroring.
+MAX_ROWS = 500
+
+
+def level_value(df: pd.DataFrame, row: int, name: str) -> Any:
+    """Value of index level ``name`` in row ``row``, or None when absent.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Frame whose index is being read.
+    row : int
+        Positional row number.
+    name : str
+        Index level name, e.g. ``'unit'``, ``'X'``, ``'T'``.
+
+    Returns
+    -------
+    Any or None
+        None when the frame has no such level, so a caller can write one
+        predicate that works for both the Aggregate and the Portfolio shape of
+        a frame. An Aggregate's ``tail_df`` is indexed by ``T`` alone; the
+        Portfolio's by ``(unit, T)``.
+    """
+    names = list(df.index.names or [])
+    if name not in names:
+        return None
+    label = df.index[row]
+    if df.index.nlevels == 1:
+        return label
+    return label[names.index(name)]
+
+
+# `_is_total`, `_is_anchor`, `_summary_flags` and `_tail_flags` came out at
+# a71 with the ROW_FLAGS entries they served. Between them they decided which
+# of the library's rows a reader should look at hardest, off a hard-coded
+# 1-in-200 and 1-in-250. See ROW_FLAGS below.
+
+
+#: Per-frame row emphasis. Frames absent from this map build unflagged.
+#:
+#: **Empty since a71, and it should stay that way.** It held `summary`, `tail_df`
+#: and `reins_summary_df`, deciding which of the library's rows carry weight: the
+#: total, the subtotals, and the two capital anchors on the return-period ladder.
+#: Every one of those tables is a published exhibit that ships its own flags, and
+#: the anchors are the clearest case of why this was the wrong place to hold it:
+#: which return periods a book is capitalized at is the library's choice, this
+#: repo had 1-in-200 and 1-in-250 written down as a fact about it, and the copy
+#: had already gone stale by a68 without anybody noticing.
+#:
+#: The mechanism stays because `frame_document` takes a key and the grid audit
+#: still goes through it. Nothing should be added here for a frame the library
+#: publishes an exhibit for; that is what the exhibit is.
+ROW_FLAGS: dict[str, Callable[[pd.DataFrame, int], Sequence[str]]] = {}
+
+#: Per-frame column formats, for the columns whose dtype does not say enough.
+#:
+#: A loss ratio and a return on capital are both just floats, so the engine has
+#: no way to know they should read as percents. These say so once, in the
+#: document, and **both** views then render from the same resolved format: the
+#: walker draws it, and ``irToGridInput`` maps it into the grid's own format-spec
+#: language. The strings are the same ones the SPA used to carry in three
+#: hand-written maps, which is what this replaces.
+#:
+#: A value is either a mapping of column name to spec, or a single spec that
+#: applies to **every** column. The second form was for a frame whose columns
+#: are not statistics: the sharpen score grid's were steps in log2, so one
+#: spec covered the lot.
+#:
+#: Money, everywhere money appears. Grouped, and to the cent.
+#:
+#: It was ``,d`` through a50, and on a real book that made the whole pricing
+#: table integers: every column of the pentagon is money except the three
+#: ratios, `P` was declared ``,d`` outright, and `L`, `M`, `Q` and `a` fell
+#: through to greater-tables' inference, which drops to zero decimals once a
+#: column's mean reaches 20,000 (``engine/formats.py``). So a book priced in the
+#: millions reported its margin as a whole number of dollars and its loss ratio
+#: to a tenth of a percent, which is the wrong way round: the margin is the
+#: small difference between two large numbers and is exactly where the digits
+#: are worth having.
+#:
+#: Two decimals rather than a scale-aware choice. Money is money at every
+#: magnitude, and a table whose decimal count moves with the book is harder to
+#: read across than one that is slightly over-precise in places.
+MONEY = ",.2f"
+
+# `PROBABILITY` came out at a71 with the `tail_df` entry that was its only user.
+
+FORMATS: dict[str, dict[str, object] | str] = {
+    # ---- the Quick Re quote sheet -----------------------------------------
+    #
+    # The one legitimate entry, and the reason the map still exists. This frame
+    # is **this repo's own**, built in `routes.objects.post_reins` out of
+    # `layer_pricing.layer_quotes`, so no library exhibit ships its formats and
+    # dtype inference is the only alternative. Inference reads `ROL` and `LR`
+    # as plain floats and the five currency columns at whatever precision their
+    # magnitude suggests, which is exactly the "a table whose decimal count
+    # moves with the book" problem `MONEY` exists to stop.
+    "reins_quotes": {
+        "EL": MONEY,
+        "SD load": MONEY,
+        "PH": MONEY,
+        "Dual": MONEY,
+        "Min ROL": MONEY,
+        "Premium": MONEY,
+        # `LR` takes the library's own ratio reading, `.1%`. **`ROL` does not**,
+        # and the extra place is load bearing: `layer_pricing.ROL_FIGS` rounds a
+        # rate-on-line quote to four significant figures precisely so the clause
+        # and this sheet agree to the digit, and `.1%` prints a rate of 0.1217
+        # as `12.2%` beside a clause reading `rol 0.1217`. Three places never
+        # hide a figure the clause carries, across both decades a rate on line
+        # occupies: `12.170%` on a working layer and `1.217%` at the top. The
+        # trailing zero is honest about where the rounding fell.
+        "ROL": ".3%",
+        "LR": ".1%",
+        # A multiple, not a percentage, which is why `CV` departs from the
+        # library's `ratio` reading of the same name.
+        "CV": ".3f",
+        "Span": "s",
+        "Binds": "s",
+    },
+    # ---- otherwise empty, and staying that way ----------------------------
+    #
+    # Every entry this map ever held named the formats for a frame whose table
+    # the library publishes as an exhibit, which ships its formats resolved, so
+    # each was this repo asserting how the library's own numbers print.
+    # `summary`, `tail_df`, `validation_df`, `reins_summary_df` and
+    # `bs_window_df` came out at a71; the six pricing sets (`price`,
+    # `reins_price` and the four `stat_*` slices) at a85; the last two,
+    # `sharpen_df` and `sharpen_score`, at a94 when the Sharpen leaf moved
+    # onto the `sharpen` exhibit the library registered at 1.0.0a255.
+    #
+    # The `frame/{which}` route still serves the frames for direct api use; it
+    # renders them by dtype inference, and if that reads badly the answer is to
+    # fetch the exhibit, which is what the app does. Nothing belongs here for a
+    # frame the library publishes an exhibit for; that is what the exhibit is.
+    # A frame this repo builds itself is the exception, which is what the entry
+    # above is: there is no exhibit to fetch.
+}
+
+
+def frame_spec(
+    df: pd.DataFrame, which: str | None = None, formats: str | None = None,
+) -> TableSpec:
+    """The build spec for one named frame.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        The frame, needed here because the row-flag predicates read its index
+        rather than the row values ``TableSpec`` would otherwise hand them.
+    which : str, optional
+        Frame name, used to look up row emphasis in ``ROW_FLAGS``. Unknown and
+        missing names build unflagged.
+    formats : str, optional
+        Key into ``FORMATS``. Separate from ``which`` because several frames
+        share one format set: the four per-distortion slices are all priced the
+        same way.
+
+    Returns
+    -------
+    TableSpec
+        Notes
+        -----
+        ``include_raw`` carries the unrounded value beside the formatted text,
+        which is what lets the interactive grid sort and filter on real numbers.
+        ``irToGridInput`` refuses a document built without it.
+
+        It is the **explicit column list**, not the ``'data'`` shorthand the
+        handoff spec names, and the difference is load bearing: ``'data'`` means
+        numeric, date and bool columns only, so a string data column gets no raw
+        value and the adapter then throws on the whole document. Three of the
+        Price tab's frames carry one (``distortion``, ``param_name``). Naming
+        every column is what makes the two features compose. Reported upstream;
+        see ``dev/TODO.md``.
+
+        Columns absent from a ``FORMATS`` entry are left to the engine, which
+        infers from the dtype. Only the ones whose meaning outruns their dtype
+        need naming.
+
+        There is no ``full_precision`` here since a68. It rebuilt the document
+        with ``formatters={}`` and a wide ``float_format``, which was only ever
+        a way to reprint numbers a client could not reach; ``include_raw`` puts
+        them in every document, so reprinting is the client's to do and costs no
+        round trip. See ``dev/plan-ui-round-5.md``.
+    """
+    flags = ROW_FLAGS.get(which or "")
+    chosen = FORMATS.get(formats or "")
+    if isinstance(chosen, str):
+        columns = {c: chosen for c in df.columns}
+    else:
+        # Filter to what the frame actually has: an Aggregate's pentagon carries
+        # fewer columns than a Portfolio's, and naming an absent one is not an
+        # error worth raising.
+        #
+        # Under a **spanned** header the name to match is the innermost level,
+        # not the whole tuple. `x in df.columns` on a MultiIndex tests the first
+        # level, so a frame whose columns are (component, measure) matched none
+        # of the measure names declared above and quietly fell through to
+        # inference for the whole table. Building the key set from the last
+        # level and mapping back to the full tuples is what makes one
+        # declaration cover `('freq', 'mean')`, `('sev', 'mean')` and
+        # `('agg', 'mean')`, which is right: the format belongs to the measure.
+        wanted = chosen or {}
+        if isinstance(df.columns, pd.MultiIndex):
+            columns = {
+                col: wanted[col[-1]] for col in df.columns if col[-1] in wanted
+            }
+        else:
+            columns = {k: v for k, v in wanted.items() if k in df.columns}
+    return TableSpec(
+        include_raw=list(df.columns),
+        max_rows=MAX_ROWS,
+        row_flags=(lambda pos, _row: flags(df, pos)) if flags else None,
+        # ``formatters``, not ``formats``: the field was renamed somewhere in the
+        # ``greater_tables`` 1.9 to 6.0.0a4 run that the sibling checkout has
+        # moved through. Following the rename is all a37 does about that move;
+        # catching up with the rest of 6.0 is its own piece of work.
+        formatters=columns,
+    )
+
+
+def frame_document(
+    df: pd.DataFrame, which: str | None = None, formats: str | None = None,
+) -> tuple[bytes, str]:
+    """Render a frame as canonical table-document JSON.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        The frame, **with its index intact**. Do not ``reset_index()`` first:
+        the row index is what gets sparsified into stub rowspans, and flattening
+        it into data columns throws away the whole benefit.
+    which : str, optional
+        Frame name, for row emphasis. See ``ROW_FLAGS``.
+    formats : str, optional
+        Format-set key. See ``FORMATS``.
+
+    Returns
+    -------
+    body : bytes
+        Deterministic UTF-8 JSON: the same frame and spec give byte identical
+        output, which is what makes the content hash usable as an ETag.
+    hash : str
+        The document's 12-hex content hash, returned alongside so a caller can
+        set an ETag without parsing the body back.
+
+    Raises
+    ------
+    ValueError
+        If the frame is empty or carries duplicate column names.
+    """
+    if df is None or df.empty:
+        raise ValueError("nothing to render: the frame is empty")
+    if not df.columns.is_unique:
+        # Naming the frame here beats surfacing a library error the caller
+        # cannot place.
+        raise ValueError("frame has duplicate column names")
+    doc = build(df, frame_spec(df, which, formats))
+    return canonical_json(doc), doc.hash
+
+
+def frame_document_dict(
+    df: pd.DataFrame, which: str | None = None, formats: str | None = None
+) -> dict:
+    """``frame_document`` as a parsed object, for embedding in a JSON response.
+
+    The frame routes return the canonical bytes directly, because that is what
+    the ETag hashes. The POST pricing endpoints carry their documents *inside* a
+    Pydantic response, so those need the parsed form.
+    """
+    body, _hash = frame_document(df, which, formats)
+    return json.loads(body)

aggregate_api-1.0.0.dist-info/METADATA

@@ -0,0 +1,187 @@
+Metadata-Version: 2.4
+Name: aggregate_api
+Version: 1.0.0
+Summary: aggregate Loss Lab (aLL): FastAPI service and single-page web app for the aggregate actuarial library.
+Author-email: "Stephen J. Mildenhall" <steve@convexrisk.com>
+Maintainer-email: "Stephen J. Mildenhall" <steve@convexrisk.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/mynl/aggregate_api
+Project-URL: Source Code, https://github.com/mynl/aggregate_api
+Project-URL: Documentation, https://github.com/mynl/aggregate_api#readme
+Project-URL: Changelog, https://github.com/mynl/aggregate_api/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/mynl/aggregate_api/issues
+Keywords: actuarial,insurance,reinsurance,risk,aggregate loss,compound distribution,FFT,pricing,DecL
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Framework :: FastAPI
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aggregate<2,>=1.0.1
+Requires-Dist: greater-tables>=6.0.0
+Requires-Dist: fastapi>=0.115
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pydantic-settings>=2.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Provides-Extra: status
+Requires-Dist: psutil>=5.9; extra == "status"
+Dynamic: license-file
+
+# aggregate_api
+
+**aggregate Loss Lab** (aLL): a FastAPI service and a single-page web app for
+the [`aggregate`](https://github.com/mynl/aggregate) actuarial library.
+*Description to distribution.*
+
+`aggregate_api` is the package; **aggregate Loss Lab** is the app it serves.
+It puts `build()` behind an HTTP/JSON api (DecL parsing, FFT-based compound
+distributions, plotting, and risk pricing) and ships a Bootstrap 5 and
+CodeMirror 6 DecL workbench that runs against it. A single `aggregate-api`
+process serves both the web UI (at `/`) and the JSON endpoints (under `/v1`)
+same-origin.
+
+> **Status:** 1.0.0, the first public release. Extracted from the `aggregate`
+> repo so the library can ship without it. The package is installable and
+> supported; the `/v1` surface is not yet a frozen interface, and the caveat at
+> the end of [Running headless](#running-headless) says why. See
+> [CHANGELOG.md](CHANGELOG.md) for what has landed and
+> [dev/TODO.md](dev/TODO.md) for the roadmap.
+
+## What's inside
+
+- **Backend** (`src/aggregate_api/`): FastAPI app. Object lifecycle
+  (`POST /v1/objects` to build and cache, then `info`, `meta`, `summary`,
+  `tail_df`, `validation_df`, `stats_df`, `density_df`, `plot`, `kappa`,
+  `price`, `pricing_at`, plus `frame/{which}` in CSV or table-document form),
+  DecL helpers (`/v1/decl/complete`, `/lex`,
+  `/format`), and the example library read straight from `aggregate`'s recipe
+  base (`/v1/examples`, `/v1/examples/heroes`). In-memory LRU cache, build
+  timeout, SQLite audit log, CORS. Swagger UI at `/docs`.
+- **Frontend** (`web/`): vanilla-JS SPA (Vite, Bootstrap, CodeMirror 6,
+  `csv-grid`). A DecL editor with syntax highlighting, autocomplete and history,
+  a landing gallery of showcase examples, tabbed risk output, interactive and
+  native plots, and a rich parse-error pane.
+
+### Tables: one payload, two renderers
+
+Every table under 500 rows is fetched once, as a **table document**: versioned
+JSON carrying semantics only (dtypes, resolved formats, hierarchy, spans, flags)
+and no widths or CSS. Both views render from that one document, so they cannot
+disagree about a number:
+
+- **Static** is `greater_tables`' own JS walker, which draws a book-quality table
+  (sparsified row index, spanned headers, partial rules). The walker and its
+  stylesheet are served straight out of the installed Python package at
+  `/v1/assets/`, so the renderer and the documents it renders can never version
+  skew.
+- **Interactive** is `csv-grid`, fed by `irToGridInput(doc)`: sort, per-column
+  filter, fzf search, copy and save.
+
+Which one you get is a page-wide preference in the header menu. Large frames (the
+densities) skip the document entirely and go to the grid, which is the honest
+instrument for them.
+
+## Install
+
+Requires Python ≥ 3.13. Nothing else: `aggregate` ≥ 1.0.1 and
+`greater-tables` ≥ 6.0.0 come from PyPI with it.
+
+```
+pip install aggregate_api
+aggregate-api --port 8001
+```
+
+Then open http://127.0.0.1:8001/ for the app, or http://127.0.0.1:8001/docs for
+the api.
+
+> **Install the wheel, not the repository.** The web bundle is 2.5 MB of
+> generated Vite output and is deliberately not in git, so it reaches you in the
+> built distribution and only there. `pip install git+https://github.com/mynl/aggregate_api`
+> installs a working api whose `/` returns 404, which is a reasonable thing to
+> want if you are putting your own front end in front of the engine, and a
+> baffling one otherwise. The wheel and sdist are also attached to each
+> [GitHub release](https://github.com/mynl/aggregate_api/releases).
+
+One footnote, which the pins above handle for you and which bites anyone
+installing the table engine on its own: PyPI's `greater-tables` 5.3 is a
+previous generation sharing the `greater_tables` import name, so a bare
+`pip install greater-tables` can get a package with no `build`, `canonical_json`
+or `IR_VERSION`, which fails at import rather than at install. This package pins
+`>=6.0.0` and `tests/test_meta.py` asserts the right generation is present.
+
+## Develop
+
+Needs [`uv`](https://docs.astral.sh/uv/) and Node for the web build. A fresh
+clone syncs with nothing checked out beside it.
+
+```
+git clone https://github.com/mynl/aggregate_api
+cd aggregate_api
+uv sync --extra dev
+.\scripts\build-web.ps1          # Windows; ./scripts/build-web.sh on Unix
+uv run aggregate-api --port 8001 --reload
+```
+
+`build-web` drops the bundle into `src/aggregate_api/static/`, which the FastAPI
+`StaticFiles` mount serves at `/`. Until it has run once, `/` has nothing to
+serve. For hot reload with a Vite dev server proxying `/v1` to `:8000`, use
+`cd web; npm install; npm run dev` instead.
+
+To develop against a local checkout of `aggregate` or `greater-tables` rather
+than the released build, install it editable over the synced environment:
+
+```
+uv pip install -e ../aggregate               # or wherever the checkout is
+```
+
+The next `uv sync` silently reinstalls the released build, so `uv run --no-sync`
+is the way to work in between.
+
+Run the tests. There are two suites and both are the gate:
+
+```
+uv run pytest           # 490 tests, FastAPI TestClient, no live server needed
+cd web; npm test        # 277 tests, node --test over web/test/
+```
+
+Rehearse a release, which is a stronger check than either suite because it
+builds the distributions and runs everything against the installed wheel in a
+clean environment:
+
+```
+.\scripts\release-check.ps1
+```
+
+### Running headless
+
+One process serves both halves: the routers mount under `/v1`, and the built web
+bundle is mounted at `/`. To run the engine alone, behind somebody else's front
+end, say so:
+
+```
+uv run aggregate-api --headless           # or AGGAPI_SERVE_SPA=0
+```
+
+`/v1`, `/docs` and `/openapi.json` all stay; only `/` stops answering. A front
+end on another origin also wants `AGGAPI_CORS_ORIGINS`, comma separated:
+
+```
+AGGAPI_CORS_ORIGINS=https://your.app uv run aggregate-api --headless
+```
+
+`/openapi.json` is the contract. Note that the `/v1` surface is pre-1.0 and its
+shape follows what the bundled web app needs, so treat it as a moving target
+rather than a stable interface for now.
+
+## License
+
+BSD 3-Clause. See [LICENSE](LICENSE).

aggregate_api-1.0.0.dist-info/RECORD

@@ -0,0 +1,63 @@
+aggregate_api/__init__.py,sha256=k656-0vnCmNakINSCiCW3q7HlYswEdSV7LyyNjhK_vU,1340
+aggregate_api/__main__.py,sha256=h68CVF82mMY3TlRFCRHQJfMzs3Rd5E4UlF_dBP2jQKA,5672
+aggregate_api/app.py,sha256=TxXHw1MFE603fRz9VoEZgVffbud9wozZ2lH2HX3GmWc,8963
+aggregate_api/audit.py,sha256=wlBpeoy7nZXQID_KGp5HF0XJUYaY9MhZ05YMioCCDtQ,17186
+aggregate_api/bounds.py,sha256=jnNsaxBZTHEinUGDpX3xnO770JurYhCJkMbKQAxD20Y,14753
+aggregate_api/cache.py,sha256=vEIUGko1esJxg0ixHilFZgeqnTfMjFxSRT-CzVkohOQ,12308
+aggregate_api/capability.py,sha256=Q52stFJlKiwVozsCIYgglhaKQalRfOPMID9JDD89kf8,31640
+aggregate_api/completion.py,sha256=dETpa3c9yDBI1fjFwPGyFTpFg6GzHPoBAsL8OnfAiy8,8506
+aggregate_api/config.py,sha256=Q3tgSNG9ebGJjuqcWAo8dnPpPxKBCGzyyZMpXzngSqo,16936
+aggregate_api/cors.py,sha256=fYmGBtpM6tjRctzrA55UXkOMweMFT-prh-2FUjBQ1NU,2537
+aggregate_api/examples.py,sha256=XEWmBwXz77HgYPPDs3xocT7T4rk3Q62muaEy0LhfkFI,27243
+aggregate_api/layer_pricing.py,sha256=wCKulSUVaXUmBjauuTeum2x9odsSo-Jz_DtXyAaMVis,36623
+aggregate_api/library.py,sha256=sYZGqsYV2_d6p3-V54HJSrnjD9dzSugXYyfvER6a_v4,3893
+aggregate_api/library_notes.py,sha256=pB_vPWxM6qVqdppMpi7084IIrdC4slIHAcRmR6dgjYE,3676
+aggregate_api/models.py,sha256=rcyOL1OySucmM52qxGTkzopNqzHHXbIT8ZftJ--NNKE,56889
+aggregate_api/net.py,sha256=wIgpd_dLKY7p765e0N_LNwhnmcc9LhqjIYO0aDWHHHM,10981
+aggregate_api/pnl.py,sha256=61OyheKtRSSA-oaiEyh1qU4slh2TpQbpe4uxrIKPhes,4786
+aggregate_api/pricing.py,sha256=8z6Oz0cJzjTK4Pz6fD6L_f8EBhFhQq4lY7L2Dgr_r_4,35382
+aggregate_api/resources.py,sha256=N__uWH1CoIkblgdJrhO6ugcDXFL2Ids4u8wdUyODTs0,10230
+aggregate_api/serializers.py,sha256=4LOoXkF9gMdcuenbhf3xD8aT7Yr610bwkJ6Nv4X-X_s,23941
+aggregate_api/sessions.py,sha256=eHK1Nr7YDX9miT6P8st-eDAVaE5IUOJu4RUo9OfSEU8,14980
+aggregate_api/status.py,sha256=iZfVt8CItp4tYWGUHEO5BLyXtbnMMe6MRuo693VzsR8,21096
+aggregate_api/status_page.html,sha256=TjJP3kkS_fceBU26aU1k9Iq-H_1J-NsHNxAyhGt67OE,22004
+aggregate_api/tables.py,sha256=17mFbsDtJolS6mHrRrvNWWqfp3fJ7bLYI-381zbm394,15005
+aggregate_api/routes/__init__.py,sha256=piuaQpv5J-swGvFwFOP3AqohJ5JUgMJ992o5ErW1pmE,246
+aggregate_api/routes/decl.py,sha256=Rqn34wl84RSaPmYDjNIfN_zQhchIMHpcd3kEFE2q0kQ,14613
+aggregate_api/routes/examples.py,sha256=MBlmm8Hytd8OVpbA7ZaHiLeehDZxsrUu-cuQzCjJ_0Y,3070
+aggregate_api/routes/meta.py,sha256=TiarkXSrQZBequroDU2_BCP7b8H8JNjHDu3jwAMm0KY,11108
+aggregate_api/routes/objects.py,sha256=k6Mn_NfX9GdVlh5ZoOKDVlrVWKLN6-fb4T-aAmk387U,190715
+aggregate_api/routes/status.py,sha256=l1JtQkumLyCvZzwLKMGt6pMqSse_exTcNB5Xt_flF2M,20331
+aggregate_api/static/aggregate-api-logo-512.png,sha256=IPG-GqRdMmzbLiCZ3IHqvi6-ISHV-h17082Clpc-ML0,204132
+aggregate_api/static/aggregate-api-logo.png,sha256=qM71q7DBAwRITWTP8zr0YYj4dVKkz8PW63-YfoV3LFc,909083
+aggregate_api/static/aggregate-api-trim.png,sha256=9VShrxMcovZINKomb6eqf7lDTNRyr53FplcRtWqodyw,439370
+aggregate_api/static/android-chrome-192x192.png,sha256=pXGYAIQCMoszyIW-T3QRZpnhPeEDFiZv_fOzZm1T_LE,28801
+aggregate_api/static/android-chrome-512x512.png,sha256=7qUmwO6yXtRthgp7QE5VDHzesfMHrukbhDEE6_bfQpY,183910
+aggregate_api/static/apple-touch-icon.png,sha256=ZcMULrusE15EVPWy1rtOFAPcpHWFWb-wUzA6gGtkSh8,26298
+aggregate_api/static/favicon-16x16.png,sha256=bBRfwBovSVLijTJlsRgFWPahSZXhmg6n0_RJ24BuCnE,636
+aggregate_api/static/favicon-32x32.png,sha256=Jqw4IO6U4CUnQI_8vMVnsiMJdKM5OsPpPaGzdm3BEnQ,1456
+aggregate_api/static/favicon.ico,sha256=930lTNx16SzUqifmmTjOXsBcwWcn0QHIkEvgM0zb4rA,4917
+aggregate_api/static/index.html,sha256=nZlvRp06EV3riF1NSWX1Ed3yls_ffOa-bmFIMmbGPck,62604
+aggregate_api/static/lite.html,sha256=0E3hLpL3X8aSQrS0XK8m0BqoACzZPY8GDBEUZ3YwBo8,3989
+aggregate_api/static/logo.png,sha256=IPG-GqRdMmzbLiCZ3IHqvi6-ISHV-h17082Clpc-ML0,204132
+aggregate_api/static/site.webmanifest,sha256=FK0rjGM6nniEoY7TA-4xJ2pDHowNZzaHbB0XiIWOYuA,493
+aggregate_api/static/sw.js,sha256=LtKvw7mL3xPtgZWSf18qsnHgGCZJZSD6NWPwrbjPFb0,3405
+aggregate_api/static/assets/bootstrap-icons-BeopsB42.woff,sha256=9VUTt7WRy4SjuH_w406iTUgx1v7cIuVLkRymS1tUShU,180288
+aggregate_api/static/assets/bootstrap-icons-mSm7cUeB.woff2,sha256=bHVxA2ShylYEJncW9tKJl7JjGf2weM8R4LQqtm_y6mE,134044
+aggregate_api/static/assets/bootstrap-ohb1VZ53.js,sha256=cpwBrnRcJshb--DpvmeJZ9hdZdQIqJb3WLJHs4MC-ik,81694
+aggregate_api/static/assets/codemirror-h62DHGGa.js,sha256=I1GK_BwfQTaM0BD0fAXr4Iv-JjFzfoSDkeNlVh2sCdU,351580
+aggregate_api/static/assets/csv-grid.worker-DKzHGXac.js,sha256=wBxTBubbiXUCRZ1MbGQjZfmxZFTbofeN5Pfc3zvvllA,8384
+aggregate_api/static/assets/echarts-B7o9sc00.js,sha256=vkBuu4yHZTSjpPwqc14zOAEv3R_z2wc3oe-LeJKY22s,610652
+aggregate_api/static/assets/echarts-gl-DG1Uf6wE.js,sha256=bQ96Cfn42OoRsDkob8MxBMK9wdkexSvvgZl7TrM_GUE,601841
+aggregate_api/static/assets/lite-CUlcD8p4.css,sha256=Ez8V80fqbLckwr2lBR0BI9OpOg3bbUZw8U6FOlaseKQ,6948
+aggregate_api/static/assets/lite-Dd2TnT4M.js,sha256=_Fprm777SkLY-ScGwkXoUDo398aVJGSKsczt6veLOE8,7458
+aggregate_api/static/assets/main-Bxhxa55v.css,sha256=yRBfKQrTMrpeQ2Cbj7TCapav7VRILGqsoB5hzOo0CmQ,341088
+aggregate_api/static/assets/main-CmoEiPit.js,sha256=gk0M4PM6Cth17t0gOERMJXD-RDvVqRrX3aV5QUTSsqQ,80404
+aggregate_api/static/assets/tables-BHCF7qIF.js,sha256=FUXaqrUx2BEKdXsCASbTWrD5_CmDbKC_3xeal737Cfc,143283
+aggregate_api/static/assets/tables-CxvajLr7.css,sha256=eLbXm2aU617Z0nNf0_eR3Q7kredW2CcGbub4UIKscu0,6671
+aggregate_api-1.0.0.dist-info/licenses/LICENSE,sha256=8rM_5K4tx-FCI8JUCaGUM1RTdEDbzR2nlIjlj_X7GG0,1536
+aggregate_api-1.0.0.dist-info/METADATA,sha256=uktUHsuhLT80J89rCazQK6t-cWB4h5LYcolfA-ehbJA,8083
+aggregate_api-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+aggregate_api-1.0.0.dist-info/entry_points.txt,sha256=Esuykv5feeGM3pFYFcZTBn_C8tGr9PKGYtSx3cLjqRg,62
+aggregate_api-1.0.0.dist-info/top_level.txt,sha256=wWdJVV1WG7P7g0TGiDG1lVck40S-jtSDM6Y1cKq3idI,14
+aggregate_api-1.0.0.dist-info/RECORD,,

aggregate_api-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aggregate_api-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aggregate-api = aggregate_api.__main__:main

aggregate_api-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Stephen J. Mildenhall
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

aggregate_api-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aggregate_api