Update the security master

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 ZipLime
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,14 @@
+ZipLime US Security Master
+Copyright 2026 ZipLime
+
+Source data: US Securities and Exchange Commission — EDGAR filings, the company
+tickers file, and the fails-to-deliver records. US Government works in the
+public domain.
+
+Assembled from the ZipLime insider-trading and company-fundamentals datasets,
+which are themselves derived from EDGAR.
+
+This dataset adds normalization, dated intervals, the CUSIP bridge and
+verification. Those additions are licensed under Apache-2.0 (see LICENSE).
+
+The SEC does not endorse, certify or verify this dataset.

PIPELINE.md

@@ -0,0 +1,131 @@
+# How this dataset is built
+
+Every step is in [`recipe/`](recipe/), published at the same revision as the
+data. This document records what the steps do and what went wrong on the way.
+
+## The idea
+
+A security master is usually bought. The free alternatives are snapshots —
+`company_tickers.json` states today's CIK-to-ticker map and carries no past, so
+a company that changed symbol is listed under the new one for its entire life,
+and every backtest built on it silently reads one company's prices against
+another's fundamentals.
+
+The history exists, though, scattered across filings nobody reads for this
+purpose. Four million Form 4 submissions each print the issuer's trading symbol
+on a known date. Every XBRL filing header carries the company's name, its former
+name and the date it changed. Settlement records tie a CUSIP to a ticker twice
+a month since 2004. Collected with their dates, those are a security master.
+
+So this dataset has almost no source of its own. It is assembled from the
+sibling datasets and from three SEC files, and it publishes the evidence
+alongside the conclusions.
+
+## The ticker box
+
+[`symbols.py`](recipe/symbols.py) exists because 2.3% of Form 4 filings do not
+put a ticker in the ticker box. They put an exchange prefix (`NYSE: KRC`),
+parentheses (`(SIRI)`), two share classes at once (`ISCA, ISCB`, `JWA/JWB`,
+`CRDA CRDB`), a symbol spelled with spaces (`N O G`), a venue note
+(`NWIN(OB)`), a CIK, or a word meaning absence (`NONE`, `N/A`). Read literally
+they become 3 428 tickers that never traded, and Hubbell, Wiley and
+Brown-Forman lose their real symbols.
+
+The parser reaches 98.97% of four million filings; the remainder is genuine
+absence. Two cases in it are worth keeping in mind, because both were bugs
+first:
+
+* `NYSE/TRN` splits into two chunks and the first is a venue, not a
+  four-letter ticker — but `CBOE` alone is Cboe Global Markets, whose ticker is
+  its own name. A venue name is discarded only when some other chunk parsed.
+* `NWIN(OB)` lost its symbol because brackets were stripped before the trailing
+  note was read, turning it into `NWIN(OB` and matching nothing.
+
+## Observations, then spans
+
+Everything collected is a dated statement: *this filer stated this identifier
+on this day*. Ten million of them. The spans in `identifiers` are a groupby over
+that, and nothing more — first observation, last observation, how many, from
+which sources.
+
+The restraint is deliberate. It would be easy to emit `valid_to` as the day
+before the next ticker appeared, which reads better and claims something the
+evidence does not support: nobody publishes the day a ticker changed hands, and
+a filing gap is a filing gap, not a delisting. `observations` ships so that
+anyone who wants stronger intervals can derive them from the same evidence.
+
+## What "current" means
+
+The first definition was "the newest value this filer stated". It made a
+company that stopped filing in 2014 permanently current under its 2014 ticker,
+and when another company later took that ticker over, both were current at
+once — 1 218 tickers, 6% of the live universe, each pointing at two companies.
+
+Now `is_current` also requires the filer to still be filing, and 53 remain.
+Those are genuine: dual filers and reorganisations mid-transfer.
+`is_latest_for_filer` keeps the old meaning, because "what did this company last
+call itself" is a real question about dormant companies, and keying issuer
+attributes on `is_current` would leave every dormant filer nameless.
+
+## The CUSIP bridge
+
+13F and N-PORT name a holding by CUSIP; everything else names a company by CIK.
+The composition is: settlement records give CUSIP to ticker on a date, filings
+give ticker to filer over a span, and the join is on the ticker with the dates
+required to overlap. Overlap is what separates a confident match from a
+plausible one, and it matters precisely for the reused tickers this dataset
+exists to disentangle.
+
+Two things were learned by measuring rather than assuming.
+
+**The count is the wrong measure.** By raw CUSIP count the bridge looked 37%
+complete, which reads like a failure. Against actual 13F holdings the same
+bridge covers 82.8% of holding rows and 87.9% of position value. Two thirds of
+the CUSIPs ever traded are one-off warrants, foreign lines and delisted shells
+that no strategy touches. The build now gates on match rate weighted by
+settlement traffic, excluding funds.
+
+**Exchange-traded funds can never resolve, and that is correct.** `IVV`, `IWM`,
+`SPY` settle like shares and file nothing a CIK could attach to. Counting them
+as misses is what made the bridge look broken. They carry `looks_like_fund` and
+sit outside the gated denominator.
+
+**The first six characters are the issuer.** A CUSIP's prefix identifies the
+company, the suffix the instrument, so a class B share or a preferred of a
+company whose common stock already resolved belongs to the same filer. Saying
+so is a fact about how CUSIPs are assigned, not a guess — but the instrument
+itself was never matched, only its issuer, so it carries its own method and a
+middle confidence. It lifted coverage from 37% to 69% of pairs.
+
+## Verification
+
+[`quality.py`](recipe/quality.py) gates publication. The check that earns its
+place is ambiguity: a ticker current for two filers means somebody's history
+has been attached to the wrong company, and nothing else in the pipeline would
+notice. It caught the `is_current` definition above.
+
+The other floors — ticker coverage among active filers, weighted CUSIP match,
+issuer count — are set below measured values so a regression fails and noise
+does not. All of them were set *after* measuring; the first attempt used
+guessed thresholds, and both guesses were wrong in opposite directions.
+
+## Schedule
+
+A Hugging Face Job runs [`jobs/run.py`](jobs/run.py) weekly on Monday at 07:40
+UTC, after the sibling datasets have refreshed: restore, lint, test, rebuild,
+verify, publish. Weekly rather than daily because the inputs are weekly at
+best — settlement files land twice a month and the sibling datasets are the
+things that move.
+
+## What is not done
+
+* **No history before Form 4.** Ticker evidence effectively starts in 2006.
+  EDGAR does not carry what a company traded as in 1998, so neither does this.
+* **No exchange history worth the name.** Filers rarely name the venue and SEC's
+  current map covers only live listings, so 8 210 spans is all the evidence
+  there is.
+* **No ISIN, no LEI, no FIGI.** 13F carries a FIGI column and N-PORT carries
+  ISIN; neither is ingested yet. The schema has room for them.
+* **No fuzzy name matching.** A CUSIP could often be attached to a filer by
+  comparing issuer names, and a name match that is wrong is indistinguishable
+  from one that is right. Unmatched is more useful than plausibly wrong.

README.md

@@ -0,0 +1,191 @@
+---
+license: apache-2.0
+language:
+  - en
+pretty_name: US Security Master — dated identifiers for SEC filers
+size_categories:
+  - 1M<n<10M
+task_categories:
+  - tabular-classification
+tags:
+  - finance
+  - sec
+  - edgar
+  - security-master
+  - cusip
+  - ticker
+  - point-in-time
+  - survivorship-bias
+  - ziplime
+configs:
+  - config_name: issuers
+    data_files:
+      - split: train
+        path: "data/issuers/*.parquet"
+  - config_name: identifiers
+    data_files:
+      - split: train
+        path: "data/identifiers/*.parquet"
+  - config_name: cusip_map
+    data_files:
+      - split: train
+        path: "data/cusip_map/*.parquet"
+  - config_name: observations
+    data_files:
+      - split: train
+        path: "data/observations/*.parquet"
+  - config_name: pit
+    data_files:
+      - split: train
+        path: "data/pit/*.parquet"
+---
+
+# US Security Master
+
+Which company a ticker belonged to, on a date. Which filer a CUSIP points at.
+What a company used to be called.
+
+**23 529 filers · 143 932 identifier spans · 10 056 033 dated observations ·
+74 392 CUSIPs · 1960 to 2026**
+
+This is the glue for the rest of the family. Every other ZipLime dataset keys
+on the SEC's CIK, which never changes — and every price series, broker feed and
+research note keys on a ticker, which changes all the time. Joining the two
+with today's mapping is the quiet way to put the wrong company's history into a
+backtest.
+
+The pipeline lives in [`recipe/`](recipe/) at the same revision as the data.
+See [PIPELINE.md](PIPELINE.md) for the method and its limits.
+
+## The problem this exists for
+
+| | |
+|---|---|
+| Filers that changed ticker | **6 392** of 23 529 |
+| Filers that changed name | **11 435** |
+| Tickers held by more than one company over time | **2 215** of 26 844 |
+
+A ticker is not an identity. `PLUM` can be one company until 2014 and another
+from 2019, and a strategy that resolves it by today's map reads the second
+company's fundamentals against the first company's prices for the earlier
+years. This dataset says which was which, and when.
+
+```python
+import polars as pl
+
+spans = pl.read_parquet("data/identifiers/*.parquet")
+
+def cik_for(ticker: str, on: str) -> str | None:
+    hit = spans.filter(
+        (pl.col("kind") == "ticker")
+        & (pl.col("value") == ticker)
+        & (pl.col("valid_from") <= pl.lit(on).str.to_date())
+        & (pl.col("valid_to") >= pl.lit(on).str.to_date())
+    ).sort("observations", descending=True)
+    return hit["cik"][0] if hit.height else None
+
+cik_for("FB", "2015-06-30")     # Meta, under its old symbol
+cik_for("META", "2015-06-30")   # None — the symbol did not exist yet
+```
+
+## What a span means, and what it does not
+
+`valid_from` and `valid_to` are the **first and last filing that stated the
+identifier**, not registry dates. Nobody publishes the day a ticker changed
+hands. A gap inside a span means nobody filed, not that the identifier lapsed,
+and `observations` says how much evidence stands behind it.
+
+Two flags answer two different questions:
+
+* `is_latest_for_filer` — the newest value this company gave. Use it to ask
+  *what did this company last call itself*, including companies that stopped
+  filing in 2011.
+* `is_current` — that, **and** the company still files. Use it to ask *who owns
+  this ticker now*. Defining current without the second condition left 1 218
+  tickers current for two companies at once; with it, 53 remain, and those are
+  genuine dual filers.
+
+## The CUSIP bridge
+
+13F and N-PORT identify a holding by CUSIP. Everything else identifies a
+company by CIK. No free source maps between them, so this one is built:
+settlement records tie a CUSIP to a ticker on a date, filings tie a ticker to a
+filer over a span, and the two compose.
+
+| Match | Rows | Meaning |
+|---|---|---|
+| `ticker_and_dates` | 22 921 | the ticker matched and the dates overlap — **high** |
+| `cusip6_inherited` | 23 519 | another security of the same issuer resolved — **medium** |
+| `ticker_only` | 4 747 | the ticker matched, the dates do not overlap — **low** |
+| `unmatched` | 23 205 | no filer found — **none** |
+
+**68.8% of CUSIP-ticker pairs resolve to a filer; 78.8% weighted by how often
+the CUSIP appears in settlement records.** Measured against real 13F holdings,
+the matched set covers **82.8% of holding rows and 87.9% of position value.**
+
+Counting raw CUSIPs understates it badly, and the reason is worth knowing:
+10 536 of these are exchange-traded funds. An ETF settles like a share and
+files nothing a CIK could attach to — `IVV`, `IWM`, `SPY` will never resolve to
+an operating company, because they are not one. They carry
+`looks_like_fund = true` and are excluded from the coverage the build gates on.
+
+```python
+bridge = pl.read_parquet("data/cusip_map/*.parquet")
+holdings = holdings.join(
+    bridge.filter(pl.col("match_confidence").is_in(["high", "medium"]))
+          .select("cusip", "cik"),
+    on="cusip", how="left",
+)   # now 13F joins to fundamentals and insider trades on `cik`
+```
+
+## Configs
+
+| Config | Rows | What one row is |
+|---|---|---|
+| `issuers` | 23 529 | one filer: current name, ticker, industry, and how long it has filed |
+| `identifiers` | 143 932 | one identifier and the span of filings that stated it |
+| `cusip_map` | 74 392 | one CUSIP, the ticker it settles under, the filer behind it |
+| `observations` | 10 056 033 | one dated statement — the evidence the spans are built from |
+| `pit` | 143 932 | one point-in-time identifier event, plus a Delta table for ziplime |
+
+`observations` is published so that anyone who disagrees with how the spans
+were derived can derive their own. It is the only honest way to ship a
+judgement.
+
+## Where the evidence comes from
+
+| Source | Observations | What it gives |
+|---|---|---|
+| Form 4 filings, via [ZipLime/insider-trading](https://huggingface.co/datasets/ZipLime/insider-trading) | 8 123 634 | the ticker a company printed on a filing, on that day — the only free source of ticker **history** |
+| XBRL filings, via [ZipLime/company-fundamentals](https://huggingface.co/datasets/ZipLime/company-fundamentals) | 1 901 363 | names, former names with change dates, industry, incorporation, fiscal year end |
+| SEC `company_tickers_exchange.json` | 31 036 | today's listings, including companies that never filed a Form 4 |
+| SEC fails-to-deliver records, 409 archives | 23.4M records | CUSIP to ticker, twice a month since 2004 |
+
+`company_tickers.json` alone is what most projects use, and it is a snapshot:
+it states today and carries no past, so a company that changed symbol appears
+under the new one for its entire life. The history here comes from four million
+filings that each stated a symbol on a known date.
+
+## Coverage and honest gaps
+
+* **81% of filers have a ticker; 93% of *active* filers do.** The rest are
+  funds, trusts and private filers that never printed one.
+* **Exchange is sparse** — 8 210 spans. Filers rarely name the venue, and SEC's
+  current map only covers live listings.
+* **Coverage starts in 1960** only because a filing header stated a name change
+  from then. Ticker evidence effectively begins in 2006 with Form 4, and
+  identifiers before that are not in EDGAR to be found.
+* **A span is evidence, not a registry.** See above.
+* **Fund CUSIPs do not resolve, by construction.** See above.
+* **53 tickers are current for two filers.** Dual filers and reorganisations
+  mid-transfer; the raw observations let you decide.
+
+## Provenance and updates
+
+Sources: SEC EDGAR (Form 4 and XBRL filings, both via sibling ZipLime
+datasets), `company_tickers_exchange.json`, and the fails-to-deliver
+files — all US Government works in the public domain.
+
+Rebuilt weekly, Monday 07:40 UTC, by a Hugging Face Job
+([`jobs/run.py`](jobs/run.py)) that lints, tests, rebuilds, verifies and only
+then publishes.

data/cusip_map/part-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95487d6e87e1011036a6460a202f7c079181b2a9d767a58e0882cd992d719f98
+size 1831699

data/identifiers/part-00000.parquet

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

data/issuers/part-00000.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9dcfd2a8ad81fe183786fa06a8b6f85f7d259e436c23068145c9e621e4678439
+size 689716

data/observations/part-00000.parquet

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

data/observations/part-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b465a9ab6ba2add257bd56e5232539e5c5c1f43af40a7d27f4dfb437ee66d42
+size 29983873

data/observations/part-00002.parquet

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

data/pit/part-00000.parquet

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

data/pit/security_master.delta/_delta_log/00000000000000000000.json

@@ -0,0 +1,4 @@
+{"commitInfo":{"timestamp":1788775777234,"operation":"WRITE","operationParameters":{"mode":"Overwrite"},"engineInfo":"delta-rs:py-1.6.2","operationMetrics":{"execution_time_ms":186,"num_added_files":1,"num_added_rows":143932,"num_partitions":0,"num_removed_files":0},"clientVersion":"delta-rs.py-1.6.2"}}
+{"protocol":{"minReaderVersion":1,"minWriterVersion":2}}
+{"metaData":{"id":"5d33a43b-fb97-493d-bc98-f8852636a368","name":null,"description":null,"format":{"provider":"parquet","options":{}},"schemaString":"{\"type\":\"struct\",\"fields\":[{\"name\":\"pit_event_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"entity_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"event_date\",\"type\":\"date\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_date\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_estimated\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"kind\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"value\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"valid_to\",\"type\":\"date\",\"nullable\":true,\"metadata\":{}},{\"name\":\"observations\",\"type\":\"integer\",\"nullable\":true,\"metadata\":{}},{\"name\":\"sources\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"is_current\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"ingested_at\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}}]}","partitionColumns":[],"createdTime":1788775777052,"configuration":{}}}
+{"add":{"path":"part-00000-84bed2a2-6ab3-4b85-bb3d-e89904eeb1d4-c000.snappy.parquet","partitionValues":{},"size":5114932,"modificationTime":1788775777232,"dataChange":true,"stats":"{\"numRecords\":143932,\"minValues\":{\"sources\":\"company_tickers\",\"is_current\":false,\"event_date\":\"1960-02-01\",\"value\":\"'MKTG, INC.'\",\"knowledge_date\":\"1960-02-01T23:59:59Z\",\"observations\":1,\"knowledge_estimated\":true,\"ingested_at\":\"2026-09-07T10:09:36.452570Z\",\"kind\":\"exchange\",\"pit_event_id\":\"0000000017|name|DEFINED ASSET FUNDS MUNICIPAL INVT TR FD MON PYM\",\"entity_id\":\"0000000017\",\"valid_to\":\"1960-02-01\"},\"maxValues\":{\"kind\":\"ticker\",\"is_current\":true,\"event_date\":\"2026-09-07\",\"pit_event_id\":\"0002151905|ticker|LABI|2026-09-07\",\"ingested_at\":\"2026-09-07T10:09:36.452570Z\",\"knowledge_estimated\":true,\"knowledge_date\":\"2026-09-07T23:59:59Z\",\"value\":\"zulily, inc.\",\"entity_id\":\"0002151905\",\"valid_to\":\"2026-09-07\",\"observations\":12865,\"sources\":\"xbrl\"},\"nullCount\":{\"entity_id\":0,\"value\":0,\"valid_to\":0,\"is_current\":0,\"ingested_at\":0,\"kind\":0,\"knowledge_date\":0,\"event_date\":0,\"sources\":0,\"knowledge_estimated\":0,\"observations\":0,\"pit_event_id\":0}}","tags":null,"baseRowId":null,"defaultRowCommitVersion":null,"clusteringProvider":null}}

data/pit/security_master.delta/part-00000-84bed2a2-6ab3-4b85-bb3d-e89904eeb1d4-c000.snappy.parquet

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

jobs/run.py

@@ -0,0 +1,107 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#   "httpx>=0.27,<1",
+#   "polars>=1.24,<2",
+#   "pyarrow>=18,<21",
+#   "deltalake>=0.22,<2",
+#   "huggingface-hub>=1.19,<2",
+#   "pytest>=8,<9",
+#   "pytest-asyncio>=0.24,<1",
+#   "ruff>=0.11,<1",
+#   "pyyaml>=6,<7",
+# ]
+# ///
+"""Hugging Face Jobs entry point for the ZipLime security-master dataset.
+
+    restore repository -> lint -> tests -> build -> verify -> publish
+
+The build reads two sibling datasets from the Hub. That is the point of this
+one: it is glue, and what it says has to be derivable from what the others
+published, not from a working copy that only exists on somebody's laptop.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+DEFAULT_REPO = "ZipLime/security-master"
+DEFAULT_WORKSPACE = "/tmp/security-master"
+
+
+def log(message: str) -> None:
+    print(f"[security-master] {message}", flush=True)
+
+
+def restore_repository(repo_id: str, token: str | None, workspace: Path) -> Path:
+    from huggingface_hub import snapshot_download
+    from huggingface_hub.errors import RepositoryNotFoundError
+
+    workspace.mkdir(parents=True, exist_ok=True)
+    try:
+        snapshot_download(
+            repo_id=repo_id, repo_type="dataset", token=token, local_dir=str(workspace),
+            # Only the recipe and tests are needed: every table is rebuilt from
+            # the sources each run, so restoring the data would download tens of
+            # megabytes to overwrite them.
+            allow_patterns=["recipe/**", "tests/**", "jobs/**", "*.md", "*.json", "*.toml"],
+        )
+        log(f"restored {repo_id} into {workspace}")
+    except RepositoryNotFoundError:
+        log(f"{repo_id} does not exist yet; treating this as the first publication")
+    if not (workspace / "recipe" / "cli.py").is_file():
+        raise SystemExit(f"{workspace} has no recipe; publish it before scheduling a Job")
+    return workspace
+
+
+def run(command: list[str], *, cwd: Path, env: dict[str, str]) -> int:
+    log(f"running: {' '.join(command)}")
+    return subprocess.run(command, cwd=cwd, env=env, check=False).returncode
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mode", choices=["update", "build"], default="update")
+    parser.add_argument("--ftd-limit", default=None)
+    parser.add_argument("--workspace", default=os.environ.get("JOB_WORKSPACE", DEFAULT_WORKSPACE))
+    parser.add_argument("--skip-gates", action="store_true")
+    args = parser.parse_args(argv)
+
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        raise SystemExit("the HF_TOKEN secret is required")
+    if not os.environ.get("SEC_USER_AGENT"):
+        raise SystemExit("the SEC_USER_AGENT secret is required")
+    repo_id = os.environ.get("HF_DATASET_REPO", DEFAULT_REPO)
+
+    workspace = restore_repository(repo_id, token, Path(args.workspace))
+    env = {**os.environ, "PYTHONPATH": str(workspace), "DATA_DIR": "data"}
+
+    if not args.skip_gates:
+        for name, command in (("lint", ["ruff", "check", "."]), ("tests", ["pytest", "-q"])):
+            code = run(command, cwd=workspace, env=env)
+            if code != 0:
+                log(f"{name} failed; nothing was fetched and nothing was published")
+                return code
+
+    build = [sys.executable, "-m", "recipe.cli", "build"]
+    if args.ftd_limit:
+        build += ["--ftd-limit", str(args.ftd_limit)]
+    code = run(build, cwd=workspace, env=env)
+    if code != 0:
+        log("build or verification failed; nothing published")
+        return code
+    if args.mode == "build":
+        return 0
+    return run(
+        [sys.executable, "-m", "recipe.cli", "publish", "--repo", repo_id],
+        cwd=workspace, env=env,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

manifest.json

@@ -0,0 +1,155 @@
+{
+  "bundle_storage_class": "ziplime.data.services.file_system_delta_lake_bundle_storage.FileSystemDeltaLakeBundleStorage",
+  "bundle_storage_data": {
+    "table_uri": "data/pit/security_master.delta"
+  },
+  "config_rows": {
+    "cusip_map": 74392,
+    "identifiers": 143932,
+    "issuers": 23529,
+    "observations": 10056033,
+    "pit": 143932
+  },
+  "config_schemas": {
+    "cusip_map": {
+      "cik": "String",
+      "cusip": "String",
+      "cusip6": "String",
+      "first_seen": "Date",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "issuer_name": "String",
+      "last_seen": "Date",
+      "looks_like_fund": "Boolean",
+      "match_confidence": "String",
+      "match_method": "String",
+      "observations": "Int32",
+      "ticker": "String"
+    },
+    "identifiers": {
+      "cik": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_current": "Boolean",
+      "is_latest_for_filer": "Boolean",
+      "kind": "String",
+      "observations": "Int32",
+      "rank_within_kind": "Int32",
+      "sources": "String",
+      "valid_from": "Date",
+      "valid_to": "Date",
+      "value": "String"
+    },
+    "issuers": {
+      "all_tickers": "String",
+      "cik": "String",
+      "exchange": "String",
+      "filings_observed": "Int32",
+      "first_seen": "Date",
+      "fiscal_year_end": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_active": "Boolean",
+      "last_seen": "Date",
+      "name": "String",
+      "name_changes": "Int32",
+      "primary_ticker": "String",
+      "sic": "String",
+      "state_incorporated": "String",
+      "ticker_changes": "Int32"
+    },
+    "observations": {
+      "cik": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "kind": "String",
+      "observed_on": "Date",
+      "source": "String",
+      "source_ref": "String",
+      "value": "String"
+    },
+    "pit": {
+      "entity_id": "String",
+      "event_date": "Date",
+      "ingested_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_current": "Boolean",
+      "kind": "String",
+      "knowledge_date": "Datetime(time_unit='us', time_zone='UTC')",
+      "knowledge_estimated": "Boolean",
+      "observations": "Int32",
+      "pit_event_id": "String",
+      "sources": "String",
+      "valid_to": "Date",
+      "value": "String"
+    }
+  },
+  "configs": {
+    "cusip_map": {
+      "grain": "one CUSIP, the ticker it settles under and the filer behind it",
+      "path": "data/cusip_map/**/*.parquet"
+    },
+    "identifiers": {
+      "grain": "one identifier and the span of filings that stated it",
+      "path": "data/identifiers/**/*.parquet"
+    },
+    "issuers": {
+      "grain": "one SEC filer, with what it is called now and how long it has filed",
+      "path": "data/issuers/**/*.parquet"
+    },
+    "observations": {
+      "grain": "one dated statement that an identifier belonged to a filer",
+      "path": "data/observations/**/*.parquet"
+    },
+    "pit": {
+      "delta_path": "data/pit/security_master.delta",
+      "grain": "one point-in-time identifier knowledge event",
+      "path": "data/pit/**/*.parquet"
+    }
+  },
+  "coverage": {
+    "max_observation": "2026-09-07",
+    "min_observation": "1960-02-01"
+  },
+  "data_type": "PIT_DATA",
+  "dataset": "security-master",
+  "entity_domain": "us_equities",
+  "entity_id": "issuer_cik",
+  "event_date": "valid_from",
+  "event_date_type": "date",
+  "frequency_seconds": null,
+  "generated_at": "2026-09-07T10:19:29.410389+00:00",
+  "identifier_kinds": [
+    "ticker",
+    "name",
+    "former_name",
+    "exchange",
+    "sic",
+    "cusip",
+    "figi"
+  ],
+  "knowledge_date": "observed_on",
+  "knowledge_date_policy": {
+    "never_before_event_date": true,
+    "precision": "day; the underlying filings carry a time but settlement records do not, and mixing precisions would imply certainty the coarser source lacks",
+    "primary": "end of the day an identifier was first observed in a filing"
+  },
+  "knowledge_date_type": "timestamp[us, tz=UTC]",
+  "name": "security_master",
+  "pit": {
+    "append_only": false,
+    "knowledge_lag_model": "filing_date_end_of_day",
+    "restatement_policy": "spans are rebuilt from the full observation history on every run; the observations config is the evidence layer"
+  },
+  "pretty_name": "ZipLime US Security Master (PIT)",
+  "quality_ok": true,
+  "rows": 143932,
+  "source": {
+    "build_version": "1.0.0",
+    "coverage_note": "Ticker evidence effectively begins in 2006 with Form 4; earlier dates come from name-change fields in filing headers.",
+    "coverage_start": "1960-02-01",
+    "license": "US Government work — public domain",
+    "origin": "SEC EDGAR Form 4 and XBRL filings (via ZipLime/insider-trading and ZipLime/company-fundamentals), company_tickers_exchange.json, and SEC fails-to-deliver records",
+    "package_version": "1.0.0",
+    "recipe": "recipe/",
+    "recipe_hash": "sha256:3ba230dcb310ad04a7466a2976f2db1a7a346e451df0078feae0f0108a1edb41",
+    "schedule": "40 7 * * 1"
+  },
+  "trading_calendar_name": null,
+  "version": "1.0.0"
+}

pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=75", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ziplime-security-master"
+version = "1.0.0"
+description = "Point-in-time US security master: dated tickers, names and the CUSIP bridge"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "Apache-2.0"}
+authors = [{name = "ZipLime"}]
+dependencies = [
+  "httpx>=0.27,<1",
+  "polars>=1.24,<2",
+  "pyarrow>=18,<21",
+  "deltalake>=0.22,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8,<9",
+  "pytest-asyncio>=0.24,<1",
+  "ruff>=0.11,<1",
+  "pyyaml>=6,<7",
+]
+publish = ["huggingface-hub>=1.19,<2"]
+
+[project.scripts]
+ziplime-security-master = "recipe.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["recipe*"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+extend-exclude = ["data", ".cache"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+ignore = ["E501"]

recipe/__init__.py

@@ -0,0 +1,3 @@
+"""US security master: dated identifiers for SEC filers, and the CUSIP bridge."""
+
+__version__ = "1.0.0"

recipe/build.py

@@ -0,0 +1,111 @@
+"""Collect observations, derive the tables, write them out."""
+
+from __future__ import annotations
+
+import logging
+import shutil
+from datetime import UTC, datetime
+from pathlib import Path
+
+import polars as pl
+
+from .config import Settings
+from .intervals import build_cusip_map, build_identifiers, build_issuers, build_pit
+from .schema import CONFIG_SCHEMAS, align
+from .sources import (
+    from_company_tickers,
+    from_fundamental_filings,
+    from_ownership_filings,
+    ftd_archives,
+    parse_ftd,
+)
+from .store import atomic_write_parquet
+
+LOGGER = logging.getLogger(__name__)
+
+PIT_DELTA_NAME = "security_master.delta"
+# Rows per output file. The tables are small next to the datasets they glue
+# together, so one file per table is right until observations outgrow memory.
+MAX_ROWS_PER_FILE = 5_000_000
+
+
+def _write(data_dir: Path, table: str, frame: pl.DataFrame) -> int:
+    root = Path(data_dir) / table
+    if root.exists():
+        shutil.rmtree(root)
+    root.mkdir(parents=True, exist_ok=True)
+    frame = align(frame, CONFIG_SCHEMAS[table])
+    if frame.is_empty():
+        atomic_write_parquet(frame, root / "part-00000.parquet")
+        return 0
+    for index, start in enumerate(range(0, frame.height, MAX_ROWS_PER_FILE)):
+        atomic_write_parquet(
+            frame.slice(start, MAX_ROWS_PER_FILE), root / f"part-{index:05d}.parquet"
+        )
+    return frame.height
+
+
+async def collect_ftd(client, *, limit: int | None = None) -> pl.DataFrame:
+    """Every settlement record SEC currently publishes, as CUSIP-ticker pairs."""
+    urls = await ftd_archives(client)
+    if limit:
+        urls = urls[-limit:]
+    LOGGER.info("fails-to-deliver archives: %d", len(urls))
+    rows: list[dict] = []
+    for index, url in enumerate(urls, 1):
+        try:
+            payload = await client.get_bytes(url, timeout=180.0)
+        except Exception as exc:  # a withdrawn file is not a reason to stop
+            LOGGER.warning("skipping %s (%s)", url.rsplit("/", 1)[-1], type(exc).__name__)
+            continue
+        rows.extend(parse_ftd(payload, source_ref=url.rsplit("/", 1)[-1]))
+        if index % 40 == 0:
+            LOGGER.info("  %d/%d archives, %d records", index, len(urls), len(rows))
+    if not rows:
+        return pl.DataFrame(schema={"cusip": pl.String, "ticker": pl.String,
+                                    "issuer_name": pl.String, "observed_on": pl.Date,
+                                    "source_ref": pl.String})
+    return pl.DataFrame(rows, strict=False)
+
+
+async def run_build(
+    *, settings: Settings, token: str | None = None, ftd_limit: int | None = None
+) -> dict[str, int]:
+    from .sec_client import SECClient
+
+    data_dir = Path(settings.data_dir)
+    observations = [
+        from_ownership_filings(settings, token=token),
+        from_fundamental_filings(settings, token=token),
+    ]
+
+    async with SECClient(
+        user_agent=settings.sec_user_agent,
+        cache_dir=settings.cache_dir,
+        requests_per_second=settings.requests_per_second,
+    ) as client:
+        observations.append(await from_company_tickers(client))
+        ftd = await collect_ftd(client, limit=ftd_limit)
+
+    frame = pl.concat(observations, how="vertical_relaxed")
+    LOGGER.info("observations: %d from %d sources", frame.height, frame["source"].n_unique())
+
+    identifiers = build_identifiers(frame)
+    issuers = build_issuers(identifiers, frame)
+    cusip_map = build_cusip_map(ftd, identifiers)
+    pit = build_pit(identifiers)
+
+    counts = {
+        "observations": _write(data_dir, "observations", frame),
+        "identifiers": _write(data_dir, "identifiers", identifiers),
+        "issuers": _write(data_dir, "issuers", issuers),
+        "cusip_map": _write(data_dir, "cusip_map", cusip_map),
+        "pit": _write(data_dir, "pit", pit),
+    }
+    delta = data_dir / "pit" / PIT_DELTA_NAME
+    if delta.exists():
+        shutil.rmtree(delta)
+    if not pit.is_empty():
+        align(pit, CONFIG_SCHEMAS["pit"]).write_delta(str(delta), mode="overwrite")
+    LOGGER.info("built %s at %s", counts, datetime.now(UTC).isoformat(timespec="seconds"))
+    return counts

recipe/cli.py

@@ -0,0 +1,77 @@
+"""Command line for the security master recipe."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+from pathlib import Path
+
+from .build import run_build
+from .config import Settings
+from .manifest import build_manifest
+from .quality import validate
+from .store import config_row_counts
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="security-master", description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    build = sub.add_parser("build", help="collect observations and write every table")
+    build.add_argument("--ftd-limit", type=int, default=None,
+                       help="use only the newest N fails-to-deliver archives")
+
+    verify = sub.add_parser("verify", help="run the quality gate and write the manifest")
+    verify.add_argument("--strict", action="store_true")
+
+    publish = sub.add_parser("publish", help="mirror the built tree to Hugging Face")
+    publish.add_argument("--repo", default=None)
+
+    args = parser.parse_args(argv)
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s | %(message)s"
+    )
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    settings = Settings.from_env()
+
+    data_dir = Path(settings.data_dir)
+
+    if args.command == "build":
+        counts = asyncio.run(run_build(settings=settings, ftd_limit=args.ftd_limit))
+        report = validate(data_dir)
+        report.write(data_dir.parent / "quality_report.json")
+        build_manifest(data_dir=data_dir, row_counts=counts, quality_ok=report.ok)
+        print(json.dumps({"rows": counts, "quality_ok": report.ok,
+                          "errors": report.errors, "warnings": report.warnings}, indent=2))
+        return 0 if report.ok else 1
+
+    if args.command == "verify":
+        report = validate(data_dir)
+        report.write(data_dir.parent / "quality_report.json")
+        build_manifest(
+            data_dir=data_dir, row_counts=config_row_counts(data_dir), quality_ok=report.ok
+        )
+        print(json.dumps(report.as_dict(), indent=2, default=str))
+        return 0 if report.ok else 1
+
+    if args.command == "publish":
+        from .publish import hf_token, publish_to_hf
+
+        report = validate(data_dir)
+        if not report.ok:
+            print(json.dumps({"quality_ok": False, "errors": report.errors}, indent=2))
+            return 1
+        commit = publish_to_hf(
+            project_root=data_dir.resolve().parent,
+            repo_id=args.repo or settings.hf_repo,
+            token=hf_token(),
+        )
+        print(json.dumps({"commit": commit}, indent=2))
+        return 0
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

recipe/config.py

@@ -0,0 +1,57 @@
+"""Runtime configuration with SEC-safe defaults."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_SEC_USER_AGENT = "ZipLime security-master/1.0 algo@limex.com"
+DEFAULT_HF_REPO = "ZipLime/security-master"
+
+# The sibling datasets this one is assembled from. It is glue: it has almost no
+# source of its own, and every identifier in it was stated in a filing that one
+# of these already parsed and published.
+SOURCE_REPOS = {
+    "insider": "ZipLime/insider-trading",
+    "fundamentals": "ZipLime/company-fundamentals",
+    "institutional": "ZipLime/institutional-portfolio-13f",
+}
+
+# Where a local checkout of a sibling lives, for iterating without downloading
+# gigabytes. `SECURITY_MASTER_SIBLINGS=/path/to/hf` makes the build read
+# `/path/to/hf/Insider_trading/data` instead of the Hub.
+SIBLING_DIRS = {
+    "insider": "Insider_trading",
+    "fundamentals": "Company_fundamentals",
+    "institutional": "Institutional_portfolio_13f",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Settings:
+    data_dir: Path = Path("data")
+    cache_dir: Path = Path(".cache/sec")
+    sec_user_agent: str = DEFAULT_SEC_USER_AGENT
+    requests_per_second: float = 4.0
+    hf_repo: str = DEFAULT_HF_REPO
+    siblings_dir: Path | None = None
+
+    @classmethod
+    def from_env(cls, **overrides) -> Settings:
+        siblings = os.environ.get("SECURITY_MASTER_SIBLINGS")
+        return cls(
+            data_dir=Path(overrides.get("data_dir") or os.environ.get("DATA_DIR", "data")),
+            cache_dir=Path(overrides.get("cache_dir") or os.environ.get("SEC_CACHE_DIR", ".cache/sec")),
+            sec_user_agent=os.environ.get("SEC_USER_AGENT", DEFAULT_SEC_USER_AGENT),
+            requests_per_second=float(os.environ.get("SEC_REQUESTS_PER_SECOND", "4")),
+            hf_repo=overrides.get("hf_repo") or os.environ.get("HF_DATASET_REPO", DEFAULT_HF_REPO),
+            siblings_dir=Path(siblings) if siblings else None,
+        )
+
+
+def validate_sec_user_agent(value: str) -> str:
+    cleaned = (value or "").strip()
+    if "@" not in cleaned or len(cleaned) < 12:
+        raise ValueError(f"SEC requires a User-Agent with a contact address, got {value!r}")
+    return cleaned

recipe/hf_jobs.py

@@ -0,0 +1,228 @@
+"""Declarative management of the Hugging Face Jobs that run this recipe.
+
+Scheduling lives on Hugging Face rather than in an external CI system: the data,
+the recipe revision, and the compute that produces them stay in one place, and a
+job is not bound by an external runner's disk or wall-clock limits.
+
+The scheduled job executes a UV script published in this same dataset
+repository, so the code that produced a revision is always recoverable from the
+revision itself.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .config import DEFAULT_HF_REPO, validate_sec_user_agent
+
+# The work is downloading the sibling datasets and four hundred settlement
+# archives, then a few minutes of grouping. Memory is modest; bandwidth is not.
+UPDATE_FLAVOR = "cpu-upgrade"
+BACKFILL_FLAVOR = "cpu-upgrade"
+UPDATE_TIMEOUT = "3h"
+BACKFILL_TIMEOUT = "4h"
+# Monday 07:40 UTC, half an hour after the fundamentals rebuild: this dataset
+# reads that one's output, and reading yesterday's revision would publish a
+# security master that lags its own sources by a week.
+DEFAULT_SCHEDULE = "40 7 * * 1"
+# One self-contained UV script serves both modes: a Job downloads a single file.
+JOB_SCRIPT = "jobs/run.py"
+UPDATE_JOB_NAME = "security-master-update"
+BACKFILL_JOB_NAME = "security-master-rebuild"
+
+
+def script_url(
+    *, repo_id: str = DEFAULT_HF_REPO, script: str = JOB_SCRIPT, revision: str = "main"
+) -> str:
+    return f"https://huggingface.co/datasets/{repo_id}/resolve/{revision}/{script}"
+
+
+@dataclass(frozen=True, slots=True)
+class JobSpec:
+    """Everything needed to launch or schedule one run, minus the credentials."""
+
+    script: str
+    script_url: str
+    flavor: str
+    timeout: str
+    script_args: tuple[str, ...]
+    env: dict[str, str]
+    name: str
+
+    def as_kwargs(self, *, secrets: dict[str, str]) -> dict[str, Any]:
+        """Build the huggingface_hub call arguments.
+
+        The Jobs API takes no ``name`` parameter; a job's display name is the
+        ``name`` label. Credentials go through ``secrets`` so they are encrypted
+        server side instead of travelling as plain environment variables.
+        """
+
+        return {
+            "script": self.script_url,
+            "script_args": list(self.script_args),
+            "flavor": self.flavor,
+            "timeout": self.timeout,
+            "env": dict(self.env),
+            "secrets": secrets,
+            "labels": {"name": self.name, "project": "insider-trading"},
+        }
+
+
+def update_spec(
+    *,
+    repo_id: str = DEFAULT_HF_REPO,
+    revision: str = "main",
+    flavor: str = UPDATE_FLAVOR,
+    timeout: str = UPDATE_TIMEOUT,
+) -> JobSpec:
+    return JobSpec(
+        script=JOB_SCRIPT,
+        script_url=script_url(repo_id=repo_id, revision=revision),
+        flavor=flavor,
+        timeout=timeout,
+        script_args=("--mode", "update"),
+        env={"HF_DATASET_REPO": repo_id},
+        name=UPDATE_JOB_NAME,
+    )
+
+
+def backfill_spec(
+    *,
+    repo_id: str = DEFAULT_HF_REPO,
+    revision: str = "main",
+    start: str | None = None,
+    end: str | None = None,
+    flavor: str = BACKFILL_FLAVOR,
+    timeout: str = BACKFILL_TIMEOUT,
+) -> JobSpec:
+    args = ["--mode", "build"]
+    _ = (start, end)
+    return JobSpec(
+        script=JOB_SCRIPT,
+        script_url=script_url(repo_id=repo_id, revision=revision),
+        flavor=flavor,
+        timeout=timeout,
+        script_args=tuple(args),
+        env={"HF_DATASET_REPO": repo_id},
+        name=BACKFILL_JOB_NAME,
+    )
+
+
+def job_secrets(*, hf_token: str, sec_user_agent: str) -> dict[str, str]:
+    """Validate credentials locally so a misconfigured job fails before it costs money."""
+
+    if not hf_token.strip():
+        raise ValueError("HF_TOKEN is required to create or run a Hugging Face Job")
+    return {
+        "HF_TOKEN": hf_token.strip(),
+        "SEC_USER_AGENT": validate_sec_user_agent(sec_user_agent),
+    }
+
+
+def _api(token: str | None) -> Any:
+    try:
+        from huggingface_hub import HfApi
+    except ImportError as error:  # pragma: no cover - exercised in the job environment
+        raise RuntimeError("install the 'publish' extra to manage Hugging Face Jobs") from error
+    return HfApi(token=token)
+
+
+def _require(api: Any, method: str) -> Any:
+    """Fail with an actionable message when the installed hub predates a Jobs API."""
+
+    function = getattr(api, method, None)
+    if function is None:
+        raise RuntimeError(
+            f"the installed huggingface_hub has no {method}(); "
+            "upgrade with: pip install -U 'huggingface-hub>=1.19'"
+        )
+    return function
+
+
+def create_schedule(
+    spec: JobSpec,
+    *,
+    schedule: str = DEFAULT_SCHEDULE,
+    secrets: dict[str, str],
+    namespace: str | None = None,
+    token: str | None = None,
+) -> Any:
+    api = _api(token)
+    return _require(api, "create_scheduled_uv_job")(
+        schedule=schedule,
+        namespace=namespace,
+        **spec.as_kwargs(secrets=secrets),
+    )
+
+
+def run_once(
+    spec: JobSpec,
+    *,
+    secrets: dict[str, str],
+    namespace: str | None = None,
+    token: str | None = None,
+) -> Any:
+    api = _api(token)
+    return _require(api, "run_uv_job")(namespace=namespace, **spec.as_kwargs(secrets=secrets))
+
+
+def list_schedules(*, namespace: str | None = None, token: str | None = None) -> list[Any]:
+    api = _api(token)
+    return list(_require(api, "list_scheduled_jobs")(namespace=namespace))
+
+
+def inspect_schedule(
+    scheduled_job_id: str, *, namespace: str | None = None, token: str | None = None
+) -> Any:
+    api = _api(token)
+    return _require(api, "inspect_scheduled_job")(
+        scheduled_job_id=scheduled_job_id, namespace=namespace
+    )
+
+
+def delete_schedule(
+    scheduled_job_id: str, *, namespace: str | None = None, token: str | None = None
+) -> None:
+    api = _api(token)
+    _require(api, "delete_scheduled_job")(scheduled_job_id=scheduled_job_id, namespace=namespace)
+
+
+def suspend_schedule(
+    scheduled_job_id: str, *, namespace: str | None = None, token: str | None = None
+) -> Any:
+    api = _api(token)
+    return _require(api, "suspend_scheduled_job")(
+        scheduled_job_id=scheduled_job_id, namespace=namespace
+    )
+
+
+def resume_schedule(
+    scheduled_job_id: str, *, namespace: str | None = None, token: str | None = None
+) -> Any:
+    api = _api(token)
+    return _require(api, "resume_scheduled_job")(
+        scheduled_job_id=scheduled_job_id, namespace=namespace
+    )
+
+
+__all__ = [
+    "BACKFILL_FLAVOR",
+    "BACKFILL_TIMEOUT",
+    "DEFAULT_SCHEDULE",
+    "JOB_SCRIPT",
+    "UPDATE_FLAVOR",
+    "UPDATE_TIMEOUT",
+    "JobSpec",
+    "backfill_spec",
+    "create_schedule",
+    "delete_schedule",
+    "inspect_schedule",
+    "job_secrets",
+    "list_schedules",
+    "resume_schedule",
+    "run_once",
+    "script_url",
+    "suspend_schedule",
+    "update_spec",
+]

recipe/intervals.py

@@ -0,0 +1,275 @@
+"""Turn dated observations into the published tables.
+
+The model is deliberately modest. An interval here says "filings stated this
+identifier for this filer between these two dates", not "this identifier was
+legally valid over this span". Nobody publishes the day a ticker changed hands,
+so a stronger claim would be invented. A gap means nobody filed; `observations`
+says how much evidence stands behind the span.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from datetime import UTC, datetime, time, timedelta
+
+import polars as pl
+
+from .schema import (
+    CUSIP_MAP_SCHEMA,
+    IDENTIFIER_SCHEMA,
+    ISSUER_SCHEMA,
+    PIT_SCHEMA,
+    align,
+    empty_frame,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+# A filer that has not been seen for this long is treated as no longer filing.
+# Two years, not one: an annual filer that slips a quarter is still alive, and
+# calling it dead would reintroduce exactly the survivorship bias this dataset
+# exists to remove.
+DORMANT_AFTER_DAYS = 730
+
+# How far a settlement record may sit outside an observed ticker span and still
+# be matched to it. Fails-to-deliver records are dated by settlement, filings by
+# filing; neither brackets the other.
+CUSIP_MATCH_SLACK_DAYS = 200
+
+# An exchange-traded fund settles like a share and files nothing a security
+# master can key on: no Form 4, no financial statements under its ticker. It
+# will never resolve to an operating company's CIK, and counting those failures
+# as misses made the bridge look 13% complete when it covers 88% of the money.
+FUND_NAME = re.compile(
+    r"\b(ETF|ETN|FUND|FUNDS|TRUST|TR|INDEX|IDX|PORTFOLIO|ISHARES|SPDR|VANGUARD|"
+    r"POWERSHARES|PROSHARES|WISDOMTREE|SELECT SECTOR|UNIT SER|DEP RCPT)\b",
+    re.I,
+)
+
+
+def build_identifiers(observations: pl.DataFrame) -> pl.DataFrame:
+    """One row per (filer, kind, value) with the span it was stated over."""
+    if observations.is_empty():
+        return empty_frame(IDENTIFIER_SCHEMA)
+
+    grouped = (
+        observations.group_by(["cik", "kind", "value"])
+        .agg(
+            pl.col("observed_on").min().alias("valid_from"),
+            pl.col("observed_on").max().alias("valid_to"),
+            pl.len().cast(pl.Int32).alias("observations"),
+            pl.col("source").unique().sort().str.join("|").alias("sources"),
+        )
+    )
+    # "Current" has to mean current *now*, not merely last-stated. Defining it
+    # as "the newest value this filer gave" made a company that stopped filing
+    # in 2014 permanently current under its 2014 ticker -- and when another
+    # company later took that ticker over, both looked current at once. Six
+    # percent of live tickers were ambiguous that way.
+    latest = grouped.group_by(["cik", "kind"]).agg(
+        pl.col("valid_to").max().alias("kind_latest")
+    )
+    horizon = observations["observed_on"].max()
+    active = (
+        observations.group_by("cik")
+        .agg(pl.col("observed_on").max().alias("filer_last_seen"))
+        .with_columns(
+            (pl.col("filer_last_seen") >= horizon - timedelta(days=DORMANT_AFTER_DAYS))
+            .alias("filer_active")
+        )
+        .select("cik", "filer_active")
+    )
+    grouped = (
+        grouped.join(latest, on=["cik", "kind"], how="left")
+        .join(active, on="cik", how="left")
+        .with_columns(
+            (
+                (pl.col("valid_to") == pl.col("kind_latest"))
+                & pl.col("filer_active").fill_null(False)
+            ).alias("is_current"),
+            (pl.col("valid_to") == pl.col("kind_latest")).alias("is_latest_for_filer"),
+        )
+    )
+    grouped = grouped.with_columns(
+        pl.struct("observations", "valid_to")
+        .rank("ordinal", descending=True)
+        .over(["cik", "kind"])
+        .cast(pl.Int32)
+        .alias("rank_within_kind"),
+        pl.lit(datetime.now(UTC)).alias("inserted_at"),
+    )
+    return align(grouped, IDENTIFIER_SCHEMA).sort(["cik", "kind", "rank_within_kind"])
+
+
+def _current_value(identifiers: pl.DataFrame, kind: str, column: str) -> pl.DataFrame:
+    """The filer's own newest value, active or not.
+
+    An issuer row describes a company, including one that stopped filing in
+    2011; keying this on `is_current` would leave every dormant filer nameless.
+    """
+    return (
+        identifiers.filter((pl.col("kind") == kind) & pl.col("is_latest_for_filer"))
+        .sort(["cik", "rank_within_kind"])
+        .group_by("cik", maintain_order=True)
+        .agg(pl.col("value").first().alias(column))
+    )
+
+
+def build_issuers(identifiers: pl.DataFrame, observations: pl.DataFrame) -> pl.DataFrame:
+    """One row per filer: what it is called now, and how long it has been filing."""
+    if identifiers.is_empty():
+        return empty_frame(ISSUER_SCHEMA)
+
+    span = observations.group_by("cik").agg(
+        pl.col("observed_on").min().alias("first_seen"),
+        pl.col("observed_on").max().alias("last_seen"),
+        pl.col("source_ref").n_unique().cast(pl.Int32).alias("filings_observed"),
+    )
+    frame = span
+    for kind, column in (
+        ("name", "name"), ("ticker", "primary_ticker"), ("exchange", "exchange"),
+        ("sic", "sic"), ("fiscal_year_end", "fiscal_year_end"),
+        ("state_incorporated", "state_incorporated"),
+    ):
+        frame = frame.join(_current_value(identifiers, kind, column), on="cik", how="left")
+
+    tickers = (
+        identifiers.filter((pl.col("kind") == "ticker") & pl.col("is_latest_for_filer"))
+        .sort(["cik", "rank_within_kind"])
+        .group_by("cik", maintain_order=True)
+        .agg(pl.col("value").str.join(",").alias("all_tickers"))
+    )
+    # The pivot names its columns after the kinds, so it produces a column
+    # called `name` that collides with the company name already on the frame.
+    # Renaming after the join hit the wrong one and blanked every issuer's name.
+    changes = (
+        identifiers.filter(pl.col("kind").is_in(["ticker", "name"]))
+        .group_by(["cik", "kind"])
+        .agg(pl.len().alias("n"))
+        .pivot(on="kind", index="cik", values="n", aggregate_function="first")
+        .rename(lambda column: column if column == "cik" else f"{column}_changes")
+    )
+    frame = frame.join(tickers, on="cik", how="left").join(changes, on="cik", how="left")
+
+    horizon = observations["observed_on"].max()
+    frame = frame.with_columns(
+        (pl.col("last_seen") >= horizon - timedelta(days=DORMANT_AFTER_DAYS)).alias("is_active"),
+        pl.lit(datetime.now(UTC)).alias("inserted_at"),
+    )
+    return align(frame, ISSUER_SCHEMA).sort("cik")
+
+
+def build_cusip_map(ftd: pl.DataFrame, identifiers: pl.DataFrame) -> pl.DataFrame:
+    """CUSIP to CIK, by way of the ticker both of them name.
+
+    13F and N-PORT identify a holding by CUSIP; every other dataset in this
+    family identifies a company by CIK, and no free source maps between them.
+    Settlement records tie a CUSIP to a ticker on a date, filings tie a ticker
+    to a filer over a span, and the two compose -- provided the dates overlap,
+    which is what separates a confident match from a plausible one.
+    """
+    if ftd.is_empty():
+        return empty_frame(CUSIP_MAP_SCHEMA)
+
+    pairs = ftd.group_by(["cusip", "ticker"]).agg(
+        pl.col("issuer_name").mode().first().alias("issuer_name"),
+        pl.col("observed_on").min().alias("first_seen"),
+        pl.col("observed_on").max().alias("last_seen"),
+        pl.len().cast(pl.Int32).alias("observations"),
+    )
+    spans = (
+        identifiers.filter(pl.col("kind") == "ticker")
+        .select("cik", pl.col("value").alias("ticker"), "valid_from", "valid_to", "observations")
+        .rename({"observations": "ticker_observations"})
+    )
+    joined = pairs.join(spans, on="ticker", how="left")
+
+    slack = timedelta(days=CUSIP_MATCH_SLACK_DAYS)
+    overlaps = (pl.col("first_seen") <= pl.col("valid_to") + slack) & (
+        pl.col("last_seen") >= pl.col("valid_from") - slack
+    )
+    joined = joined.with_columns(
+        pl.when(pl.col("cik").is_null())
+        .then(pl.lit("unmatched"))
+        .when(overlaps)
+        .then(pl.lit("ticker_and_dates"))
+        .otherwise(pl.lit("ticker_only"))
+        .alias("match_method")
+    )
+    # One ticker can belong to several filers over time -- that is the whole
+    # point of this dataset -- so the date-overlapping candidate wins, and the
+    # best-evidenced one breaks a remaining tie.
+    ranked = joined.sort(
+        ["cusip", "ticker",
+         pl.col("match_method").replace_strict(
+             {"ticker_and_dates": 0, "ticker_only": 1, "unmatched": 2}, default=3
+         ),
+         pl.col("ticker_observations").fill_null(0)],
+        descending=[False, False, False, True],
+    ).group_by(["cusip", "ticker"], maintain_order=True).first()
+
+    ranked = ranked.with_columns(pl.col("cusip").str.slice(0, 6).alias("cusip6"))
+
+    # The first six characters of a CUSIP identify the issuer; the rest identify
+    # the instrument. So a class B share, a preferred and a warrant of a company
+    # whose common stock already resolved belong to the same filer, and saying
+    # so is a fact about how CUSIPs are assigned rather than a guess. It carries
+    # its own method and a middle confidence, because the *instrument* was never
+    # matched -- only its issuer.
+    issuer_level = (
+        ranked.filter(pl.col("cik").is_not_null())
+        .group_by("cusip6")
+        .agg(pl.col("cik").mode().first().alias("issuer_cik"))
+    )
+    ranked = ranked.join(issuer_level, on="cusip6", how="left").with_columns(
+        pl.when(pl.col("cik").is_null() & pl.col("issuer_cik").is_not_null())
+        .then(pl.lit("cusip6_inherited"))
+        .otherwise(pl.col("match_method"))
+        .alias("match_method"),
+        pl.coalesce([pl.col("cik"), pl.col("issuer_cik")]).alias("cik"),
+    )
+
+    ranked = ranked.with_columns(
+        pl.col("issuer_name").fill_null("").str.contains(FUND_NAME.pattern).alias("looks_like_fund"),
+        pl.when(pl.col("match_method") == "ticker_and_dates")
+        .then(pl.lit("high"))
+        .when(pl.col("match_method") == "cusip6_inherited")
+        .then(pl.lit("medium"))
+        .when(pl.col("match_method") == "ticker_only")
+        .then(pl.lit("low"))
+        .otherwise(pl.lit("none"))
+        .alias("match_confidence"),
+        pl.lit(datetime.now(UTC)).alias("inserted_at"),
+    )
+    return align(ranked, CUSIP_MAP_SCHEMA).sort(["cusip", "ticker"])
+
+
+def build_pit(identifiers: pl.DataFrame, *, run_at: datetime | None = None) -> pl.DataFrame:
+    """Identifier spans in point-in-time form.
+
+    `knowledge_date` is the end of the day an identifier was first observed.
+    The underlying filings carry an acceptance time to the second, but a
+    settlement record carries only a date, and mixing the two precisions would
+    imply a certainty the coarser source does not have. End of day errs late,
+    which delays a fact rather than leaking it.
+    """
+    if identifiers.is_empty():
+        return empty_frame(PIT_SCHEMA)
+    now = run_at or datetime.now(UTC)
+    frame = identifiers.with_columns(
+        pl.concat_str(
+            [pl.col("cik"), pl.col("kind"), pl.col("value"),
+             pl.col("valid_from").cast(pl.String)], separator="|"
+        ).alias("pit_event_id"),
+        pl.col("cik").alias("entity_id"),
+        pl.col("valid_from").alias("event_date"),
+        pl.col("valid_from")
+        .cast(pl.Datetime("us"))
+        .dt.combine(time(23, 59, 59))
+        .dt.replace_time_zone("UTC")
+        .alias("knowledge_date"),
+        pl.lit(True).alias("knowledge_estimated"),
+        pl.lit(now).alias("ingested_at"),
+    )
+    return align(frame, PIT_SCHEMA).sort(["entity_id", "kind", "event_date"])

recipe/manifest.py

@@ -0,0 +1,119 @@
+"""The bundle descriptor, rebuilt from what is actually on disk."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import polars as pl
+
+from . import __version__
+from .build import PIT_DELTA_NAME
+from .schema import BUILD_VERSION, CONFIG_SCHEMAS, IDENTIFIER_KINDS
+from .store import read_table
+
+RECIPE_ROOT = Path(__file__).resolve().parent.parent
+
+CONFIG_DESCRIPTIONS: dict[str, dict[str, str]] = {
+    "issuers": {
+        "path": "data/issuers/**/*.parquet",
+        "grain": "one SEC filer, with what it is called now and how long it has filed",
+    },
+    "identifiers": {
+        "path": "data/identifiers/**/*.parquet",
+        "grain": "one identifier and the span of filings that stated it",
+    },
+    "observations": {
+        "path": "data/observations/**/*.parquet",
+        "grain": "one dated statement that an identifier belonged to a filer",
+    },
+    "cusip_map": {
+        "path": "data/cusip_map/**/*.parquet",
+        "grain": "one CUSIP, the ticker it settles under and the filer behind it",
+    },
+    "pit": {
+        "path": "data/pit/**/*.parquet",
+        "delta_path": f"data/pit/{PIT_DELTA_NAME}",
+        "grain": "one point-in-time identifier knowledge event",
+    },
+}
+
+
+def recipe_hash(project_root: Path | None = None) -> str:
+    """Hash of the code that produced a build.
+
+    The root defaults to the installed recipe rather than being derived from
+    `data_dir`: a run writing elsewhere would otherwise hash an empty file set,
+    which reads as a valid hash and proves nothing.
+    """
+    root = (project_root or RECIPE_ROOT).resolve()
+    digest = hashlib.sha256()
+    files = sorted(
+        {
+            path
+            for pattern in ("recipe/**/*.py", "jobs/**/*.py", "tests/**/*.py", "pyproject.toml")
+            for path in root.glob(pattern)
+            if path.is_file()
+        }
+    )
+    if not files:
+        raise FileNotFoundError(f"no recipe sources under {root}")
+    for path in files:
+        digest.update(str(path.relative_to(root)).encode())
+        digest.update(b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    return f"sha256:{digest.hexdigest()}"
+
+
+def _coverage(data_dir: Path) -> dict[str, str | None]:
+    bounds = read_table(data_dir, "observations").select(
+        pl.col("observed_on").min().alias("min_observation"),
+        pl.col("observed_on").max().alias("max_observation"),
+    ).collect()
+    if bounds.is_empty():
+        return {}
+    row = bounds.row(0, named=True)
+    return {k: (v.isoformat() if v is not None else None) for k, v in row.items()}
+
+
+def build_manifest(*, data_dir: Path, row_counts: dict[str, int], quality_ok: bool) -> dict[str, Any]:
+    data_dir = Path(data_dir)
+    project_root = data_dir.resolve().parent
+    path = project_root / "manifest.json"
+    manifest: dict[str, Any] = json.loads(path.read_text()) if path.exists() else {}
+
+    manifest["generated_at"] = datetime.now(UTC).isoformat()
+    manifest["rows"] = row_counts.get("pit", 0)
+    manifest["config_rows"] = row_counts
+    manifest["configs"] = CONFIG_DESCRIPTIONS
+    manifest["coverage"] = _coverage(data_dir)
+    manifest["quality_ok"] = quality_ok
+    manifest["identifier_kinds"] = list(IDENTIFIER_KINDS)
+    manifest["config_schemas"] = {
+        name: {column: str(dtype) for column, dtype in schema.items()}
+        for name, schema in CONFIG_SCHEMAS.items()
+    }
+    source = dict(manifest.get("source") or {})
+    source["recipe_hash"] = recipe_hash()
+    source["build_version"] = BUILD_VERSION
+    source["package_version"] = __version__
+    manifest["source"] = source
+
+    descriptor, temporary = tempfile.mkstemp(prefix=".manifest-", suffix=".json", dir=project_root)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+            json.dump(manifest, handle, indent=2, sort_keys=True, ensure_ascii=False)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+    return manifest

recipe/publish.py

@@ -0,0 +1,135 @@
+"""Bootstrap and atomic same-revision publication through Hugging Face Hub."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def bootstrap_from_hf(
+    *, data_dir: Path, repo_id: str, token: str | None = None
+) -> bool:
+    """Hydrate prior append-only state on an ephemeral scheduled runner."""
+
+    if any((data_dir / "filings").glob("**/*.parquet")):
+        return False
+    try:
+        from huggingface_hub import snapshot_download
+        from huggingface_hub.errors import HfHubHTTPError, RepositoryNotFoundError
+    except ImportError as error:  # pragma: no cover - exercised in publish environment
+        raise RuntimeError("install the 'publish' extra to bootstrap from Hugging Face") from error
+
+    temporary = Path(tempfile.mkdtemp(prefix="insider-hf-bootstrap-"))
+    try:
+        try:
+            snapshot_download(
+                repo_id=repo_id,
+                repo_type="dataset",
+                token=token,
+                allow_patterns=["data/**"],
+                local_dir=temporary,
+            )
+        except RepositoryNotFoundError:
+            return False  # first publication
+        except HfHubHTTPError as error:
+            if getattr(error.response, "status_code", None) == 404:
+                return False
+            raise
+        downloaded = temporary / "data"
+        if not downloaded.exists():
+            return False
+        data_dir.mkdir(parents=True, exist_ok=True)
+        for source in downloaded.glob("**/*"):
+            if not source.is_file():
+                continue
+            target = data_dir / source.relative_to(downloaded)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            if not target.exists():
+                shutil.copy2(source, target)
+        return True
+    finally:
+        shutil.rmtree(temporary, ignore_errors=True)
+
+
+def publish_to_hf(
+    *, project_root: Path, repo_id: str, token: str | None = None
+) -> str:
+    try:
+        from huggingface_hub import HfApi
+    except ImportError as error:  # pragma: no cover - exercised in publish environment
+        raise RuntimeError("install the 'publish' extra to publish to Hugging Face") from error
+
+    api = HfApi(token=token)
+    api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True)
+    local = {
+        str(path.relative_to(project_root))
+        for path in project_root.glob("data/**/*.parquet")
+    }
+    commit = api.upload_folder(
+        repo_id=repo_id,
+        repo_type="dataset",
+        folder_path=project_root,
+        # Without this, an upload only ever adds. Partition file names are
+        # derived from their contents, so a rebuild writes different names and
+        # the previous build's files stay behind -- every row then appears
+        # twice, and years dropped from the rebuild come back from the dead.
+        # The published tree has to be what is on disk, not the union of every
+        # build that ever ran.
+        delete_patterns=["data/**"],
+        allow_patterns=[
+            "data/**",
+            "recipe/**",
+            "tests/**",
+            "jobs/**",
+            "README.md",
+            "PIPELINE.md",
+            "manifest.json",
+            "pyproject.toml",
+            "LICENSE",
+            "NOTICE",
+        ],
+        # The append lock is local coordination state, not published data.
+        ignore_patterns=["**/__pycache__/**", "**/*.pyc", "**/.append.lock"],
+        commit_message="Update the security master",
+    )
+    # A mirror that quietly failed to mirror is the failure this guards. Names
+    # are enough: a partition file's name is derived from its contents, so a
+    # set difference catches both a leftover from a previous build and a file
+    # that never arrived -- without downloading anything.
+    published = {
+        sibling.rfilename
+        for sibling in api.dataset_info(repo_id).siblings
+        if sibling.rfilename.startswith("data/") and sibling.rfilename.endswith(".parquet")
+    }
+    stale, missing = published - local, local - published
+    if stale or missing:
+        raise RuntimeError(
+            f"published tree does not match the local one: {len(stale)} stale file(s) "
+            f"left behind, {len(missing)} missing. Examples: "
+            f"stale={sorted(stale)[:3]} missing={sorted(missing)[:3]}"
+        )
+    logger.info("published tree mirrors %d local data files", len(local))
+    return str(commit.oid)
+
+
+def hf_token() -> str | None:
+    """The token to act with: the environment first, then a stored login.
+
+    A scheduled job receives HF_TOKEN as a secret; a person running the same
+    command locally has usually run `hf auth login` instead, and should not
+    have to export the token again to use it.
+    """
+
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        return token
+    try:
+        from huggingface_hub import get_token
+    except ImportError:  # pragma: no cover - exercised in the publish environment
+        return None
+    return get_token()

recipe/quality.py

@@ -0,0 +1,189 @@
+"""Checks that decide whether a build may be published.
+
+A security master fails quietly. A wrong ticker does not raise; it silently
+sends a backtest to another company's price series, and the result looks
+plausible. So the checks here are about identity: that a ticker current for one
+filer is not simultaneously current for another, that intervals are ordered,
+that the CUSIP bridge resolves the names everyone actually looks up.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import polars as pl
+
+from .store import read_table
+
+# Floors measured on the corpus, set below what it gives so a regression fails
+# and noise does not.
+MIN_TICKER_COVERAGE = 0.70
+# Weighted by how often a CUSIP appears in settlement records, and counting
+# only instruments that could resolve. A plain count of matched CUSIPs is the
+# wrong measure: two thirds of the CUSIPs ever traded are one-off warrants,
+# foreign lines and delisted shells, and exchange-traded funds -- which settle
+# like shares and file nothing -- can never resolve at all. By count the bridge
+# looks 37% complete; it covers 88% of the position value actually held in 13F.
+MIN_CUSIP_WEIGHTED_MATCH = 0.60
+MIN_ISSUERS = 15_000
+# A ticker genuinely belongs to two filers at once only in odd cases -- a
+# reorganisation mid-transfer, a dual filer. Above this share it means the
+# ticker history is being stitched to the wrong companies.
+MAX_AMBIGUOUS_CURRENT_TICKERS = 0.02
+
+
+@dataclass
+class QualityReport:
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    metrics: dict[str, Any] = field(default_factory=dict)
+
+    def error(self, message: str) -> None:
+        self.errors.append(message)
+
+    def warn(self, message: str) -> None:
+        self.warnings.append(message)
+
+    def metric(self, name: str, value: Any) -> None:
+        self.metrics[name] = value
+
+    @property
+    def ok(self) -> bool:
+        return not self.errors
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "ok": self.ok,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "metrics": self.metrics,
+        }
+
+    def write(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(self.as_dict(), indent=2, default=str), encoding="utf-8")
+
+
+def validate(data_dir: Path) -> QualityReport:
+    report = QualityReport()
+    data_dir = Path(data_dir)
+
+    observations = read_table(data_dir, "observations").collect()
+    identifiers = read_table(data_dir, "identifiers").collect()
+    issuers = read_table(data_dir, "issuers").collect()
+    cusip_map = read_table(data_dir, "cusip_map").collect()
+    pit = read_table(data_dir, "pit").collect()
+
+    for name, frame in (
+        ("observations", observations), ("identifiers", identifiers),
+        ("issuers", issuers), ("cusip_map", cusip_map), ("pit", pit),
+    ):
+        report.metric(f"rows_{name}", frame.height)
+    if issuers.is_empty():
+        report.error("issuers table is empty")
+        return report
+    if issuers.height < MIN_ISSUERS:
+        report.error(f"only {issuers.height} issuers, below the {MIN_ISSUERS} floor")
+
+    for column in ("cik", "kind", "value", "observed_on", "source"):
+        nulls = observations[column].null_count()
+        if nulls:
+            report.error(f"observations.{column}: {nulls} nulls")
+
+    reversed_spans = identifiers.filter(pl.col("valid_to") < pl.col("valid_from")).height
+    if reversed_spans:
+        report.error(f"identifiers: {reversed_spans} spans end before they start")
+
+    duplicates = identifiers.height - identifiers.select("cik", "kind", "value").unique().height
+    if duplicates:
+        report.error(f"identifiers: {duplicates} duplicate (cik, kind, value) rows")
+
+    if issuers["cik"].n_unique() != issuers.height:
+        report.error("issuers: duplicate CIKs")
+
+    with_ticker = issuers.filter(pl.col("primary_ticker").is_not_null()).height
+    coverage = with_ticker / issuers.height
+    report.metric("issuers_with_ticker", round(coverage, 4))
+    active = issuers.filter(pl.col("is_active"))
+    report.metric("issuers_active", active.height)
+    if not active.is_empty():
+        active_coverage = active.filter(pl.col("primary_ticker").is_not_null()).height / active.height
+        report.metric("active_issuers_with_ticker", round(active_coverage, 4))
+        if active_coverage < MIN_TICKER_COVERAGE:
+            report.error(
+                f"only {active_coverage:.1%} of active issuers have a ticker, "
+                f"below the {MIN_TICKER_COVERAGE:.0%} floor"
+            )
+
+    # The check that matters most: a ticker current for two filers at once means
+    # somebody's history has been attached to the wrong company.
+    current = identifiers.filter((pl.col("kind") == "ticker") & pl.col("is_current"))
+    if not current.is_empty():
+        ambiguous = (
+            current.group_by("value").agg(pl.col("cik").n_unique().alias("filers"))
+            .filter(pl.col("filers") > 1)
+        )
+        share = ambiguous.height / current["value"].n_unique()
+        report.metric("ambiguous_current_tickers", ambiguous.height)
+        report.metric("ambiguous_current_ticker_share", round(share, 4))
+        if share > MAX_AMBIGUOUS_CURRENT_TICKERS:
+            report.error(
+                f"{ambiguous.height} tickers are current for more than one filer "
+                f"({share:.1%}) — histories are being stitched to the wrong companies"
+            )
+
+    if not cusip_map.is_empty():
+        matched = cusip_map.filter(pl.col("cik").is_not_null()).height
+        report.metric("cusip_rows", cusip_map.height)
+        report.metric("cusip_matched_share", round(matched / cusip_map.height, 4))
+        resolvable = cusip_map.filter(~pl.col("looks_like_fund").fill_null(False))
+        weight = resolvable["observations"].sum() or 1
+        rate = resolvable.filter(pl.col("cik").is_not_null())["observations"].sum() / weight
+        report.metric("cusip_weighted_match", round(rate, 4))
+        report.metric("cusip_fund_rows", cusip_map.height - resolvable.height)
+        report.metric(
+            "cusip_by_confidence",
+            {
+                row["match_confidence"]: row["n"]
+                for row in cusip_map.group_by("match_confidence")
+                .agg(pl.len().alias("n")).iter_rows(named=True)
+            },
+        )
+        if rate < MIN_CUSIP_WEIGHTED_MATCH:
+            report.error(
+                f"only {rate:.1%} of non-fund CUSIP traffic resolved to a filer, "
+                f"below the {MIN_CUSIP_WEIGHTED_MATCH:.0%} floor"
+            )
+        if cusip_map.select("cusip", "ticker").unique().height != cusip_map.height:
+            report.error("cusip_map: duplicate (cusip, ticker) rows")
+
+    if not pit.is_empty():
+        if pit.height != identifiers.height:
+            report.error(
+                f"pit has {pit.height} events for {identifiers.height} identifier spans"
+            )
+        for column in ("entity_id", "event_date", "knowledge_date"):
+            if pit[column].null_count():
+                report.error(f"pit.{column}: {pit[column].null_count()} nulls")
+
+    bounds = observations.select(
+        pl.col("observed_on").min().alias("first"), pl.col("observed_on").max().alias("last")
+    ).row(0)
+    report.metric("coverage_first_observation", str(bounds[0]))
+    report.metric("coverage_last_observation", str(bounds[1]))
+    report.metric(
+        "observations_by_source",
+        {
+            row["source"]: row["n"]
+            for row in observations.group_by("source").agg(pl.len().alias("n")).iter_rows(named=True)
+        },
+    )
+    return report
+
+
+__all__ = ["QualityReport", "validate"]

recipe/schema.py

@@ -0,0 +1,128 @@
+"""Canonical Polars schemas for every published config."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+import polars as pl
+
+UTC_DATETIME = pl.Datetime(time_unit="us", time_zone="UTC")
+
+BUILD_VERSION = "1.0.0"
+
+# What kinds of identifier this master carries. `former_name` is separate from
+# `name` because a former name is stated *as* former -- the filing says when it
+# stopped being used, which a run of name observations cannot tell you.
+IDENTIFIER_KINDS = ("ticker", "name", "former_name", "exchange", "sic", "cusip", "figi")
+
+# One dated statement that an identifier belonged to a filer. This is the
+# evidence layer: intervals are derived from it, and anyone who disagrees with
+# how they were derived can derive their own.
+OBSERVATION_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "kind": pl.String,
+    "value": pl.String,
+    "observed_on": pl.Date,
+    "source": pl.String,
+    "source_ref": pl.String,
+    "inserted_at": UTC_DATETIME,
+}
+
+# One identifier and the span over which filings actually stated it.
+#
+# `valid_from`/`valid_to` are first and last *observation*, not registry dates:
+# nobody publishes the day a ticker changed hands. A gap means nobody filed,
+# not that the identifier lapsed, and `observations` says how much evidence
+# stands behind the span.
+IDENTIFIER_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "kind": pl.String,
+    "value": pl.String,
+    "valid_from": pl.Date,
+    "valid_to": pl.Date,
+    "observations": pl.Int32,
+    "sources": pl.String,
+    # `is_current` means live now: the newest value this filer stated *and* the
+    # filer still files. `is_latest_for_filer` drops the second condition, which
+    # is what you want when asking "what did this company last call itself".
+    "is_current": pl.Boolean,
+    "is_latest_for_filer": pl.Boolean,
+    "rank_within_kind": pl.Int32,
+    "inserted_at": UTC_DATETIME,
+}
+
+ISSUER_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "name": pl.String,
+    "primary_ticker": pl.String,
+    "all_tickers": pl.String,
+    "exchange": pl.String,
+    "sic": pl.String,
+    "fiscal_year_end": pl.String,
+    "state_incorporated": pl.String,
+    "first_seen": pl.Date,
+    "last_seen": pl.Date,
+    "is_active": pl.Boolean,
+    "ticker_changes": pl.Int32,
+    "name_changes": pl.Int32,
+    "filings_observed": pl.Int32,
+    "inserted_at": UTC_DATETIME,
+}
+
+# The bridge. 13F and N-PORT name a holding by CUSIP; every other dataset in
+# this family names a company by CIK. Nobody publishes a free map between them.
+CUSIP_MAP_SCHEMA: dict[str, pl.DataType] = {
+    "cusip": pl.String,
+    "cusip6": pl.String,
+    "ticker": pl.String,
+    "cik": pl.String,
+    "issuer_name": pl.String,
+    "first_seen": pl.Date,
+    "last_seen": pl.Date,
+    "observations": pl.Int32,
+    "match_method": pl.String,
+    "match_confidence": pl.String,
+    # True for an ETF or fund share, which settles like a stock and files
+    # nothing a CIK could be attached to. Not a failed match: a different kind
+    # of instrument.
+    "looks_like_fund": pl.Boolean,
+    "inserted_at": UTC_DATETIME,
+}
+
+PIT_SCHEMA: dict[str, pl.DataType] = {
+    "pit_event_id": pl.String,
+    "entity_id": pl.String,
+    "event_date": pl.Date,
+    "knowledge_date": UTC_DATETIME,
+    "knowledge_estimated": pl.Boolean,
+    "kind": pl.String,
+    "value": pl.String,
+    "valid_to": pl.Date,
+    "observations": pl.Int32,
+    "sources": pl.String,
+    "is_current": pl.Boolean,
+    "ingested_at": UTC_DATETIME,
+}
+
+CONFIG_SCHEMAS: dict[str, dict[str, pl.DataType]] = {
+    "observations": OBSERVATION_SCHEMA,
+    "identifiers": IDENTIFIER_SCHEMA,
+    "issuers": ISSUER_SCHEMA,
+    "cusip_map": CUSIP_MAP_SCHEMA,
+    "pit": PIT_SCHEMA,
+}
+
+
+def empty_frame(schema: Mapping[str, pl.DataType]) -> pl.DataFrame:
+    return pl.DataFrame(schema=dict(schema))
+
+
+def align(frame: pl.DataFrame, schema: Mapping[str, pl.DataType]) -> pl.DataFrame:
+    missing = [
+        pl.lit(None, dtype=dtype).alias(name)
+        for name, dtype in schema.items()
+        if name not in frame.columns
+    ]
+    if missing:
+        frame = frame.with_columns(missing)
+    return frame.select([pl.col(n).cast(d, strict=False) for n, d in schema.items()])

recipe/sec_client.py

@@ -0,0 +1,309 @@
+"""Async SEC client with declared identity, throttling, retries, and cache."""
+
+from __future__ import annotations
+
+import asyncio
+import gzip
+import hashlib
+import json
+import os
+import random
+import tempfile
+import time
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from .config import DEFAULT_SEC_USER_AGENT, validate_sec_user_agent
+
+_ALLOWED_HOSTS = frozenset({"sec.gov", "www.sec.gov", "data.sec.gov"})
+_RETRYABLE_STATUS = frozenset({408, 425, 429, 500, 502, 503, 504})
+
+
+class SECObjectMissing(Exception):
+    """The requested EDGAR object does not exist.
+
+    EDGAR serves its archive from an object store that answers a missing key
+    with ``403 AccessDenied`` rather than ``404``. Weekends, holidays, and the
+    current day before the feed is published all look like this, so a caller
+    that treated only 404 as "not there" would fail on an ordinary run.
+    """
+
+
+class SECAccessBlocked(Exception):
+    """SEC refused the request itself, not a specific object.
+
+    This is a Fair Access block: an undeclared automated tool or an exceeded
+    request rate. It must never be mistaken for a per-filing error. Recording a
+    blocked run as thousands of parse failures would write those failures into
+    append-only history, where they cannot be corrected.
+    """
+
+
+def _classify_forbidden(response: httpx.Response) -> Exception:
+    """Tell a missing archive object apart from a Fair Access block.
+
+    The archive backend stamps ``x-amz-request-id`` and returns an XML
+    ``AccessDenied`` body; a block is served by the edge as HTML.
+    """
+
+    if "x-amz-request-id" in response.headers and b"AccessDenied" in response.content[:4096]:
+        return SECObjectMissing(f"EDGAR has no object at {response.request.url}")
+    return SECAccessBlocked(
+        "SEC refused the request (Fair Access). Check the declared User-Agent and "
+        f"request rate before retrying: {response.request.url}"
+    )
+
+
+class SECClient:
+    """Fair-Access-aware HTTP client.
+
+    The shared monotonic limiter spaces request starts. The default six requests
+    per second stays comfortably below SEC's published ten-request threshold.
+    """
+
+    def __init__(
+        self,
+        *,
+        user_agent: str = DEFAULT_SEC_USER_AGENT,
+        cache_dir: str | Path = ".cache/sec",
+        requests_per_second: float = 6.0,
+        max_attempts: int = 5,
+        timeout: float = 45.0,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        if not 0 < requests_per_second < 10:
+            raise ValueError("requests_per_second must be greater than zero and below 10")
+        self.user_agent = validate_sec_user_agent(user_agent)
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.requests_per_second = requests_per_second
+        self.max_attempts = max_attempts
+        self._spacing = 1.0 / requests_per_second
+        self._limiter_lock = asyncio.Lock()
+        self._next_request_at = 0.0
+        self._timeout = timeout
+        self._client = httpx.AsyncClient(
+            headers={
+                "User-Agent": self.user_agent,
+                "Accept-Encoding": "gzip, deflate",
+                "Accept": "*/*",
+            },
+            timeout=timeout,
+            follow_redirects=True,
+            transport=transport,
+        )
+
+    async def __aenter__(self) -> SECClient:
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    @staticmethod
+    def _validate_url(url: str) -> None:
+        parsed = urlparse(url)
+        if parsed.scheme != "https" or (parsed.hostname or "").lower() not in _ALLOWED_HOSTS:
+            raise ValueError(f"SECClient refuses non-SEC URL: {url!r}")
+
+    def _cache_path(self, url: str) -> Path:
+        digest = hashlib.sha256(url.encode("utf-8")).hexdigest()
+        suffix = Path(urlparse(url).path).suffix[:10] or ".bin"
+        return self.cache_dir / digest[:2] / f"{digest}{suffix}"
+
+    async def _throttle(self) -> None:
+        async with self._limiter_lock:
+            now = time.monotonic()
+            delay = max(0.0, self._next_request_at - now)
+            if delay:
+                await asyncio.sleep(delay)
+            self._next_request_at = time.monotonic() + self._spacing
+
+    @staticmethod
+    def _fresh(path: Path, max_age_seconds: float | None) -> bool:
+        if not path.is_file():
+            return False
+        if max_age_seconds is None:
+            return True
+        return time.time() - path.stat().st_mtime <= max_age_seconds
+
+    @staticmethod
+    def _decode_cached(payload: bytes) -> bytes:
+        """Read a cache entry written either compressed or plain."""
+
+        if payload[:2] == b"\x1f\x8b":
+            return gzip.decompress(payload)
+        return payload
+
+    @staticmethod
+    def _atomic_write(path: Path, payload: bytes) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        descriptor, temporary = tempfile.mkstemp(prefix=".download-", dir=path.parent)
+        try:
+            with os.fdopen(descriptor, "wb") as handle:
+                # SEC source documents are XML and compress about sevenfold. A
+                # full historical cache is the difference between ~10 GB and
+                # ~1.5 GB, which is what makes keeping it affordable — and a
+                # kept cache turns a future parser fix into a re-parse instead
+                # of a multi-day re-download.
+                handle.write(gzip.compress(payload, compresslevel=6, mtime=0))
+                handle.flush()
+                os.fsync(handle.fileno())
+            os.replace(temporary, path)
+        finally:
+            if os.path.exists(temporary):
+                os.unlink(temporary)
+
+    async def get_bytes(
+        self,
+        url: str,
+        *,
+        use_cache: bool = True,
+        max_age_seconds: float | None = None,
+        first_bytes: int | None = None,
+        timeout: float | None = None,
+    ) -> bytes:
+        """Fetch a URL, optionally only its opening bytes.
+
+        ``first_bytes`` issues a ranged request. Reading an acceptance
+        timestamp needs a couple of kilobytes out of a submission that may be
+        hundreds; the request still counts against the rate limit, but the
+        transfer does not. A ranged response is never cached, since it is a
+        fragment rather than the document.
+
+        ``timeout`` overrides the client default for one call. The default suits
+        an 8 KB filing; a daily feed archive is hundreds of megabytes and needs
+        minutes, and timing it out mid-transfer silently drops a whole day.
+        """
+
+        self._validate_url(url)
+        cache_path = self._cache_path(url)
+        if first_bytes is not None:
+            use_cache = False
+        elif use_cache and self._fresh(cache_path, max_age_seconds):
+            return self._decode_cached(cache_path.read_bytes())
+
+        last_error: Exception | None = None
+        for attempt in range(1, self.max_attempts + 1):
+            await self._throttle()
+            try:
+                headers = (
+                    {"Range": f"bytes=0-{first_bytes - 1}"} if first_bytes else None
+                )
+                response = await self._client.get(
+                    url, headers=headers, timeout=timeout or self._timeout
+                )
+                # A block and a missing object are both terminal, but they mean
+                # opposite things to the caller, so neither is retried here.
+                if response.status_code == 403:
+                    raise _classify_forbidden(response)
+                if response.status_code == 404:
+                    raise SECObjectMissing(f"EDGAR has no object at {url}")
+                if response.status_code not in _RETRYABLE_STATUS:
+                    if first_bytes is None or response.status_code != 206:
+                        response.raise_for_status()
+                    payload = response.content
+                    if use_cache:
+                        self._atomic_write(cache_path, payload)
+                    return payload
+                retry_after = response.headers.get("Retry-After")
+                delay = float(retry_after) if retry_after and retry_after.isdigit() else 0.0
+                last_error = httpx.HTTPStatusError(
+                    f"retryable SEC response {response.status_code}",
+                    request=response.request,
+                    response=response,
+                )
+            except (httpx.TransportError, httpx.TimeoutException) as error:
+                # Includes RemoteProtocolError: EDGAR sometimes closes a large
+                # transfer early. Retrying is the right response; the backoff
+                # below spaces the attempts.
+                last_error = error
+                delay = 0.0
+
+            if attempt < self.max_attempts:
+                exponential = min(30.0, 0.75 * (2 ** (attempt - 1)))
+                await asyncio.sleep(max(delay, exponential + random.uniform(0, 0.25)))
+
+        assert last_error is not None
+        raise last_error
+
+    async def get_resumable(
+        self,
+        url: str,
+        *,
+        timeout: float,
+        max_resumes: int = 40,
+    ) -> bytes:
+        """Download a large object, resuming from where a break left off.
+
+        EDGAR closes long transfers early often enough that restarting from
+        zero is futile: a 450 MB archive that fails at 80% would re-download
+        the whole thing, fail again, and eventually cost the day. A ranged
+        continuation keeps the bytes already received and asks only for the
+        remainder.
+
+        The resume budget is generous because each attempt makes progress: a
+        break costs only the bytes not yet received. Archives reach 1.4 GB by
+        the 2020s and can break repeatedly within one transfer, and a budget of
+        eight was already losing whole weekdays at 540 MB.
+        """
+
+        self._validate_url(url)
+        buffer = bytearray()
+        resumes = 0
+        stalls = 0
+        max_stalls = 5
+        progress_mark = 0
+        while True:
+            headers = {"Range": f"bytes={len(buffer)}-"} if buffer else None
+            await self._throttle()
+            try:
+                async with self._client.stream(
+                    "GET", url, headers=headers, timeout=timeout
+                ) as response:
+                    if response.status_code == 403:
+                        await response.aread()
+                        raise _classify_forbidden(response)
+                    if response.status_code == 404:
+                        raise SECObjectMissing(f"EDGAR has no object at {url}")
+                    if response.status_code in _RETRYABLE_STATUS:
+                        # The plain path retries these; the resumable one must
+                        # too, or a transient 503 becomes a lost day.
+                        await response.aread()
+                        resumes += 1
+                        if resumes > max_resumes:
+                            response.raise_for_status()
+                        await asyncio.sleep(min(30.0, 2.0 * resumes))
+                        continue
+                    if response.status_code not in (200, 206):
+                        await response.aread()
+                        response.raise_for_status()
+                    async for chunk in response.aiter_bytes():
+                        buffer.extend(chunk)
+                return bytes(buffer)
+            except (httpx.TransportError, httpx.TimeoutException):
+                # A break that still delivered bytes is progress, not a failed
+                # attempt: only stalls count against the budget, so a large
+                # archive breaking many times still completes.
+                if len(buffer) > progress_mark:
+                    progress_mark = len(buffer)
+                    stalls = 0
+                else:
+                    stalls += 1
+                resumes += 1
+                if stalls > max_stalls or resumes > max_resumes:
+                    raise
+                await asyncio.sleep(min(30.0, 2.0 * stalls + 1.0))
+
+    async def get_text(self, url: str, **kwargs: Any) -> str:
+        payload = await self.get_bytes(url, **kwargs)
+        return payload.decode("utf-8", errors="replace")
+
+    async def get_json(self, url: str, **kwargs: Any) -> Any:
+        return json.loads(await self.get_text(url, **kwargs))
+

recipe/sources.py

@@ -0,0 +1,224 @@
+"""Where the identifier observations come from.
+
+This dataset has almost no source of its own. Every ticker in it was printed on
+a Form 4 by the company it belongs to; every former name came from a filing
+header; every CUSIP-to-ticker pair came from a settlement record. The job here
+is to collect those statements with their dates and keep the evidence.
+
+Reading a sibling dataset locally is supported so a build can be iterated
+without moving gigabytes, but the scheduled job reads the published revisions:
+what this dataset says has to be derivable from what the others published.
+"""
+
+from __future__ import annotations
+
+import io
+import logging
+import re
+import zipfile
+from collections.abc import Iterator
+from datetime import UTC, date, datetime
+from pathlib import Path
+
+import polars as pl
+
+from .config import SIBLING_DIRS, SOURCE_REPOS, Settings
+from .schema import OBSERVATION_SCHEMA, align, empty_frame
+from .symbols import parse_symbols
+
+LOGGER = logging.getLogger(__name__)
+
+COMPANY_TICKERS_URL = "https://www.sec.gov/files/company_tickers_exchange.json"
+FTD_INDEX_URL = "https://www.sec.gov/data/foiadocsfailsdatahtm"
+FTD_LINK = re.compile(r'href="(/files/[^"]*cnsfails(\d{6})[ab]\.zip)"')
+
+
+def _observations(rows: list[dict]) -> pl.DataFrame:
+    if not rows:
+        return empty_frame(OBSERVATION_SCHEMA)
+    frame = pl.DataFrame(rows, strict=False).with_columns(
+        pl.lit(datetime.now(UTC)).alias("inserted_at")
+    )
+    return align(frame, OBSERVATION_SCHEMA)
+
+
+def sibling_path(settings: Settings, name: str) -> Path | None:
+    if settings.siblings_dir is None:
+        return None
+    path = settings.siblings_dir / SIBLING_DIRS[name] / "data"
+    return path if path.is_dir() else None
+
+
+def _download_sibling(name: str, patterns: list[str], token: str | None) -> Path:
+    from huggingface_hub import snapshot_download
+
+    LOGGER.info("downloading %s from %s", patterns, SOURCE_REPOS[name])
+    return Path(
+        snapshot_download(
+            repo_id=SOURCE_REPOS[name],
+            repo_type="dataset",
+            allow_patterns=patterns,
+            token=token,
+        )
+    )
+
+
+def sibling_frame(
+    settings: Settings, name: str, config: str, columns: list[str], *, token: str | None = None
+) -> pl.LazyFrame:
+    """One config of a sibling dataset, local if available, else from the Hub."""
+    local = sibling_path(settings, name)
+    if local is not None:
+        files = sorted(
+            path
+            for path in (local / config).rglob("*.parquet")
+            if not any(part.endswith(".delta") for part in path.parts)
+        )
+        if files:
+            return pl.scan_parquet(files).select(columns)
+    root = _download_sibling(name, [f"data/{config}/**"], token)
+    files = sorted(
+        path
+        for path in (root / "data" / config).rglob("*.parquet")
+        if not any(part.endswith(".delta") for part in path.parts)
+    )
+    if not files:
+        raise FileNotFoundError(f"{SOURCE_REPOS[name]} has no {config} parquet")
+    return pl.scan_parquet(files).select(columns)
+
+
+def from_ownership_filings(settings: Settings, *, token: str | None = None) -> pl.DataFrame:
+    """Tickers and issuer names as Form 4 filers printed them.
+
+    Four million filings, each stating the symbol on the day it was filed. This
+    is the only free source of ticker *history*: `company_tickers.json` states
+    today's map and carries no past, so a company that changed symbol is listed
+    under the new one for its whole life.
+    """
+    frame = sibling_frame(
+        settings, "insider", "filings",
+        ["issuer_cik", "issuer_name", "issuer_trading_symbol_raw", "filing_date",
+         "accession_number"],
+        token=token,
+    ).collect()
+    LOGGER.info("ownership filings: %d", frame.height)
+
+    rows: list[dict] = []
+    for cik, name, raw, filed, accession in frame.iter_rows():
+        if filed is None or not cik:
+            continue
+        for symbol in parse_symbols(raw):
+            rows.append({
+                "cik": cik, "kind": "ticker", "value": symbol.ticker,
+                "observed_on": filed, "source": "form4", "source_ref": accession,
+            })
+            if symbol.exchange:
+                rows.append({
+                    "cik": cik, "kind": "exchange", "value": symbol.exchange,
+                    "observed_on": filed, "source": "form4", "source_ref": accession,
+                })
+        if name:
+            rows.append({
+                "cik": cik, "kind": "name", "value": name.strip(),
+                "observed_on": filed, "source": "form4", "source_ref": accession,
+            })
+    return _observations(rows)
+
+
+def from_fundamental_filings(settings: Settings, *, token: str | None = None) -> pl.DataFrame:
+    """Names, former names, industry and incorporation, dated by filing.
+
+    `former_name` is the one identifier here that carries its own end date: the
+    filing states the name it used to have and when it changed, which no run of
+    observations could reconstruct.
+    """
+    frame = sibling_frame(
+        settings, "fundamentals", "filings",
+        ["cik", "company_name", "former_name", "former_name_changed", "sic",
+         "fiscal_year_end", "state_incorporated", "filed_date", "accession_number"],
+        token=token,
+    ).collect()
+    LOGGER.info("fundamental filings: %d", frame.height)
+
+    rows: list[dict] = []
+    for cik, name, former, changed, sic, fye, state, filed, accession in frame.iter_rows():
+        if filed is None or not cik:
+            continue
+        base = {"cik": cik, "observed_on": filed, "source": "xbrl", "source_ref": accession}
+        if name:
+            rows.append({**base, "kind": "name", "value": name.strip()})
+        if former:
+            rows.append({
+                **base, "kind": "former_name", "value": former.strip(),
+                "observed_on": changed or filed,
+            })
+        if sic:
+            rows.append({**base, "kind": "sic", "value": sic})
+        if fye:
+            rows.append({**base, "kind": "fiscal_year_end", "value": fye})
+        if state:
+            rows.append({**base, "kind": "state_incorporated", "value": state})
+    return _observations(rows)
+
+
+async def from_company_tickers(client, *, today: date | None = None) -> pl.DataFrame:
+    """SEC's current CIK-to-ticker map, with the exchange.
+
+    It states today and only today, which is exactly why it cannot be the whole
+    dataset -- but it is authoritative for what is listed right now, and it
+    covers companies that never filed a Form 4.
+    """
+    payload = await client.get_json(COMPANY_TICKERS_URL, max_age_seconds=24 * 3600)
+    fields = payload.get("fields") if isinstance(payload, dict) else None
+    records = payload.get("data") if isinstance(payload, dict) else payload
+    observed = today or date.today()
+    rows: list[dict] = []
+    for record in records or []:
+        item = dict(zip(fields, record, strict=False)) if fields else record
+        cik = str(item.get("cik") or item.get("cik_str") or "").strip()
+        if not cik.isdigit():
+            continue
+        cik = cik.zfill(10)
+        base = {"cik": cik, "observed_on": observed, "source": "company_tickers",
+                "source_ref": "company_tickers_exchange.json"}
+        ticker = (item.get("ticker") or "").strip().upper()
+        if ticker:
+            rows.append({**base, "kind": "ticker", "value": ticker})
+        exchange = (item.get("exchange") or "").strip().upper()
+        if exchange:
+            rows.append({**base, "kind": "exchange", "value": exchange})
+        name = (item.get("name") or item.get("title") or "").strip()
+        if name:
+            rows.append({**base, "kind": "name", "value": name})
+    LOGGER.info("company_tickers: %d observations", len(rows))
+    return _observations(rows)
+
+
+async def ftd_archives(client) -> list[str]:
+    """Every fails-to-deliver file SEC currently links to."""
+    html = await client.get_text(FTD_INDEX_URL, max_age_seconds=24 * 3600)
+    links = {f"https://www.sec.gov{path}": month for path, month in FTD_LINK.findall(html)}
+    return sorted(links)
+
+
+def parse_ftd(payload: bytes, *, source_ref: str) -> Iterator[dict]:
+    """CUSIP, symbol and issuer name as the clearing record states them.
+
+    Settlement records are a strange place to find a security master, and they
+    are the best free one: `SETTLEMENT DATE|CUSIP|SYMBOL|QUANTITY|DESCRIPTION|
+    PRICE`, twice a month since 2004, twelve thousand securities a file. No
+    other free source ties a CUSIP to a ticker on a date.
+    """
+    with zipfile.ZipFile(io.BytesIO(payload)) as archive:
+        name = archive.namelist()[0]
+        text = archive.read(name).decode("latin-1")
+    for line in text.splitlines()[1:]:
+        parts = line.split("|")
+        if len(parts) < 5:
+            continue
+        settled, cusip, symbol, _quantity, description = (part.strip() for part in parts[:5])
+        if len(settled) != 8 or not settled.isdigit() or not cusip or not symbol:
+            continue
+        observed = date(int(settled[:4]), int(settled[4:6]), int(settled[6:]))
+        yield {"cusip": cusip.upper(), "ticker": symbol.upper(),
+               "issuer_name": description, "observed_on": observed, "source_ref": source_ref}

recipe/store.py

@@ -0,0 +1,120 @@
+"""Write and read the published tables.
+
+Storage is deliberately simpler here than in the sibling datasets. There, rows
+arrive one filing at a time from a feed and an append-only store with a primary
+key is the only way to tell a new row from one already held. Here the unit of
+arrival is a whole quarterly archive, and every accession appears in exactly
+one archive -- verified across four quarters, zero overlap. So a quarter is
+written as one partition that a rebuild reproduces byte for byte, no key column
+is needed, and re-ingesting a quarter is idempotent by construction rather than
+by comparison.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+from collections.abc import Mapping
+from pathlib import Path
+
+import polars as pl
+
+from .schema import CONFIG_SCHEMAS, align
+
+PARTITION = "kind"
+# Facts of one quarter run to about forty megabytes of parquet; splitting that
+# into several files would only multiply metadata. One file per quarter also
+# makes the partition trivially replaceable.
+PART_NAME = "part-00000.parquet"
+
+
+def partition_dir(data_dir: Path, table: str, quarter: str) -> Path:
+    return Path(data_dir) / table / f"{PARTITION}={quarter}"
+
+
+def atomic_write_parquet(frame: pl.DataFrame, target: Path) -> None:
+    """Write through a temporary file in the same directory, then rename.
+
+    A partly written parquet is indistinguishable from a valid one until it is
+    read, and a build interrupted mid-write would leave the dataset in a state
+    that only fails later, in a consumer's process.
+    """
+    target.parent.mkdir(parents=True, exist_ok=True)
+    descriptor, temporary = tempfile.mkstemp(
+        prefix=".part-", suffix=".parquet", dir=target.parent
+    )
+    os.close(descriptor)
+    try:
+        frame.write_parquet(temporary, compression="zstd", statistics=True)
+        os.replace(temporary, target)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+def write_quarter(
+    data_dir: Path, table: str, quarter: str, frame: pl.DataFrame
+) -> tuple[Path, int]:
+    """Replace one quarter's partition of one table."""
+    schema = CONFIG_SCHEMAS[table]
+    directory = partition_dir(data_dir, table, quarter)
+    if directory.exists():
+        shutil.rmtree(directory)
+    target = directory / PART_NAME
+    atomic_write_parquet(align(frame, schema), target)
+    return target, frame.height
+
+
+def ingested_quarters(data_dir: Path, table: str = "facts") -> set[str]:
+    """Quarters already on disk, read from the partition names themselves.
+
+    A separate ledger file would be a second source of truth about what was
+    built, and the two would disagree the first time a run was interrupted.
+    """
+    root = Path(data_dir) / table
+    if not root.is_dir():
+        return set()
+    return {
+        path.name.split("=", 1)[1]
+        for path in root.iterdir()
+        if path.is_dir() and path.name.startswith(f"{PARTITION}=") and any(path.iterdir())
+    }
+
+
+def read_table(
+    data_dir: Path, table: str, *, quarters: set[str] | None = None
+) -> pl.LazyFrame:
+    """Lazy scan of a table, optionally restricted to some quarters."""
+    root = Path(data_dir) / table
+    if not root.is_dir():
+        return pl.LazyFrame(schema=dict(CONFIG_SCHEMAS[table]))
+    # The Delta table lives inside the pit directory and is made of parquet
+    # files holding the very same rows. Globbing them alongside the partitions
+    # returns every point-in-time event twice, which reads as a broken
+    # projection rather than as a directory-listing mistake.
+    files = sorted(
+        path
+        for path in root.rglob("*.parquet")
+        if not any(part.endswith(".delta") or part == "_delta_log" for part in path.parts)
+        and (quarters is None or path.parent.name.split("=", 1)[-1] in quarters)
+    )
+    if not files:
+        return pl.LazyFrame(schema=dict(CONFIG_SCHEMAS[table]))
+    return pl.scan_parquet(files)
+
+
+def table_rows(data_dir: Path, table: str) -> int:
+    return int(read_table(data_dir, table).select(pl.len()).collect().item())
+
+
+def write_singleton(data_dir: Path, table: str, frame: pl.DataFrame) -> Path:
+    """A table small enough to live in one file, such as the archive ledger."""
+    target = Path(data_dir) / table / PART_NAME
+    atomic_write_parquet(align(frame, CONFIG_SCHEMAS[table]), target)
+    return target
+
+
+def config_row_counts(data_dir: Path, tables: Mapping[str, object] | None = None) -> dict[str, int]:
+    names = list(tables or CONFIG_SCHEMAS)
+    return {name: table_rows(data_dir, name) for name in names}

recipe/symbols.py

@@ -0,0 +1,144 @@
+"""Turn what a filing wrote in the ticker box into tickers.
+
+Four million Form 4 filings state a trading symbol, and 2.3% of them state
+something else: an exchange prefix (`NYSE: KRC`), parentheses (`(SIRI)`), two
+share classes at once (`ISCA, ISCB`, `JWA/JWB`, `BFA, BFB`), or a word meaning
+absence (`NONE`, `N/A`). Read literally, those become 3 428 tickers that never
+traded, and the companies behind them - Hubbell, Brown-Forman, Wiley - lose
+their real symbols.
+
+The parser returns every symbol it finds, because a company with two share
+classes genuinely has two, and the exchange when the filer volunteered one.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+# A symbol as the exchanges write them: up to five letters, optionally a class
+# suffix after a dot or dash. Deliberately not looser -- a pattern that accepts
+# anything short and upper-case swallows "NONE", "OTC" and "N A".
+SYMBOL = re.compile(r"^[A-Z]{1,5}(?:[.\-][A-Z]{1,2})?$")
+
+# Words filers write to mean "no symbol". Matched whole, after stripping.
+ABSENT = frozenset({
+    "NONE", "N/A", "NA", "N A", "N.A.", "NOTAPPLICABLE", "NOT APPLICABLE",
+    "NOTLISTED", "NOT LISTED", "NOTRADING", "NO TRADING SYMBOL", "NO SYMBOL",
+    "PRIVATE", "UNLISTED", "--", "-", ".", "*", "TBD", "PENDING", "XXX",
+})
+
+# Exchange names filers put in front of the symbol. The value is the canonical
+# code kept alongside the ticker: the prefix is noise for identification and
+# evidence for listing.
+EXCHANGE_PREFIX = {
+    "NYSE": "NYSE", "NEW YORK STOCK EXCHANGE": "NYSE", "NYSE MKT": "NYSEAMERICAN",
+    "NYSE AMERICAN": "NYSEAMERICAN", "NYSE ARCA": "NYSEARCA", "ARCA": "NYSEARCA",
+    "AMEX": "NYSEAMERICAN", "AMERICAN STOCK EXCHANGE": "NYSEAMERICAN",
+    "NASDAQ": "NASDAQ", "NASD": "NASDAQ", "NASDAQ GS": "NASDAQ",
+    "NASDAQ GM": "NASDAQ", "NASDAQ CM": "NASDAQ", "NASDAQ GLOBAL SELECT": "NASDAQ",
+    "OTC": "OTC", "OTCBB": "OTC", "OTC BB": "OTC", "OTC MARKETS": "OTC",
+    "PINK": "OTC", "PINK SHEETS": "OTC", "CBOE": "CBOE", "BATS": "CBOE",
+    "TSX": "TSX", "TSXV": "TSXV", "LSE": "LSE",
+}
+
+_SPLIT = re.compile(r"[,;/&]| and | or ", re.I)
+# Decoration around a symbol. A character-set strip is easy to mistype -- this
+# one carried a duplicated bracket for a while -- and says less about intent.
+_TRIM = re.compile(r"^[\s()\[\]{}\"']+|[\s()\[\]{}\"']+$")
+# A trailing venue note: NWIN(OB), ACME (Pink Sheets).
+_TRAILING_NOTE = re.compile(r"\s*\(([^)]{1,20})\)\s*$")
+_PREFIX = re.compile(r"^\s*([A-Za-z .]{2,28}?)\s*[:\-]\s*(.+)$")
+
+
+@dataclass(frozen=True, slots=True)
+class Symbol:
+    ticker: str
+    exchange: str | None = None
+
+
+def _clean(chunk: str) -> tuple[str, str | None]:
+    """Strip decoration from one chunk and pull out an exchange if it is there."""
+    # The trailing note is read before brackets are stripped: stripping first
+    # turns "NWIN(OB)" into "NWIN(OB", which matches nothing.
+    text = re.sub(r"\s+", " ", chunk.strip())
+    exchange: str | None = None
+    note = _TRAILING_NOTE.search(text)
+    if note and SYMBOL.match(_TRIM.sub("", text[: note.start()]).upper()):
+        exchange = EXCHANGE_PREFIX.get(note.group(1).strip().upper())
+        text = text[: note.start()].strip()
+    text = _TRIM.sub("", text)
+    # "N O G" is one symbol written with spaces, not three symbols.
+    letters = text.split(" ")
+    if len(letters) > 1 and all(len(part) == 1 and part.isalpha() for part in letters):
+        text = "".join(letters)
+    match = _PREFIX.match(text)
+    if match:
+        candidate = match.group(1).strip().upper().rstrip(".")
+        if candidate in EXCHANGE_PREFIX:
+            exchange = EXCHANGE_PREFIX[candidate]
+            text = match.group(2).strip()
+        elif SYMBOL.match(candidate) and not SYMBOL.match(match.group(2).strip().upper()):
+            # "KRC - New York Stock Exchange": the symbol is on the left, and
+            # the exchange is still worth keeping.
+            exchange = EXCHANGE_PREFIX.get(match.group(2).strip().upper().rstrip("."))
+            text = candidate
+    return _TRIM.sub("", text), exchange
+
+
+def parse_symbols(raw: str | None) -> list[Symbol]:
+    """Every symbol stated in one ticker field, in the order written."""
+    if raw is None:
+        return []
+    text = re.sub(r"\s+", " ", raw).strip()
+    if not text or text.upper() in ABSENT:
+        return []
+
+    outer_exchange: str | None = None
+    stripped, exchange = _clean(text)
+    if exchange:
+        outer_exchange, text = exchange, stripped
+
+    # Split on separators first, then on plain spaces -- "CRDA CRDB" is two
+    # share classes. A single chunk that already parses is left alone, so a
+    # symbol containing a space is not shredded.
+    chunks = _SPLIT.split(text)
+    if len(chunks) == 1 and " " in text and not SYMBOL.match(_clean(text)[0].upper()):
+        chunks = text.split(" ")
+
+    found: list[Symbol] = []
+    seen: set[str] = set()
+    exchange_only: list[str] = []
+    for chunk in chunks:
+        candidate, chunk_exchange = _clean(chunk)
+        upper = candidate.upper()
+        # "NYSE/TRN" splits into two chunks and the first is an exchange, not a
+        # four-letter ticker. But "CBOE" alone is Cboe Global Markets, whose
+        # ticker is its own name -- so a venue name is only discarded when some
+        # other chunk turned out to be a symbol.
+        if upper in EXCHANGE_PREFIX:
+            exchange_only.append(upper)
+            continue
+        if not upper or upper in ABSENT or not SYMBOL.match(upper):
+            continue
+        if upper in seen:
+            continue
+        seen.add(upper)
+        found.append(Symbol(ticker=upper, exchange=chunk_exchange or outer_exchange))
+
+    if not found and exchange_only:
+        return [
+            Symbol(ticker=name, exchange=None)
+            for name in exchange_only
+            if SYMBOL.match(name)
+        ]
+    if found and exchange_only:
+        venue = EXCHANGE_PREFIX[exchange_only[0]]
+        found = [Symbol(s.ticker, s.exchange or venue) for s in found]
+    return found
+
+
+def primary_symbol(raw: str | None) -> str | None:
+    """The first symbol, which is the one a filer writes for the main class."""
+    symbols = parse_symbols(raw)
+    return symbols[0].ticker if symbols else None

tests/conftest.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import sys
+from datetime import UTC, date, datetime
+from pathlib import Path
+
+import polars as pl
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+
+def observation(cik, kind, value, day, source="form4", ref="acc-1"):
+    return {"cik": cik, "kind": kind, "value": value, "observed_on": day,
+            "source": source, "source_ref": ref, "inserted_at": datetime.now(UTC)}
+
+
+@pytest.fixture
+def observations() -> pl.DataFrame:
+    """A filer that renamed itself and changed ticker, plus a later reuser.
+
+    `PLUM` moves from one company to another, which is the case a security
+    master exists to get right: a backtest that resolves it by today's mapping
+    reads the wrong company's history for the earlier years.
+    """
+    rows = [
+        observation("0000000001", "ticker", "OLDT", date(2012, 3, 1), ref="a1"),
+        observation("0000000001", "ticker", "OLDT", date(2015, 3, 1), ref="a2"),
+        observation("0000000001", "ticker", "NEWT", date(2016, 3, 1), ref="a3"),
+        observation("0000000001", "ticker", "NEWT", date(2024, 3, 1), ref="a4"),
+        observation("0000000001", "name", "Old Name Inc", date(2012, 3, 1), ref="a1"),
+        observation("0000000001", "name", "New Name Inc", date(2024, 3, 1), ref="a4"),
+        observation("0000000001", "sic", "3571", date(2024, 3, 1), source="xbrl", ref="a4"),
+        # PLUM belonged to filer 2 until 2014 and to filer 3 from 2019.
+        observation("0000000002", "ticker", "PLUM", date(2010, 5, 1), ref="b1"),
+        observation("0000000002", "ticker", "PLUM", date(2014, 5, 1), ref="b2"),
+        observation("0000000003", "ticker", "PLUM", date(2019, 5, 1), ref="c1"),
+        observation("0000000003", "ticker", "PLUM", date(2024, 5, 1), ref="c2"),
+    ]
+    return pl.DataFrame(rows, strict=False)
+
+
+@pytest.fixture
+def ftd() -> pl.DataFrame:
+    return pl.DataFrame(
+        [
+            {"cusip": "111111111", "ticker": "PLUM", "issuer_name": "PLUM CORP",
+             "observed_on": date(2012, 6, 1), "source_ref": "f1"},
+            {"cusip": "222222222", "ticker": "PLUM", "issuer_name": "PLUM HOLDINGS",
+             "observed_on": date(2022, 6, 1), "source_ref": "f2"},
+            {"cusip": "333333333", "ticker": "GHOST", "issuer_name": "GHOST INC",
+             "observed_on": date(2020, 6, 1), "source_ref": "f3"},
+        ],
+        strict=False,
+    )

tests/test_docs_and_jobs.py

@@ -0,0 +1,58 @@
+"""The published documents and the job must describe what is actually built."""
+
+from __future__ import annotations
+
+import json
+import re
+import tomllib
+from pathlib import Path
+
+import yaml
+
+from recipe.hf_jobs import DEFAULT_SCHEDULE, JOB_SCRIPT
+from recipe.schema import CONFIG_SCHEMAS
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _frontmatter() -> dict:
+    text = (ROOT / "README.md").read_text(encoding="utf-8")
+    assert text.startswith("---\n")
+    return yaml.safe_load(text.split("---\n", 2)[1])
+
+
+def test_readme_declares_every_config():
+    assert {entry["config_name"] for entry in _frontmatter()["configs"]} == set(CONFIG_SCHEMAS)
+
+
+def test_readme_has_no_unfilled_placeholders():
+    assert not re.findall(r"\{\{[A-Z_]+\}\}", (ROOT / "README.md").read_text(encoding="utf-8"))
+
+
+def test_job_script_declares_every_runtime_dependency():
+    """A Job installs from the script header alone; a gap fails only in the cloud."""
+    project = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))["project"]
+    required = {re.split(r"[<>=]", n, maxsplit=1)[0].strip().lower() for n in project["dependencies"]}
+    for group in ("dev", "publish"):
+        required |= {
+            re.split(r"[<>=]", n, maxsplit=1)[0].strip().lower()
+            for n in project.get("optional-dependencies", {}).get(group, [])
+        }
+    header = (ROOT / JOB_SCRIPT).read_text(encoding="utf-8").split("# ///")[1]
+    declared = {m.group(1).lower() for m in re.finditer(r'"\s*([A-Za-z0-9_.-]+)\s*[<>=]', header)}
+    assert required <= declared
+
+
+def test_manifest_matches_the_recipe():
+    from recipe.build import PIT_DELTA_NAME
+
+    manifest = json.loads((ROOT / "manifest.json").read_text(encoding="utf-8"))
+    assert manifest["bundle_storage_data"]["table_uri"].endswith(PIT_DELTA_NAME)
+    assert manifest["source"]["schedule"] == DEFAULT_SCHEDULE
+
+
+def test_schedule_runs_after_the_dataset_it_reads():
+    """This dataset is assembled from company-fundamentals; reading yesterday's
+    revision would publish a master that lags its own sources by a week."""
+    hour, minute = int(DEFAULT_SCHEDULE.split()[1]), int(DEFAULT_SCHEDULE.split()[0])
+    assert (hour, minute) > (7, 10), DEFAULT_SCHEDULE

tests/test_intervals.py

@@ -0,0 +1,89 @@
+"""Observations into spans, filers, and the CUSIP bridge."""
+
+from __future__ import annotations
+
+from datetime import date
+
+import polars as pl
+
+from recipe.intervals import build_cusip_map, build_identifiers, build_issuers, build_pit
+
+
+def test_a_ticker_change_becomes_two_spans(observations):
+    spans = build_identifiers(observations)
+    ticker = spans.filter(
+        (pl.col("cik") == "0000000001") & (pl.col("kind") == "ticker")
+    ).sort("valid_from")
+    assert ticker["value"].to_list() == ["OLDT", "NEWT"]
+    assert ticker["valid_from"].to_list() == [date(2012, 3, 1), date(2016, 3, 1)]
+    assert ticker["valid_to"].to_list() == [date(2015, 3, 1), date(2024, 3, 1)]
+    assert ticker["is_current"].to_list() == [False, True]
+
+
+def test_a_dormant_filer_holds_no_current_ticker(observations):
+    """A company that stopped filing in 2014 is not currently listed under its
+    2014 ticker -- and PLUM belongs to whoever files under it now."""
+    spans = build_identifiers(observations)
+    plum = spans.filter((pl.col("kind") == "ticker") & (pl.col("value") == "PLUM"))
+    current = plum.filter(pl.col("is_current"))
+    assert current.height == 1, "one live owner, not two"
+    assert current["cik"][0] == "0000000003"
+    # The dormant filer keeps its own history, flagged as its latest.
+    dormant = plum.filter(pl.col("cik") == "0000000002").row(0, named=True)
+    assert dormant["is_current"] is False
+    assert dormant["is_latest_for_filer"] is True
+    assert dormant["valid_to"] == date(2014, 5, 1)
+
+
+def test_issuer_keeps_its_name(observations):
+    """Regression: the changes pivot produced a column called `name` too, and
+    renaming after the join blanked every issuer's name."""
+    spans = build_identifiers(observations)
+    issuers = build_issuers(spans, observations)
+    row = issuers.filter(pl.col("cik") == "0000000001").row(0, named=True)
+    assert row["name"] == "New Name Inc"
+    assert row["primary_ticker"] == "NEWT"
+    assert row["name_changes"] == 2
+    assert row["ticker_changes"] == 2
+    assert row["sic"] == "3571"
+
+
+def test_dormant_filers_are_marked_inactive(observations):
+    spans = build_identifiers(observations)
+    issuers = build_issuers(spans, observations)
+    assert issuers.filter(pl.col("cik") == "0000000002")["is_active"][0] is False
+    assert issuers.filter(pl.col("cik") == "0000000001")["is_active"][0] is True
+
+
+def test_a_reused_ticker_resolves_by_date(observations, ftd):
+    """The point of the bridge: PLUM is two companies, and the CUSIP knows when."""
+    spans = build_identifiers(observations)
+    bridge = build_cusip_map(ftd, spans)
+    early = bridge.filter(pl.col("cusip") == "111111111").row(0, named=True)
+    late = bridge.filter(pl.col("cusip") == "222222222").row(0, named=True)
+    assert early["cik"] == "0000000002" and early["match_confidence"] == "high"
+    assert late["cik"] == "0000000003" and late["match_confidence"] == "high"
+
+
+def test_a_cusip_with_no_filer_is_kept_and_labelled(observations, ftd):
+    spans = build_identifiers(observations)
+    bridge = build_cusip_map(ftd, spans)
+    ghost = bridge.filter(pl.col("cusip") == "333333333").row(0, named=True)
+    assert ghost["cik"] is None
+    assert ghost["match_method"] == "unmatched" and ghost["match_confidence"] == "none"
+    assert ghost["ticker"] == "GHOST", "the ticker is still usable without a filer"
+
+
+def test_cusip6_is_the_issuer_prefix(observations, ftd):
+    bridge = build_cusip_map(ftd, build_identifiers(observations))
+    assert bridge.filter(pl.col("cusip") == "111111111")["cusip6"][0] == "111111"
+
+
+def test_pit_dates_every_span_and_never_leaks(observations):
+    spans = build_identifiers(observations)
+    pit = build_pit(spans)
+    assert pit.height == spans.height
+    assert pit["entity_id"].null_count() == 0
+    # Knowledge is the end of the day observed, so it never precedes the event.
+    assert (pit["knowledge_date"].dt.date() >= pit["event_date"]).all()
+    assert pit["knowledge_estimated"].all()

tests/test_symbols.py

@@ -0,0 +1,50 @@
+"""The ticker box, and everything filers put in it that is not a ticker."""
+
+from __future__ import annotations
+
+import pytest
+
+from recipe.symbols import parse_symbols, primary_symbol
+
+
+@pytest.mark.parametrize(
+    ("raw", "expected"),
+    [
+        ("AAPL", [("AAPL", None)]),
+        ("brk.b", [("BRK.B", None)]),
+        # Two share classes in one box: Hubbell, Wiley, Brown-Forman all do this.
+        ("ISCA, ISCB", [("ISCA", None), ("ISCB", None)]),
+        ("JWA/JWB", [("JWA", None), ("JWB", None)]),
+        ("CRDA CRDB", [("CRDA", None), ("CRDB", None)]),
+        # An exchange prefix is evidence of listing, not part of the symbol.
+        ("NYSE: KRC", [("KRC", "NYSE")]),
+        ("(NYSE:FBC)", [("FBC", "NYSE")]),
+        ("NYSE/TRN", [("TRN", "NYSE")]),
+        ("KRC - New York Stock Exchange", [("KRC", "NYSE")]),
+        ("ACME (Pink Sheets)", [("ACME", "OTC")]),
+        ("NWIN(OB)", [("NWIN", None)]),
+        ("(SIRI)", [("SIRI", None)]),
+        ("N O G", [("NOG", None)]),
+        # Cboe Global Markets trades as CBOE: a venue name can be a real ticker,
+        # so it is only discarded when something else in the field parsed.
+        ("CBOE", [("CBOE", None)]),
+        ("NONE", []),
+        ("N/A", []),
+        ("none", []),
+        ("", []),
+        (None, []),
+        # A CIK typed into the ticker box.
+        ("1314152", []),
+    ],
+)
+def test_parses(raw, expected):
+    assert [(s.ticker, s.exchange) for s in parse_symbols(raw)] == expected
+
+
+def test_primary_symbol_takes_the_first_class():
+    assert primary_symbol("ISCA, ISCB") == "ISCA"
+    assert primary_symbol("NONE") is None
+
+
+def test_duplicates_within_one_field_collapse():
+    assert [s.ticker for s in parse_symbols("AAPL, AAPL")] == ["AAPL"]