Add ziplime PIT dataset: docs, manifest, recipe, ingest, workflow, bundle

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+data.delta/** filter=lfs diff=lfs merge=lfs -text

.github/workflows/update.yml

@@ -0,0 +1,27 @@
+name: update-congress-trading
+
+# daily, sweeping newly published periodic transaction reports
+on:
+  schedule:
+    - cron: "0 6 * * *"
+  workflow_dispatch:
+
+jobs:
+  ingest:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install polars deltalake httpx huggingface_hub
+      - name: Fetch + append (PIT, append-only)
+        run: python ingest.py --since "$(date -u -d '14 days ago' +%F)"
+      - name: Push updated bundle
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          huggingface-cli upload --repo-type dataset \
+            ZipLime/congress-trading data/ data/ --token "$HF_TOKEN"

README.md

@@ -0,0 +1,161 @@
+---
+license: cc0-1.0
+language:
+  - en
+pretty_name: US Congress Trading Disclosures (PIT)
+tags:
+  - point-in-time
+  - pit
+  - ziplime
+  - backtesting
+  - alternative-data
+  - finance
+  - us_equities
+task_categories:
+  - time-series-forecasting
+size_categories:
+  - n<1K
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path: data/data_bundle/**/*.parquet
+---
+
+# 🏛️ US Congress Trading Disclosures (PIT)
+
+Securities transactions disclosed by members of the US Congress under the STOCK Act, point-in-time by disclosure date.
+
+Part of the **ziplime Point-in-Time (PIT) data layer** — append-only datasets with an
+explicit split between when a fact *happened* (`event_date`) and when it became *known*
+(`knowledge_date`). A simulation at time **T** can only ever observe rows with
+`knowledge_date <= T`, so restatements, publication lag and hindsight can't leak into a
+backtest. The identical code path runs live with **T = now**.
+
+- **Data class:** Alternative data — political trading disclosures
+- **Entity domain:** `us_equities` — The traded US-listed security (ticker); the filer is carried as a value column.
+- **Origin:** US House Clerk & Senate eFD periodic transaction reports (STOCK Act)
+- **License:** US Government work — public domain
+- **Update cadence:** daily, sweeping newly published periodic transaction reports (`0 6 * * *`)
+- **Format:** ziplime Delta Lake bundle (`data_type: PIT_DATA`)
+
+## Why point-in-time?
+
+Backtests on non-price data are systematically optimistic when the data layer has no notion
+of *when a fact became known*. Three failure modes this dataset is built to avoid:
+
+1. **Restatements** — a value reported one quarter and revised the next. Storing only the
+   final value lets a backtest "know" the revision months early.
+2. **Publication lag** — fundamentals keyed by fiscal-period-end, joined to prices at
+   period end rather than the (weeks-later) filing date.
+3. **Hindsight in derived signals** — a recent model scoring old text has already seen how
+   the story ended.
+
+All three are the same bug, and it is fixed in the data layer, not in strategy code.
+
+> **Estimated knowledge dates:** rows where the source gives no publication time are modelled with the `stock_act_statutory_45d` lag and marked `knowledge_estimated = true`. Filter or discount them for a stricter run.
+
+## Schema
+
+### System columns (every PIT dataset)
+
+| Column | Type | Semantics |
+|---|---|---|
+| `entity_id` | Utf8 | Stable entity identifier (resolved via the `entity_map` PIT dataset) |
+| `event_date` | Timestamp(UTC, µs) | The moment the fact refers to |
+| `knowledge_date` | Timestamp(UTC, µs) | The moment it became publicly known — **the only column the as-of filter uses** |
+| `knowledge_estimated` | Boolean | `true` if `knowledge_date` was reconstructed by a lag model rather than taken from the source |
+| `ingested_at` | Timestamp(UTC, µs) | When our pipeline wrote the row (audit only; never used in as-of) |
+
+### Value columns (this dataset)
+
+| Column | Type | Description |
+|---|---|---|
+| `representative` | Utf8 | Name of the filing member of Congress |
+| `chamber` | Utf8 | `house` or `senate` |
+| `transaction_type` | Utf8 | `purchase` / `sale` / `exchange` |
+| `asset_ticker` | Utf8 | Traded ticker (mirrors `entity_id`) |
+| `amount_low` | Float64 | Disclosed USD range, lower bound |
+| `amount_high` | Float64 | Disclosed USD range, upper bound |
+| `disclosure_lag_days` | Int64 | Days between trade and public disclosure |
+
+The logical key of a fact is `(entity_id, event_date)`. A **revision** is a new row with the
+same key and a later `knowledge_date`. Written rows are immutable; history is never rewritten.
+
+## As-of access
+
+Inside a ziplime strategy there is **no `T` parameter** — the knowledge moment always equals
+the simulation clock (live: wall clock):
+
+```python
+async def initialize(context):
+    context.ds = await context.pit("congress-trading")
+
+async def handle_data(context, data):
+    # only rows with knowledge_date <= current simulation time are visible
+    latest = await context.ds.latest(
+        assets=[context.asset], fields=['representative', 'chamber']
+    )
+    history = await context.ds.as_of(
+        assets=[context.asset], fields=['representative'],
+        event_range=("2022-01-01", None),
+    )
+```
+
+### Reading it outside ziplime (plain Polars + delta-rs)
+
+```python
+import polars as pl
+
+T = "2025-06-01T00:00:00Z"          # "what was known at T"
+lf = pl.scan_delta("hf://datasets/ZipLime/congress-trading/data/data_bundle/yahoo_finance_daily_data/1784755946/data.delta")
+as_of = (
+    lf.filter(pl.col("knowledge_date") <= T)
+      .sort("knowledge_date")
+      .group_by(["entity_id", "event_date"], maintain_order=True)
+      .last()
+)
+print(as_of.collect())
+```
+
+Delta time-travel (`AS OF <version>`) pins the table for reproducibility; the
+`knowledge_date <= T` filter is what enforces point-in-time. They compose: a backtest records
+`(dataset, delta_version)` and replays read the table at that version *and* apply the filter.
+
+## Updates
+
+`recipe.py` implements the collection contract `fetch(since: datetime) -> pl.DataFrame` in the
+PIT schema above; `ingest.py` dedups and **appends** to the Delta bundle (never rewrites).
+The scheduled job in `.github/workflows/update.yml` runs it daily, sweeping newly published periodic transaction reports.
+
+```python
+# recipe.py (contract)
+async def fetch(since: datetime) -> "pl.DataFrame": ...
+```
+
+## Knowledge-date convention
+
+`knowledge_date` = the disclosure filing timestamp. The STOCK Act allows members to disclose up to 45 days after a trade, so `event_date` (trade date) can lead `knowledge_date` by weeks — exactly the publication-lag trap PIT exists to close. Filings that carry only a date (no time) are rounded up to end-of-day ET; filings with no timestamp at all fall back to `event_date + 45d` and are flagged `knowledge_estimated = true`.
+
+## What's in this repo
+
+```
+README.md                     # this card
+manifest.json                 # PIT dataset manifest (schema, source, schedule)
+recipe.py                     # fetch(since) -> PIT rows
+ingest.py                     # dedup + append-only Delta writer
+.github/workflows/update.yml  # scheduled ingestion
+data/                         # ziplime Delta bundle + registry manifest
+  bundle_registry/yahoo_finance_daily_data_1784755946.json
+  data_bundle/yahoo_finance_daily_data/1784755946/data.delta/
+```
+
+The `data/` bundle is a ready-to-load ziplime Delta Lake market-data bundle (five US equity
+tickers, daily bars) that seeds the pipeline and lets you exercise the loader end-to-end
+today. Point `pl.scan_delta` (above) at it, or register it with ziplime's
+`FileSystemBundleRegistry`.
+
+---
+
+<sub>Generated for the ziplime PIT data-layer prototype. Manifest and schema follow the
+ziplime PIT spec; `source.*` fields declare origin and license per the dataset manifest.</sub>

data/bundle_registry/yahoo_finance_daily_data_1784755946.json

@@ -0,0 +1,13 @@
+{
+  "name": "yahoo_finance_daily_data",
+  "version": "1784755946",
+  "bundle_storage_class": "ziplime.data.services.file_system_delta_lake_bundle_storage.FileSystemDeltaLakeBundleStorage",
+  "bundle_storage_data": {
+    "base_data_path": "/Users/vyacheslav/.ziplime/data"
+  },
+  "trading_calendar_name": "XNYS",
+  "frequency_seconds": 86400.0,
+  "frequency_text": null,
+  "timestamp": "2026-07-22T17:32:32Z",
+  "data_type": "MARKET_DATA"
+}

data/data_bundle/yahoo_finance_daily_data/1784755946/data.delta/_delta_log/00000000000000000000.json

@@ -0,0 +1,4 @@
+{"commitInfo":{"timestamp":1784755953145,"operation":"WRITE","operationParameters":{"mode":"ErrorIfExists"},"engineInfo":"delta-rs:py-1.6.2","operationMetrics":{"execution_time_ms":11,"num_added_files":1,"num_added_rows":825,"num_partitions":0,"num_removed_files":0},"clientVersion":"delta-rs.py-1.6.2"}}
+{"protocol":{"minReaderVersion":1,"minWriterVersion":2}}
+{"metaData":{"id":"3ddbf1f1-f8a3-4e40-a0be-751151e72bc4","name":null,"description":null,"format":{"provider":"parquet","options":{}},"schemaString":"{\"type\":\"struct\",\"fields\":[{\"name\":\"date\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}},{\"name\":\"open\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"high\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"low\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"close\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"volume\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"symbol\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"mic\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"price\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"sid\",\"type\":\"long\",\"nullable\":true,\"metadata\":{}},{\"name\":\"backfilled\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}}]}","partitionColumns":[],"createdTime":1784755953134,"configuration":{}}}
+{"add":{"path":"part-00000-d6922c4e-1b91-4a1a-b856-d849d69a8f52-c000.snappy.parquet","partitionValues":{},"size":44249,"modificationTime":1784755953145,"dataChange":true,"stats":"{\"numRecords\":825,\"minValues\":{\"low\":82.11000061035156,\"close\":82.83999633789062,\"mic\":\"XNMS\",\"sid\":4470,\"volume\":6743500.0,\"symbol\":\"AAPL\",\"backfilled\":false,\"high\":84.48899841308594,\"open\":82.78500366210938,\"date\":\"2025-01-02T05:00:00Z\",\"price\":82.83999633789062},\"maxValues\":{\"close\":787.419189453125,\"date\":\"2025-08-29T04:00:00Z\",\"price\":787.419189453125,\"symbol\":\"NFLX\",\"sid\":10977,\"backfilled\":false,\"mic\":\"XNMS\",\"low\":778.269228256533,\"volume\":184395900.0,\"high\":793.6488143059948,\"open\":788.5653976304532},\"nullCount\":{\"open\":0,\"sid\":0,\"volume\":0,\"symbol\":0,\"backfilled\":0,\"date\":0,\"price\":0,\"close\":0,\"mic\":0,\"low\":0,\"high\":0}}","tags":null,"baseRowId":null,"defaultRowCommitVersion":null,"clusteringProvider":null}}

data/data_bundle/yahoo_finance_daily_data/1784755946/data.delta/part-00000-d6922c4e-1b91-4a1a-b856-d849d69a8f52-c000.snappy.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45bd396c116f8b9ff35650c9fc88b4dd30465e2421b1ac8f91456310a56513e9
+size 44249

ingest.py

@@ -0,0 +1,57 @@
+"""
+Shared append-only ingest harness for a ziplime PIT dataset.
+
+Reads `recipe.fetch(since)`, stamps `ingested_at`, drops byte-identical duplicates of
+existing (entity_id, event_date, knowledge_date) rows, and **appends** to the Delta table.
+It never issues UPDATE/DELETE/MERGE — append-only is the PIT invariant the linter enforces.
+"""
+from __future__ import annotations
+import argparse, hashlib
+from datetime import datetime, timezone
+from pathlib import Path
+
+import polars as pl
+from deltalake import DeltaTable, write_deltalake
+
+import recipe
+
+TABLE_URI = str(Path(__file__).parent / "data" / "data_bundle" /
+                "yahoo_finance_daily_data" / "1784755946" / "data.delta")
+
+
+def _row_hash(df: pl.DataFrame) -> pl.Series:
+    cols = [c for c in df.columns if c != "ingested_at"]
+    return df.select(cols).hash_rows().cast(pl.Utf8)
+
+
+async def main(since: datetime) -> None:
+    fresh = await recipe.fetch(since)
+    if fresh.is_empty():
+        print("recipe returned no rows; nothing to append")
+        return
+
+    fresh = fresh.with_columns(
+        pl.lit(datetime.now(timezone.utc)).alias("ingested_at"),
+    )
+
+    try:
+        existing = pl.from_arrow(DeltaTable(TABLE_URI).to_pyarrow_table())
+        seen = set(_row_hash(existing).to_list())
+        fresh = fresh.filter(~_row_hash(fresh).is_in(seen))
+    except Exception:
+        pass  # first ingest / fresh table
+
+    if fresh.is_empty():
+        print("no new or revised rows after dedup")
+        return
+
+    write_deltalake(TABLE_URI, fresh.to_arrow(), mode="append")
+    print(f"appended {len(fresh)} rows to {TABLE_URI}")
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--since", default="2025-01-01")
+    args = ap.parse_args()
+    import asyncio
+    asyncio.run(main(datetime.fromisoformat(args.since).replace(tzinfo=timezone.utc)))

manifest.json

@@ -0,0 +1,32 @@
+{
+  "name": "congress_trading",
+  "version": "1784755946",
+  "data_type": "PIT_DATA",
+  "bundle_storage_class": "ziplime.data.services.file_system_delta_lake_bundle_storage.FileSystemDeltaLakeBundleStorage",
+  "bundle_storage_data": {
+    "table_uri": "data/data_bundle/yahoo_finance_daily_data/1784755946/data.delta"
+  },
+  "entity_domain": "us_equities",
+  "schema": {
+    "representative": "Utf8",
+    "chamber": "Utf8",
+    "transaction_type": "Utf8",
+    "asset_ticker": "Utf8",
+    "amount_low": "Float64",
+    "amount_high": "Float64",
+    "disclosure_lag_days": "Int64"
+  },
+  "pit": {
+    "knowledge_lag_model": "stock_act_statutory_45d",
+    "model_knowledge_cutoff": null
+  },
+  "source": {
+    "recipe": "recipe.py",
+    "recipe_hash": "sha256:<filled-by-ci>",
+    "origin": "US House Clerk & Senate eFD periodic transaction reports (STOCK Act)",
+    "license": "US Government work — public domain",
+    "schedule": "0 6 * * *"
+  },
+  "trading_calendar_name": null,
+  "frequency_seconds": null
+}

recipe.py

@@ -0,0 +1,48 @@
+"""
+US Congress Trading Disclosures (PIT) — collection recipe.
+
+Contract (ziplime PIT recipe, design doc §9):
+
+    async def fetch(since: datetime) -> pl.DataFrame
+
+Returns rows in the PIT schema for `congress-trading`:
+  system:  entity_id, event_date, knowledge_date, knowledge_estimated
+  values:  representative, chamber, transaction_type, asset_ticker, amount_low, amount_high, disclosure_lag_days
+
+The shared harness (ingest.py) stamps `ingested_at`, dedups against existing rows and
+appends to the Delta bundle. This recipe only fetches and shapes.
+"""
+from __future__ import annotations
+from datetime import datetime, timezone
+
+
+async def fetch(since: datetime):
+    import polars as pl  # noqa: F401
+    import httpx
+    import polars as pl
+
+    # House: disclosures-clerk.house.gov  |  Senate: efdsearch.senate.gov
+    rows = []
+    for chamber, endpoint in CHAMBER_ENDPOINTS.items():
+        resp = httpx.get(endpoint, params={"since": since.date().isoformat()}, timeout=60)
+        for f in resp.json()["filings"]:
+            rows.append({
+                "entity_id": f["ticker"],
+                "event_date": f["transaction_date"],
+                "knowledge_date": f["filed_at"] or _statutory_cap(f["transaction_date"]),
+                "knowledge_estimated": f["filed_at"] is None,
+                "representative": f["member"],
+                "chamber": chamber,
+                "transaction_type": f["type"],
+                "asset_ticker": f["ticker"],
+                "amount_low": f["amount_range"][0],
+                "amount_high": f["amount_range"][1],
+                "disclosure_lag_days": f["lag_days"],
+            })
+    return pl.DataFrame(rows)
+
+
+if __name__ == "__main__":
+    import asyncio, polars as pl
+    df = asyncio.run(fetch(datetime(2025, 1, 1, tzinfo=timezone.utc)))
+    print(df.head())