Update the industry classification

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,25 @@
+ZipLime US Industry Classification
+Copyright 2026 ZipLime
+
+Source data:
+
+* US Securities and Exchange Commission — the Standard Industrial
+  Classification code assigned to each EDGAR filer, read from filing headers
+  and from EDGAR's submissions archive, and the SEC's published list of the
+  codes it assigns. US Government works in the public domain.
+* US Census Bureau — the 1987 SIC to 1997 NAICS concordance, and the 1987 SIC
+  hierarchy it states. US Government works in the public domain.
+
+Assembled from the ZipLime company-fundamentals and security-master datasets,
+which are themselves derived from EDGAR.
+
+The sector and industry taxonomy in recipe/taxonomy.py is original work by
+ZipLime, licensed under Apache-2.0 with the rest of the recipe (see LICENSE).
+
+This dataset is NOT GICS and NOT ICB. It does not reproduce, approximate or
+substitute for either. GICS is a product of MSCI and S&P Dow Jones Indices;
+ICB is a product of FTSE Russell. Neither is used here, and no classification
+licensed from either was consulted in building this one.
+
+Neither the SEC nor the Census Bureau endorses, certifies or verifies this
+dataset.

PIPELINE.md

@@ -0,0 +1,207 @@
+# 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, which judgements were made, and
+what went wrong on the way.
+
+## The idea
+
+Sector classification is a licensed product. GICS belongs to MSCI and S&P Dow
+Jones Indices, ICB to FTSE Russell, and neither can be redistributed — so a
+free dataset that wants to say what business a company is in has to build the
+answer from something else.
+
+The something else exists and is public domain: the SEC assigns a Standard
+Industrial Classification code to every filer, prints it in the header of
+every filing, and publishes the list of the 444 codes it uses. What it does
+not provide is a rollup worth using. The SIC divisions put pharmaceuticals,
+semiconductors, oil refining and breweries in one bucket called Manufacturing
+that covers a third of the listed universe.
+
+So this dataset is two things: the SEC's codes collected with their dates, and
+a rollup from those codes to sectors, written here and licensed Apache-2.0.
+The first is evidence; the second is an opinion, stated as code in
+[`recipe/taxonomy.py`](recipe/taxonomy.py) so it can be argued with.
+
+## Why it is not GICS
+
+It would be easy to write eleven sectors with GICS's names and let readers
+assume compatibility. That would be wrong twice: legally, because the GICS
+structure is a licensed product, and factually, because a SIC-derived sector
+disagrees with GICS on real companies.
+
+The disagreements are not marginal. Alphabet and Meta are Communication
+Services in GICS; here they are Technology, because EDGAR files them under
+7370 alongside systems integrators and nothing in a filing separates an
+advertising platform from a consultancy. Managed care is Health Care in both,
+but by different routes. Most of all, GICS has no bucket for a blank cheque
+company, and this taxonomy gives it a sector of its own because 2 167 filers
+have been one.
+
+Fama and French's industry definitions were considered and left out. They are
+the standard free taxonomy in academic finance and they would have been a
+natural fit — but the files carry a bare copyright notice with no licence
+grant, and the portfolios built from them derive from CRSP. Shipping a
+redistributable dataset meant not shipping them. Anyone who wants them can
+apply them to the `sic` column in a line of code; this dataset simply does not
+carry the table.
+
+## Three sources and almost no source of its own
+
+Like the security master, this is mostly glue.
+
+**The history** comes from `company-fundamentals`, a sibling dataset, whose
+`filings` table carries the SIC printed in the header of every XBRL filing
+since 2009 — 431 290 dated statements over 16 771 filers. This is the only
+free source of SIC *history*. EDGAR's own record of a filer states today's
+code and carries no past, so a dataset built on it alone would say Lucid was
+a car maker in 2020, when it was an empty shell called Churchill Capital IV.
+
+Measured on the corpus, **2 281 filers have been reclassified at least once**:
+13.6% of the 16 771 with a filing history, which is the only population where
+a change could be seen at all. That is the number that decides whether the
+dated columns are worth their weight.
+
+**The gap** is the 5 863 filers that have had a ticker and never filed XBRL:
+delisted before 2009, funds, foreign issuers on paper. They are covered from
+EDGAR's submissions archive, and what it gives is explicitly undated — the SEC
+states what it has the filer under now, not when that was assigned. Those rows
+carry `is_dated = false` and `date_basis = "undated"`, and the `by_ticker`
+table stretches the code over the ticker's life rather than pretending to a
+date it does not have.
+
+Leaving them out was the alternative, and it would have made the universe out
+of survivors. That is the bias the rest of this family exists to avoid.
+
+**The reference** is the SEC's SIC code list — scraped, because it is a web
+page and nothing else; there is no CSV, no JSON and no bulk file — and the
+Census Bureau's 1987 SIC to 1997 NAICS concordance, which doubles as the
+source for the 1987 hierarchy's own titles.
+
+## What a SIC code is, and what EDGAR's codes are
+
+These are two different things, and conflating them loses two fifths of the
+list.
+
+The 1987 SIC has 1 005 four-digit industries in 83 major groups. EDGAR assigns
+444 codes, and only 284 of them are 1987 industries. The other 160 are a major
+group or an industry group padded with zeros — `2000` for the whole of food,
+`3570` for computer and office equipment — used when the SEC did not care to
+be more precise.
+
+Checked against all 1 005 of them: **no real 1987 code ends in a zero**. So the
+padding is unambiguous and `sic_level` reads it off. Joining EDGAR's codes to
+the NAICS crosswalk as if they were 1987 industries would have silently
+dropped 39% of them; instead a roll-up is expanded to every industry beneath
+it before the crosswalk is consulted.
+
+Twelve EDGAR codes are inventions with no 1987 counterpart at all: asset
+backed securities, blank cheques, finance lessors, American Depositary
+Receipts, foreign governments, non-operating establishments and six others.
+Three of them sit arithmetically in major group 88, which is Private
+Households — so `division_of` returns nothing for them rather than calling a
+depositary receipt a household service.
+
+## The NAICS bridge is weak, and says so
+
+Measured over this corpus: 32.7% of EDGAR's codes resolve to exactly one 1997
+NAICS industry, 71.9% to exactly one NAICS sector, and fourteen codes resolve
+to nothing. The rest are one-to-many, because 1997 split a 1987 industry in two.
+
+So `naics_1997` is filled only where the answer is unique, `naics_sector` only
+where the sector is unique, and `naics_candidates` says how many there were.
+Picking one by a tie-break would read as fact and be a coin toss. The full
+crosswalk ships as `naics_map` so anyone who wants to pick differently can.
+
+## Spans are runs, not groups
+
+A filer's codes are collapsed into runs of consecutive filings that said the
+same thing — not grouped by (filer, code). A company that was a blank cheque,
+became a car maker and was reclassified back has three spans, and a groupby
+would flatten it to two and lose the order the SEC saw it in.
+
+`valid_to` is the last filing that stated the code, not the day before the
+next one. Nobody publishes the day a classification changed, and a filing gap
+is a filing gap.
+
+## `by_ticker`, and the two ways it can be wrong
+
+This is the table most people will use: a symbol, a window, a sector. It is
+the overlap of a ticker span from the security master and a SIC span from
+here, both over the same filer.
+
+Two decisions:
+
+* **Every ticker gets a row**, including the ones with no code at all, marked
+  `unknown` and unclassified. A symbol missing from the table and a symbol the
+  SEC never classified look identical to a consumer, and only one of them is a
+  bug.
+* **`is_current` marks exactly one row per live ticker** — the filer's symbol
+  now, under the newest code it has been seen under. The first version marked
+  the ticker span current, which brought a reclassified company back under
+  both its old sector and its new one, and `filter(is_current)` returned two
+  contradictory rows for the same symbol.
+
+## Verification
+
+[`quality.py`](recipe/quality.py) gates publication. Two checks earn their
+place, and both are about the shape of the answer rather than its plumbing:
+
+* **How much of the live universe is unclassified.** The SEC adds codes —
+  asset-backed securities and crypto assets both arrived after the 1987 manual
+  — and nothing else would notice that a new one fell into the catch-all.
+* **How much of it sits in the largest sector.** The whole reason this exists
+  is that the SIC divisions are unusable, Manufacturing alone being a third of
+  the universe. A regression that collapsed the taxonomy back towards its
+  input would show up here and nowhere else. Measured largest sector is Health
+  Care at 16.5%; the ceiling is 30%.
+
+The taxonomy is code, so it is tested like code: every rule has to name an
+industry that exists, every industry a sector that exists, every four-digit
+code has to land somewhere, and no narrow rule may sit after the range that
+contains it — which would make it dead.
+
+## What went wrong
+
+**The per-filer crawl.** The first implementation asked
+`data.sec.gov/submissions/CIK*.json` once per filer, at six requests a second,
+well under SEC's published limit of ten. It ran at **a fifth of a request per
+second**: SEC answers a few hundred and then throttles, and the client spends
+its life in backoff. Eight hours for six thousand small files, and the process
+burned eight seconds of CPU doing it.
+
+SEC publishes a bulk archive of the same directory for exactly this reason. It
+is 1.5 GB and one request, and it arrives in four minutes. The lesson is not
+about rate limits — the rate was within the published limit — but that a
+service offering a bulk file would rather you took it.
+
+**The coverage metric that could not fail.** The first version measured ticker
+coverage over the rows in `by_ticker`, which only contained tickers that had
+resolved. It read 100% while a fifth of the universe was missing from the
+table entirely. Making every ticker present, classified or not, turned the
+metric into one that can go down.
+
+## Schedule
+
+A Hugging Face Job runs [`jobs/run.py`](jobs/run.py) weekly on Monday at 09:40
+UTC: restore, lint, test, rebuild, verify, publish. Two hours after
+`company-fundamentals` (07:10) and `security-master` (07:40), both of which it
+reads — running before them would publish a classification a week behind its
+own sources. Weekly rather than daily because a company's assigned code moves
+on the scale of years.
+
+## What is not done
+
+* **No GICS, ICB or Fama-French.** Covered above. The `sic` column is there so
+  anyone with a licence can bring their own.
+* **No sub-industry below the ~90 industries here.** SIC does not support it:
+  two fifths of EDGAR's codes are already roll-ups, so a finer taxonomy would
+  be inventing precision the input does not carry.
+* **No revenue-based classification.** The right way to classify a
+  conglomerate is by segment revenue, which `company-fundamentals` publishes
+  as dimensional facts. Nothing here reads them yet.
+* **No history before 2009 for anything but the ticker window.** XBRL headers
+  begin in 2009 Q2. A company's code in 1998 is in the SGML header of its
+  filings, four million of them, and that is a separate dataset's worth of
+  work.
+* **No foreign classification.** The universe is SEC filers.

README.md

@@ -0,0 +1,229 @@
+---
+license: apache-2.0
+language:
+  - en
+pretty_name: US Industry Classification — free sectors for SEC filers, with dates
+size_categories:
+  - 100K<n<1M
+task_categories:
+  - tabular-classification
+tags:
+  - finance
+  - sector
+  - industry
+  - classification
+  - sic
+  - naics
+  - sec
+  - edgar
+  - point-in-time
+  - backtesting
+  - ziplime
+configs:
+  - config_name: classification
+    data_files:
+      - split: train
+        path: "data/classification/*.parquet"
+  - config_name: by_ticker
+    data_files:
+      - split: train
+        path: "data/by_ticker/*.parquet"
+  - config_name: spans
+    data_files:
+      - split: train
+        path: "data/spans/*.parquet"
+  - config_name: observations
+    data_files:
+      - split: train
+        path: "data/observations/*.parquet"
+  - config_name: sic_codes
+    data_files:
+      - split: train
+        path: "data/sic_codes/*.parquet"
+  - config_name: naics_map
+    data_files:
+      - split: train
+        path: "data/naics_map/*.parquet"
+  - config_name: taxonomy
+    data_files:
+      - split: train
+        path: "data/taxonomy/*.parquet"
+---
+
+# US Industry Classification
+
+What business a listed company is in — and what business it was in then.
+
+**22 205 filers · 11 322 live tickers · 23 750 dated classification spans ·
+435 269 statements · 15 sectors, 90 industries · 2009 to 2026**
+
+Free to use, free to redistribute. Built entirely from US government works:
+the SIC code the SEC assigns to every filer, and the Census Bureau's bridge to
+NAICS. The rollup from those codes to sectors is ZipLime's own, published
+under Apache-2.0 in [`recipe/taxonomy.py`](recipe/taxonomy.py).
+
+The pipeline lives in [`recipe/`](recipe/) at the same revision as the data.
+See [PIPELINE.md](PIPELINE.md) for the method and its limits.
+
+## This is not GICS and not ICB
+
+It cannot be. GICS belongs to MSCI and S&P Dow Jones Indices, ICB to FTSE
+Russell, and neither can be redistributed — which is the whole reason this
+exists. Nothing licensed from either was used or consulted.
+
+So expect disagreements, and know where they are:
+
+* **Alphabet and Meta are Technology here, Communication Services in GICS.**
+  The SEC files both under 7370, alongside systems integrators, and nothing in
+  a filing separates an advertising platform from a consultancy.
+* **Disney is Consumer Cyclical here, Communication Services in GICS.** Its
+  assigned code is 7990, amusement and recreation. The code is the SEC's.
+* **Blank cheque companies get a sector of their own.** GICS has no bucket for
+  one. 2 167 filers here have been one, and anyone building a universe wants
+  to drop them by name rather than find them scattered through Financials.
+
+If you have a GICS or ICB licence, the `sic` column is here to join against.
+
+## The point: it is dated
+
+A company's industry is not a constant. **2 281 filers have been reclassified
+at least once** — most often a blank cheque that became an operating company.
+
+```python
+import polars as pl
+
+history = pl.read_parquet("data/by_ticker/*.parquet")
+history.filter(pl.col("ticker") == "LCID").select(
+    "valid_from", "valid_to", "sic", "sector", "industry"
+)
+# 2021-07-27 … 2026-05-05 | 3711 | Consumer Cyclical | Automobiles
+```
+
+Churchill Capital IV was SIC 6770, a blank cheque, until it became Lucid. A
+dataset that states only today's code calls it a car maker in 2020, and a
+sector-neutral backtest then shorts the automotive basket against an empty
+shell.
+
+## Getting a sector for a ticker
+
+```python
+import polars as pl
+
+live = (
+    pl.read_parquet("data/by_ticker/*.parquet")
+      .filter(pl.col("is_current"))
+      .select("ticker", "cik", "sector_code", "sector", "industry", "sic")
+)
+```
+
+`is_current` marks exactly one row per live symbol: the filer's ticker now,
+under the newest code it has been seen under. For a date in the past, filter
+on the window instead:
+
+```python
+on = pl.date(2015, 6, 30)
+history.filter((pl.col("valid_from") <= on) & (on <= pl.col("valid_to")))
+```
+
+Join on `cik` wherever you have it. It is stable, and it is the key the rest
+of this dataset family uses.
+
+## Configs
+
+| Config | Rows | What one row is |
+|---|---|---|
+| `classification` | 22 205 | one filer: the sector it is in now, fully resolved |
+| `by_ticker` | 30 729 | one ticker over one window, with the sector it was in then |
+| `spans` | 23 750 | one run of filings that all stated the same SIC code |
+| `observations` | 435 269 | one dated statement — the evidence the spans are built from |
+| `sic_codes` | 444 | one EDGAR SIC code: hierarchy, sector, NAICS bridge, usage |
+| `naics_map` | 1 854 | one 1987 SIC to 1997 NAICS pair from the Census concordance |
+| `taxonomy` | 90 | one industry of the taxonomy and the SIC ranges it covers |
+
+`observations` is published so that anyone who disagrees with how the spans
+were cut can cut their own. It is the only honest way to ship a judgement.
+
+## The taxonomy
+
+Fifteen sectors. Thirteen are what you would expect; three exist because the
+SEC's universe is not just operating companies.
+
+| Sector | Live filers | Note |
+|---|---|---|
+| Health Care | 1 432 | includes Managed Health Care — Centene, Cigna, Elevance |
+| Industrials | 1 145 | |
+| Technology | 1 057 | includes Internet Software & Services |
+| Financials | 1 045 | |
+| Consumer Cyclical | 770 | |
+| Funds & Trusts | 594 | closed-end funds, ETFs, securitisation vehicles |
+| Materials | 506 | |
+| Shell & Blank Check | 452 | SPACs and non-operating establishments |
+| Unclassified | 403 | almost all depositary receipt programmes |
+| Real Estate | 335 | |
+| Energy | 274 | |
+| Consumer Defensive | 267 | |
+| Telecom & Media | 223 | |
+| Utilities | 180 | |
+| Government | — | foreign sovereigns and public administration |
+
+**No sector holds more than 17% of the live universe**, which is the test the
+SIC divisions fail: Division D, Manufacturing, is a third of it on its own.
+
+Read the taxonomy without reading Python:
+
+```python
+pl.read_parquet("data/taxonomy/*.parquet").select(
+    "sector", "industry", "sic_ranges"
+)
+```
+
+## Where it comes from
+
+| Source | What it gives | Rows |
+|---|---|---|
+| XBRL filing headers, via [ZipLime/company-fundamentals](https://huggingface.co/datasets/ZipLime/company-fundamentals) | the code the SEC had a filer under, on the day it filed — the only free source of SIC **history** | 431 290 |
+| EDGAR's submissions archive | today's code for filers that never filed XBRL: delisted before 2009, funds, foreign issuers on paper | 3 979 |
+| EDGAR's submissions archive, read for forms | what kind of entity a filer with no code is — N-CSR means a registered investment company, F-6 a depositary receipt programme | 1 455 |
+| Ticker windows, via [ZipLime/security-master](https://huggingface.co/datasets/ZipLime/security-master) | which symbol belonged to which filer, when | 29 511 |
+| SEC's published SIC code list | the title of each code and the office that reviews it | 444 |
+| Census Bureau 1987 SIC → 1997 NAICS concordance | the NAICS bridge, and the 1987 hierarchy's own titles | 1 854 |
+
+## Coverage and honest gaps
+
+* **97.3% of live tickers get an answer.** The remainder are dormant filers
+  EDGAR has never classified and whose forms say nothing either.
+* **Nothing before 2009.** XBRL headers begin in 2009 Q2. A company's code in
+  1998 is in the SGML header of its filings and is not read here.
+* **`date_basis` tells you what the dates are worth.** `dated` (15 266 rows)
+  means a filing stated the code inside that window. `undated` (13 015) means
+  a code is known for the filer but nothing dates it to that window, so the
+  latest one is applied across it. `unknown` (2 448) means no code at all.
+* **Two fifths of EDGAR's codes are roll-ups.** `2000` means all of food,
+  `3570` all of computer and office equipment. `sic_level` says which you
+  have: 284 of the 444 are real four-digit industries, 118 are three-digit
+  groups, 42 are two-digit major groups.
+* **The NAICS bridge is weak and labelled as such.** Only 32.7% of codes
+  resolve to exactly one 1997 NAICS industry and 71.9% to one NAICS sector.
+  `naics_1997` and `naics_sector` are filled only where the answer is unique;
+  `naics_candidates` says how many there were. The full crosswalk is in
+  `naics_map`.
+* **8731 mixes contract research with research-stage biotech.** Charles River
+  and Incyte share a code, and nothing in a filing separates them.
+* **52 symbols are current for two filers, 30 of them in different sectors.**
+  Genuine ticker transfers and reuse — Barnes Group handed `B` to Barrick.
+  Each row is right for its own filer; deciding who owns a symbol today is
+  [security-master](https://huggingface.co/datasets/ZipLime/security-master)'s
+  job.
+* **The classification is the SEC's opinion, not the company's.** Assigned
+  codes go stale; the SEC does not re-review them on a schedule.
+
+## Provenance and updates
+
+Sources: SEC EDGAR (filing headers via the sibling dataset, and the
+submissions archive), the SEC's SIC code list, and the US Census Bureau's
+SIC-to-NAICS concordance — all US Government works in the public domain. The
+sector taxonomy is ZipLime's own work under Apache-2.0. See [NOTICE](NOTICE).
+
+Rebuilt weekly, Monday 09:40 UTC, by a Hugging Face Job
+([`jobs/run.py`](jobs/run.py)) that lints, tests, rebuilds, verifies and only
+then publishes.

data/by_ticker/part-00000.parquet

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

data/classification/part-00000.parquet

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

data/naics_map/part-00000.parquet

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

data/observations/part-00000.parquet

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

data/sic_codes/part-00000.parquet

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

data/spans/part-00000.parquet

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

data/taxonomy/part-00000.parquet

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

jobs/run.py

@@ -0,0 +1,107 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#   "httpx>=0.27,<1",
+#   "polars>=1.24,<2",
+#   "pyarrow>=18,<21",
+#   "fastexcel>=0.12,<1",
+#   "huggingface-hub>=1.19,<2",
+#   "pytest>=8,<10",
+#   "pytest-asyncio>=0.24,<2",
+#   "ruff==0.16.5",
+#   "pyyaml>=6,<7",
+# ]
+# ///
+"""Hugging Face Jobs entry point for the ZipLime industry-classification dataset.
+
+    restore repository -> lint -> tests -> build -> verify -> publish
+
+The build reads two sibling datasets from the Hub rather than from a working
+copy. That is the point: what this dataset says about a company has to be
+derivable from what the others published, at a revision anyone can fetch.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+DEFAULT_REPO = "ZipLime/industry-classification"
+DEFAULT_WORKSPACE = "/tmp/industry-classification"
+
+
+def log(message: str) -> None:
+    print(f"[industry-classification] {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("--submission-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.submission_limit:
+        build += ["--submission-limit", str(args.submission_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,554 @@
+{
+  "config_rows": {
+    "by_ticker": 30729,
+    "classification": 22205,
+    "naics_map": 1854,
+    "observations": 435269,
+    "sic_codes": 444,
+    "spans": 23750,
+    "taxonomy": 90
+  },
+  "config_schemas": {
+    "by_ticker": {
+      "cik": "String",
+      "date_basis": "String",
+      "exchange": "String",
+      "industry": "String",
+      "industry_code": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_current": "Boolean",
+      "name": "String",
+      "sector": "String",
+      "sector_code": "String",
+      "sic": "String",
+      "ticker": "String",
+      "valid_from": "Date",
+      "valid_to": "Date"
+    },
+    "classification": {
+      "all_tickers": "String",
+      "cik": "String",
+      "division": "String",
+      "division_title": "String",
+      "exchange": "String",
+      "first_seen": "Date",
+      "industry": "String",
+      "industry_code": "String",
+      "industry_group": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_active": "Boolean",
+      "is_dated": "Boolean",
+      "major_group": "String",
+      "major_group_title": "String",
+      "naics_1997": "String",
+      "naics_candidates": "Int32",
+      "naics_sector": "String",
+      "naics_sector_title": "String",
+      "naics_title": "String",
+      "name": "String",
+      "observations": "Int32",
+      "primary_ticker": "String",
+      "sec_office": "String",
+      "sector": "String",
+      "sector_code": "String",
+      "sic": "String",
+      "sic_level": "String",
+      "sic_title": "String",
+      "source": "String",
+      "stated_on": "Date",
+      "taxonomy_version": "String"
+    },
+    "naics_map": {
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_part": "Boolean",
+      "naics_1997": "String",
+      "naics_sector": "String",
+      "naics_sector_title": "String",
+      "naics_title": "String",
+      "part_description": "String",
+      "sic": "String",
+      "sic_title": "String"
+    },
+    "observations": {
+      "cik": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_dated": "Boolean",
+      "knowledge_time": "Datetime(time_unit='us', time_zone='UTC')",
+      "sic": "String",
+      "source": "String",
+      "source_ref": "String",
+      "stated_on": "Date"
+    },
+    "sic_codes": {
+      "division": "String",
+      "division_title": "String",
+      "filers": "Int32",
+      "filings": "Int32",
+      "in_sic_1987": "Boolean",
+      "industry": "String",
+      "industry_code": "String",
+      "industry_group": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "major_group": "String",
+      "major_group_title": "String",
+      "naics_1997": "String",
+      "naics_candidates": "Int32",
+      "naics_sector": "String",
+      "naics_sector_title": "String",
+      "naics_title": "String",
+      "sec_office": "String",
+      "sector": "String",
+      "sector_code": "String",
+      "sic": "String",
+      "sic_level": "String",
+      "title": "String"
+    },
+    "spans": {
+      "cik": "String",
+      "industry": "String",
+      "industry_code": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_latest": "Boolean",
+      "observations": "Int32",
+      "rank_for_filer": "Int32",
+      "sector": "String",
+      "sector_code": "String",
+      "sic": "String",
+      "sources": "String",
+      "valid_from": "Date",
+      "valid_to": "Date"
+    },
+    "taxonomy": {
+      "edgar_codes": "Int32",
+      "industry": "String",
+      "industry_code": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "sector": "String",
+      "sector_code": "String",
+      "sic_ranges": "String",
+      "taxonomy_version": "String"
+    }
+  },
+  "configs": {
+    "by_ticker": {
+      "grain": "one ticker over one window, with the sector it was in then",
+      "path": "data/by_ticker/**/*.parquet"
+    },
+    "classification": {
+      "grain": "one SEC filer, with the sector and industry it is in now",
+      "path": "data/classification/**/*.parquet"
+    },
+    "naics_map": {
+      "grain": "one 1987 SIC to 1997 NAICS pair from the Census concordance",
+      "path": "data/naics_map/**/*.parquet"
+    },
+    "observations": {
+      "grain": "one dated statement that a filer was assigned a SIC code",
+      "path": "data/observations/**/*.parquet"
+    },
+    "sic_codes": {
+      "grain": "one EDGAR SIC code, with its hierarchy, sector and NAICS bridge",
+      "path": "data/sic_codes/**/*.parquet"
+    },
+    "spans": {
+      "grain": "one run of filings that all stated the same SIC code",
+      "path": "data/spans/**/*.parquet"
+    },
+    "taxonomy": {
+      "grain": "one industry of the ZipLime taxonomy and the SIC ranges it covers",
+      "path": "data/taxonomy/**/*.parquet"
+    }
+  },
+  "coverage": {
+    "max_statement": "2026-10-13",
+    "min_statement": "2009-04-15"
+  },
+  "generated_at": "2026-10-13T19:43:19.146667+00:00",
+  "industries": {
+    "CONC_AUTO": {
+      "sector": "CONC",
+      "title": "Automobiles"
+    },
+    "CONC_AUTOPART": {
+      "sector": "CONC",
+      "title": "Automobile Components"
+    },
+    "CONC_BROADLINE": {
+      "sector": "CONC",
+      "title": "Broadline Retail"
+    },
+    "CONC_CONSSVC": {
+      "sector": "CONC",
+      "title": "Consumer Services"
+    },
+    "CONC_DURABLES": {
+      "sector": "CONC",
+      "title": "Household Durables"
+    },
+    "CONC_ECOMM": {
+      "sector": "CONC",
+      "title": "Direct & Online Retail"
+    },
+    "CONC_EDUCATION": {
+      "sector": "CONC",
+      "title": "Education Services"
+    },
+    "CONC_HOMEBLD": {
+      "sector": "CONC",
+      "title": "Homebuilding"
+    },
+    "CONC_HOTEL": {
+      "sector": "CONC",
+      "title": "Hotels, Gaming & Leisure Facilities"
+    },
+    "CONC_LEISURE": {
+      "sector": "CONC",
+      "title": "Leisure Products"
+    },
+    "CONC_RESTAURANT": {
+      "sector": "CONC",
+      "title": "Restaurants"
+    },
+    "CONC_RETAIL": {
+      "sector": "CONC",
+      "title": "Specialty Retail"
+    },
+    "CONC_TEXTILE": {
+      "sector": "CONC",
+      "title": "Textiles, Apparel & Luxury Goods"
+    },
+    "COND_AGRI": {
+      "sector": "COND",
+      "title": "Agricultural Products"
+    },
+    "COND_BEV": {
+      "sector": "COND",
+      "title": "Beverages"
+    },
+    "COND_FOOD": {
+      "sector": "COND",
+      "title": "Food Products"
+    },
+    "COND_FOODDIST": {
+      "sector": "COND",
+      "title": "Food & Beverage Distribution"
+    },
+    "COND_FOODRETAIL": {
+      "sector": "COND",
+      "title": "Food & Drug Retail"
+    },
+    "COND_HOUSEHOLD": {
+      "sector": "COND",
+      "title": "Household & Personal Products"
+    },
+    "COND_TOBACCO": {
+      "sector": "COND",
+      "title": "Tobacco"
+    },
+    "ENER_COAL": {
+      "sector": "ENER",
+      "title": "Coal & Consumable Fuels"
+    },
+    "ENER_EP": {
+      "sector": "ENER",
+      "title": "Oil & Gas Exploration & Production"
+    },
+    "ENER_MIDSTREAM": {
+      "sector": "ENER",
+      "title": "Oil & Gas Storage & Transportation"
+    },
+    "ENER_REFINE": {
+      "sector": "ENER",
+      "title": "Oil & Gas Refining & Marketing"
+    },
+    "ENER_SERVICES": {
+      "sector": "ENER",
+      "title": "Oil & Gas Equipment & Services"
+    },
+    "FINS_BANK": {
+      "sector": "FINS",
+      "title": "Banks"
+    },
+    "FINS_CAPMKT": {
+      "sector": "FINS",
+      "title": "Capital Markets"
+    },
+    "FINS_CONSFIN": {
+      "sector": "FINS",
+      "title": "Consumer Finance"
+    },
+    "FINS_DIVFIN": {
+      "sector": "FINS",
+      "title": "Diversified Financial Services"
+    },
+    "FINS_INSURANCE": {
+      "sector": "FINS",
+      "title": "Insurance"
+    },
+    "FINS_MORTGAGE": {
+      "sector": "FINS",
+      "title": "Mortgage Finance"
+    },
+    "FINS_THRIFT": {
+      "sector": "FINS",
+      "title": "Thrifts & Savings Institutions"
+    },
+    "FUND_ABS": {
+      "sector": "FUND",
+      "title": "Asset-Backed Securities"
+    },
+    "FUND_INVEST": {
+      "sector": "FUND",
+      "title": "Investment Companies & Funds"
+    },
+    "FUND_TRUST": {
+      "sector": "FUND",
+      "title": "Trusts"
+    },
+    "GOVT_PUBLIC": {
+      "sector": "GOVT",
+      "title": "Public Administration"
+    },
+    "GOVT_SOVEREIGN": {
+      "sector": "GOVT",
+      "title": "Sovereign & Supranational"
+    },
+    "HLTH_BIOTECH": {
+      "sector": "HLTH",
+      "title": "Biotechnology"
+    },
+    "HLTH_DEVICE": {
+      "sector": "HLTH",
+      "title": "Health Care Equipment & Supplies"
+    },
+    "HLTH_DIST": {
+      "sector": "HLTH",
+      "title": "Health Care Distributors"
+    },
+    "HLTH_MANAGED": {
+      "sector": "HLTH",
+      "title": "Managed Health Care"
+    },
+    "HLTH_PHARMA": {
+      "sector": "HLTH",
+      "title": "Pharmaceuticals"
+    },
+    "HLTH_PROVIDER": {
+      "sector": "HLTH",
+      "title": "Health Care Providers & Services"
+    },
+    "HLTH_TOOLS": {
+      "sector": "HLTH",
+      "title": "Life Sciences Tools & Diagnostics"
+    },
+    "INDU_AERO": {
+      "sector": "INDU",
+      "title": "Aerospace & Defence"
+    },
+    "INDU_AIRLINE": {
+      "sector": "INDU",
+      "title": "Passenger Airlines"
+    },
+    "INDU_BLDGPROD": {
+      "sector": "INDU",
+      "title": "Building Products"
+    },
+    "INDU_COMMSVC": {
+      "sector": "INDU",
+      "title": "Commercial Services & Supplies"
+    },
+    "INDU_CONSTR": {
+      "sector": "INDU",
+      "title": "Construction & Engineering"
+    },
+    "INDU_DISTRIB": {
+      "sector": "INDU",
+      "title": "Trading Companies & Distributors"
+    },
+    "INDU_ELECEQ": {
+      "sector": "INDU",
+      "title": "Electrical Equipment"
+    },
+    "INDU_GROUND": {
+      "sector": "INDU",
+      "title": "Ground Transportation"
+    },
+    "INDU_LOGISTICS": {
+      "sector": "INDU",
+      "title": "Air Freight & Logistics"
+    },
+    "INDU_MACH": {
+      "sector": "INDU",
+      "title": "Machinery"
+    },
+    "INDU_MARINE": {
+      "sector": "INDU",
+      "title": "Marine Transportation"
+    },
+    "INDU_MISC": {
+      "sector": "INDU",
+      "title": "Diversified Industrial Products"
+    },
+    "INDU_PROFSVC": {
+      "sector": "INDU",
+      "title": "Professional Services"
+    },
+    "INDU_RAIL": {
+      "sector": "INDU",
+      "title": "Rail Transportation"
+    },
+    "INDU_WASTE": {
+      "sector": "INDU",
+      "title": "Waste Management"
+    },
+    "MATR_AGCHEM": {
+      "sector": "MATR",
+      "title": "Fertilizers & Agricultural Chemicals"
+    },
+    "MATR_BLDGMAT": {
+      "sector": "MATR",
+      "title": "Construction Materials"
+    },
+    "MATR_CHEM": {
+      "sector": "MATR",
+      "title": "Chemicals"
+    },
+    "MATR_CONTAIN": {
+      "sector": "MATR",
+      "title": "Containers & Packaging"
+    },
+    "MATR_FOREST": {
+      "sector": "MATR",
+      "title": "Paper & Forest Products"
+    },
+    "MATR_METALMIN": {
+      "sector": "MATR",
+      "title": "Metals & Mining"
+    },
+    "MATR_NONFERROUS": {
+      "sector": "MATR",
+      "title": "Aluminium & Nonferrous Metals"
+    },
+    "MATR_PRECIOUS": {
+      "sector": "MATR",
+      "title": "Gold & Precious Metals"
+    },
+    "MATR_RUBBER": {
+      "sector": "MATR",
+      "title": "Rubber & Plastic Products"
+    },
+    "MATR_STEEL": {
+      "sector": "MATR",
+      "title": "Steel"
+    },
+    "REAL_MGMT": {
+      "sector": "REAL",
+      "title": "Real Estate Management & Development"
+    },
+    "REAL_REIT": {
+      "sector": "REAL",
+      "title": "Real Estate Investment Trusts"
+    },
+    "SHEL_BLANK": {
+      "sector": "SHEL",
+      "title": "Blank Check & Shell Companies"
+    },
+    "SHEL_NONOP": {
+      "sector": "SHEL",
+      "title": "Non-Operating Establishments"
+    },
+    "TECH_COMMEQ": {
+      "sector": "TECH",
+      "title": "Communications Equipment"
+    },
+    "TECH_ELECTRONIC": {
+      "sector": "TECH",
+      "title": "Electronic Equipment & Components"
+    },
+    "TECH_HARDWARE": {
+      "sector": "TECH",
+      "title": "Technology Hardware & Equipment"
+    },
+    "TECH_INTERNET": {
+      "sector": "TECH",
+      "title": "Internet Software & Services"
+    },
+    "TECH_ITSVC": {
+      "sector": "TECH",
+      "title": "IT Services"
+    },
+    "TECH_SEMI": {
+      "sector": "TECH",
+      "title": "Semiconductors & Semiconductor Equipment"
+    },
+    "TECH_SOFTWARE": {
+      "sector": "TECH",
+      "title": "Software"
+    },
+    "TLCM_ADVERT": {
+      "sector": "TLCM",
+      "title": "Advertising & Marketing"
+    },
+    "TLCM_MEDIA": {
+      "sector": "TLCM",
+      "title": "Media & Entertainment"
+    },
+    "TLCM_PUBLISH": {
+      "sector": "TLCM",
+      "title": "Publishing"
+    },
+    "TLCM_TELECOM": {
+      "sector": "TLCM",
+      "title": "Telecommunication Services"
+    },
+    "UNCL_ADR": {
+      "sector": "UNCL",
+      "title": "Depositary Receipts"
+    },
+    "UNCL_OTHER": {
+      "sector": "UNCL",
+      "title": "Unclassified"
+    },
+    "UTIL_ELEC": {
+      "sector": "UTIL",
+      "title": "Electric Utilities"
+    },
+    "UTIL_GAS": {
+      "sector": "UTIL",
+      "title": "Gas Utilities"
+    },
+    "UTIL_MULTI": {
+      "sector": "UTIL",
+      "title": "Multi-Utilities"
+    },
+    "UTIL_WATER": {
+      "sector": "UTIL",
+      "title": "Water Utilities"
+    }
+  },
+  "quality_ok": true,
+  "rows": 22205,
+  "sectors": {
+    "CONC": "Consumer Cyclical",
+    "COND": "Consumer Defensive",
+    "ENER": "Energy",
+    "FINS": "Financials",
+    "FUND": "Funds & Trusts",
+    "GOVT": "Government",
+    "HLTH": "Health Care",
+    "INDU": "Industrials",
+    "MATR": "Materials",
+    "REAL": "Real Estate",
+    "SHEL": "Shell & Blank Check",
+    "TECH": "Technology",
+    "TLCM": "Telecom & Media",
+    "UNCL": "Unclassified",
+    "UTIL": "Utilities"
+  },
+  "source": {
+    "build_version": "1.0.0",
+    "package_version": "1.0.0",
+    "recipe_hash": "sha256:675e969a373cd6ec1fad32888bf6c51ecc4c536cd8164ec4106c5cec24cd989a",
+    "taxonomy_version": "1.0.0"
+  }
+}

pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=75", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ziplime-industry-classification"
+version = "1.0.0"
+description = "Free, point-in-time sector and industry classification for US SEC filers"
+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",
+  # Reads the Census concordance, which is a 2008-vintage .xls that only a
+  # BIFF-capable reader opens. polars delegates to it for read_excel.
+  "fastexcel>=0.12,<1",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8,<10",
+  "pytest-asyncio>=0.24,<2",
+  # Pinned exactly, not to a range: ruff gates publication, and a new minor
+  # release adding a rule would fail the scheduled job on code that was clean
+  # when it was written.
+  "ruff==0.16.5",
+]
+publish = ["huggingface-hub>=1.19,<2"]
+
+[project.scripts]
+ziplime-industry-classification = "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 industry classification: what business a listed company is in, on a date."""
+
+__version__ = "1.0.0"

recipe/build.py

@@ -0,0 +1,484 @@
+"""Collect the dated codes, derive the tables, write them out."""
+
+from __future__ import annotations
+
+import logging
+import shutil
+from collections import defaultdict
+from datetime import UTC, datetime
+from pathlib import Path
+
+import polars as pl
+
+from .config import Settings
+from .naics import sector_of
+from .schema import CONFIG_SCHEMAS, align, empty_frame
+from .sic import code_level, division_of, industry_group, major_group, prefix_of
+from .sources import (
+    edgar_sic_list,
+    fetch_concordance,
+    from_fundamental_filings,
+    issuers,
+    parse_concordance,
+    submissions_snapshot,
+    ticker_spans,
+)
+from .store import atomic_write_parquet
+from .taxonomy import (
+    INDUSTRIES,
+    RULES,
+    SECTORS,
+    TAXONOMY_VERSION,
+    UNCLASSIFIED,
+    classify,
+    classify_entity,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+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
+
+
+# ------------------------------------------------------------------ spans
+
+
+def build_spans(observations: pl.DataFrame) -> pl.DataFrame:
+    """Collapse consecutive statements of the same code into one run.
+
+    A run, not a groupby on (filer, code): a company that was a blank check,
+    became a car maker and was reclassified back has three spans, and
+    flattening them to two would erase the order the SEC saw it in.
+    """
+    if observations.is_empty():
+        return empty_frame(CONFIG_SCHEMAS["spans"])
+
+    ordered = observations.sort(["cik", "stated_on", "knowledge_time", "source_ref"])
+    ordered = ordered.with_columns(
+        (
+            (pl.col("sic") != pl.col("sic").shift(1).over("cik"))
+            | pl.col("cik").ne(pl.col("cik").shift(1)).fill_null(True)
+        )
+        .fill_null(True)
+        .alias("starts_run")
+    ).with_columns(pl.col("starts_run").cum_sum().alias("run"))
+
+    spans = (
+        ordered.group_by(["cik", "run"])
+        .agg(
+            pl.col("sic").first().alias("sic"),
+            pl.col("stated_on").min().alias("valid_from"),
+            pl.col("stated_on").max().alias("valid_to"),
+            pl.len().cast(pl.Int32).alias("observations"),
+            pl.col("source").unique().sort().alias("source_list"),
+        )
+        .with_columns(pl.col("source_list").list.join(",").alias("sources"))
+        .drop("source_list", "run")
+        .sort(["cik", "valid_from", "valid_to"])
+    )
+    spans = spans.with_columns(
+        (pl.len().over("cik") - pl.col("sic").cum_count().over("cik") + 1)
+        .cast(pl.Int32)
+        .alias("rank_for_filer")
+    ).with_columns((pl.col("rank_for_filer") == 1).alias("is_latest"))
+
+    assignments = _assign(spans["sic"])
+    now = datetime.now(UTC)
+    return spans.with_columns(
+        *assignments, pl.lit(now).alias("inserted_at")
+    )
+
+
+def _assign(codes: pl.Series) -> list[pl.Series]:
+    """Sector and industry columns for a column of SIC codes."""
+    cache: dict[str | None, tuple[str, str, str, str]] = {}
+    sector_code, sector, industry_code, industry = [], [], [], []
+    for code in codes.to_list():
+        if code not in cache:
+            found = classify(code)
+            cache[code] = (found.sector_code, found.sector, found.industry_code, found.industry)
+        values = cache[code]
+        sector_code.append(values[0])
+        sector.append(values[1])
+        industry_code.append(values[2])
+        industry.append(values[3])
+    return [
+        pl.Series("sector_code", sector_code, dtype=pl.String),
+        pl.Series("sector", sector, dtype=pl.String),
+        pl.Series("industry_code", industry_code, dtype=pl.String),
+        pl.Series("industry", industry, dtype=pl.String),
+    ]
+
+
+# -------------------------------------------------------------- reference
+
+
+def build_naics_lookup(crosswalk: pl.DataFrame) -> dict[str, dict]:
+    """For every EDGAR code, what the Census crosswalk can say about it.
+
+    A roll-up stands for all the 1987 industries beneath it, so `2000` is
+    resolved by taking every 20xx row in the crosswalk at once. The answer is
+    filled in only where it is unique: one NAICS industry for `naics_1997`,
+    one NAICS sector for `naics_sector`, and the candidate count either way so
+    a reader can see how much was thrown away.
+    """
+    by_prefix: dict[str, list[tuple[str, str | None]]] = defaultdict(list)
+    for row in crosswalk.iter_rows(named=True):
+        sic, naics = row["sic"], row["naics_1997"]
+        if not sic or not naics:
+            continue
+        for width in (2, 3, 4):
+            by_prefix[sic[:width]].append((naics, row["naics_title"]))
+    return {prefix: _resolve(pairs) for prefix, pairs in by_prefix.items()}
+
+
+def _resolve(pairs: list[tuple[str, str | None]]) -> dict:
+    codes = {code for code, _ in pairs}
+    sectors = {sector_of(code)[0] for code in codes} - {None}
+    one_code = next(iter(codes)) if len(codes) == 1 else None
+    title = None
+    if one_code:
+        title = next((name for code, name in pairs if code == one_code), None)
+    sector = next(iter(sectors)) if len(sectors) == 1 else None
+    return {
+        "naics_1997": one_code,
+        "naics_title": title,
+        "naics_sector": sector,
+        "naics_sector_title": sector_of(sector or "")[1] if sector else None,
+        "naics_candidates": len(codes),
+    }
+
+
+def build_sic_codes(
+    edgar: pl.DataFrame,
+    *,
+    naics_lookup: dict[str, dict],
+    major_groups: dict[str, str],
+    usage: pl.DataFrame,
+) -> pl.DataFrame:
+    """EDGAR's code list with everything derivable from a code hung off it."""
+    now = datetime.now(UTC)
+    rows: list[dict] = []
+    for row in edgar.iter_rows(named=True):
+        code = row["sic"]
+        found = classify(code)
+        division = division_of(code)
+        group = major_group(code)
+        resolved = naics_lookup.get(prefix_of(code), {})
+        rows.append({
+            "sic": code,
+            "title": row["title"],
+            "sec_office": row["sec_office"],
+            "sic_level": code_level(code),
+            "in_sic_1997_placeholder": None,
+            "division": division.letter if division else None,
+            "division_title": division.title if division else None,
+            "major_group": group,
+            "major_group_title": major_groups.get(group),
+            "industry_group": industry_group(code),
+            "sector_code": found.sector_code,
+            "sector": found.sector,
+            "industry_code": found.industry_code,
+            "industry": found.industry,
+            "naics_1997": resolved.get("naics_1997"),
+            "naics_title": resolved.get("naics_title"),
+            "naics_sector": resolved.get("naics_sector"),
+            "naics_sector_title": resolved.get("naics_sector_title"),
+            "naics_candidates": resolved.get("naics_candidates", 0),
+            "inserted_at": now,
+        })
+    frame = pl.DataFrame(rows).drop("in_sic_1997_placeholder")
+    # A code is a real 1987 industry when the crosswalk knows it by its own
+    # four digits, not by the prefix a roll-up was expanded through.
+    real = set(naics_lookup) & {code for code in frame["sic"] if len(code) == 4}
+    frame = frame.with_columns(
+        pl.col("sic")
+        .map_elements(lambda code: code in real and code_level(code) == "industry",
+                      return_dtype=pl.Boolean)
+        .alias("in_sic_1987")
+    )
+    return frame.join(usage, on="sic", how="left").with_columns(
+        pl.col("filers").fill_null(0).cast(pl.Int32),
+        pl.col("filings").fill_null(0).cast(pl.Int32),
+    )
+
+
+def build_taxonomy_table() -> pl.DataFrame:
+    """The taxonomy itself, so it can be read without reading Python."""
+    ranges: dict[str, list[str]] = defaultdict(list)
+    for low, high, industry_code in RULES:
+        ranges[industry_code].append(f"{low:04d}" if low == high else f"{low:04d}-{high:04d}")
+    now = datetime.now(UTC)
+    rows = [
+        {
+            "sector_code": sector_code,
+            "sector": SECTORS[sector_code],
+            "industry_code": industry_code,
+            "industry": industry,
+            "sic_ranges": " ".join(ranges.get(industry_code, [])) or None,
+            "taxonomy_version": TAXONOMY_VERSION,
+            "inserted_at": now,
+        }
+        for industry_code, (sector_code, industry) in INDUSTRIES.items()
+    ]
+    order = list(SECTORS)
+    return pl.DataFrame(rows).sort(
+        pl.col("sector_code").replace_strict(order, range(len(order)), default=len(order)),
+        "industry_code",
+    )
+
+
+# --------------------------------------------------------- the two answers
+
+
+def entity_fallback(kinds: pl.DataFrame) -> pl.DataFrame:
+    """Entity kinds resolved to sector and industry, for filers with no code."""
+    columns = {
+        "cik": pl.String, "sector_code": pl.String, "sector": pl.String,
+        "industry_code": pl.String, "industry": pl.String,
+    }
+    if kinds.is_empty():
+        return pl.DataFrame(schema=columns)
+    rows = []
+    for row in kinds.iter_rows(named=True):
+        found = classify_entity(row["entity_kind"])
+        if found:
+            rows.append({
+                "cik": row["cik"], "sector_code": found.sector_code, "sector": found.sector,
+                "industry_code": found.industry_code, "industry": found.industry,
+            })
+    return pl.DataFrame(rows, schema=columns) if rows else pl.DataFrame(schema=columns)
+
+
+def build_classification(
+    spans: pl.DataFrame,
+    directory: pl.DataFrame,
+    reference: pl.DataFrame,
+    fallback: pl.DataFrame,
+) -> pl.DataFrame:
+    """One row per filer: the newest code it has been seen under, resolved.
+
+    Filers with no code at all are still here when EDGAR's forms say what kind
+    of entity they are -- with `sic` null and `source` naming the forms, so
+    nothing passes a derived label off as an assigned one.
+    """
+    if spans.is_empty():
+        return empty_frame(CONFIG_SCHEMAS["classification"])
+    latest = spans.filter(pl.col("is_latest")).select(
+        "cik", "sic", "observations", "sources",
+        pl.col("valid_to").alias("stated_on"),
+    )
+    reference_columns = [
+        "sic", "title", "sic_level", "sec_office", "division", "division_title",
+        "major_group", "major_group_title", "industry_group", "sector_code", "sector",
+        "industry_code", "industry", "naics_1997", "naics_title", "naics_sector",
+        "naics_sector_title", "naics_candidates",
+    ]
+    frame = (
+        latest.join(directory, on="cik", how="left")
+        .join(reference.select(reference_columns), on="sic", how="left")
+        .rename({"title": "sic_title", "sources": "source"})
+    )
+    # A filer whose only code came from the snapshot has no history behind it.
+    frame = frame.with_columns(
+        (~pl.col("source").str.contains("submissions")).alias("is_dated"),
+    )
+    extra = fallback.join(frame.select("cik"), on="cik", how="anti")
+    if not extra.is_empty():
+        extra = extra.join(directory, on="cik", how="left").with_columns(
+            pl.lit("edgar_forms").alias("source"),
+            pl.lit(False).alias("is_dated"),
+            pl.lit(0, dtype=pl.Int32).alias("observations"),
+        )
+        frame = pl.concat([frame, extra], how="diagonal_relaxed")
+    return frame.with_columns(
+        pl.lit(TAXONOMY_VERSION).alias("taxonomy_version"),
+        pl.lit(datetime.now(UTC)).alias("inserted_at"),
+    ).sort("cik")
+
+
+def build_by_ticker(
+    tickers: pl.DataFrame,
+    spans: pl.DataFrame,
+    directory: pl.DataFrame,
+    fallback: pl.DataFrame | None = None,
+) -> pl.DataFrame:
+    """The classification keyed the way a strategy asks for it.
+
+    A ticker span and a code span are two intervals over the same filer, and
+    the useful row is their overlap: `AAPL` was Apple's symbol from here to
+    here, and over that window the SEC had Apple under 3571.
+
+    Where the two never overlap the ticker still gets a row, marked `undated`,
+    carrying the filer's latest code across the whole window. That covers the
+    delisted-before-2009 case -- Form 4 proves the symbol in 2007 and the only
+    code EDGAR holds is today's -- and also the one where both exist but miss
+    each other, which happens when a symbol appears in a single late filing.
+    Dropping those would quietly shrink the universe to the survivors, which
+    is the exact bias the rest of this family exists to avoid.
+
+    A ticker whose filer has no code at all still gets a row too, marked
+    `unknown` and unclassified. A symbol absent from the table and a symbol
+    the SEC never classified look identical to a consumer, and only one of
+    them is a bug -- so the table carries every ticker and says which it is.
+
+    `is_current` marks the single row in force today: the filer's symbol now,
+    under the newest code it has been seen under. Filtering on it gives one
+    row per live ticker, which is the question almost everyone is asking.
+    """
+    if tickers.is_empty() or spans.is_empty():
+        return empty_frame(CONFIG_SCHEMAS["by_ticker"])
+
+    labelled = spans.select(
+        "cik", "sic", "sector_code", "sector", "industry_code", "industry",
+        pl.col("valid_from").alias("span_from"), pl.col("valid_to").alias("span_to"),
+        "is_latest",
+    )
+    joined = tickers.join(labelled, on="cik", how="left")
+    overlapping = (
+        joined.filter(pl.col("sic").is_not_null())
+        .with_columns(
+            pl.max_horizontal("valid_from", "span_from").alias("overlap_from"),
+            pl.min_horizontal("valid_to", "span_to").alias("overlap_to"),
+        )
+        .filter(pl.col("overlap_from") <= pl.col("overlap_to"))
+        .with_columns(
+            pl.col("overlap_from").alias("valid_from"),
+            pl.col("overlap_to").alias("valid_to"),
+            pl.lit("dated").alias("date_basis"),
+        )
+        .drop("overlap_from", "overlap_to")
+    )
+
+    key = ["cik", "ticker"]
+    resolved = overlapping.select(key).unique()
+    remainder = (
+        tickers.join(resolved, on=key, how="anti")
+        .join(labelled.filter(pl.col("is_latest")).drop("span_from", "span_to"),
+              on="cik", how="left")
+        .with_columns(
+            pl.when(pl.col("sic").is_null())
+            .then(pl.lit("unknown"))
+            .otherwise(pl.lit("undated"))
+            .alias("date_basis"),
+            pl.lit(True).alias("is_latest"),
+        )
+    )
+    if fallback is not None and not fallback.is_empty():
+        remainder = remainder.join(fallback, on="cik", how="left", suffix="_kind")
+        for column in ("sector_code", "sector", "industry_code", "industry"):
+            remainder = remainder.with_columns(
+                pl.coalesce(pl.col(column), pl.col(f"{column}_kind")).alias(column)
+            ).drop(f"{column}_kind")
+    remainder = remainder.with_columns(
+        pl.col("sector_code").fill_null(UNCLASSIFIED.sector_code),
+        pl.col("sector").fill_null(UNCLASSIFIED.sector),
+        pl.col("industry_code").fill_null(UNCLASSIFIED.industry_code),
+        pl.col("industry").fill_null(UNCLASSIFIED.industry),
+    )
+
+    columns = [
+        "ticker", "cik", "valid_from", "valid_to", "sic", "sector_code", "sector",
+        "industry_code", "industry", "date_basis", "is_current", "is_latest",
+    ]
+    frame = pl.concat(
+        [overlapping.select(columns), remainder.select(columns)], how="vertical_relaxed"
+    )
+    # `is_current` on the way in means "this is the filer's symbol now". On the
+    # way out it means "this row is the one in force now", which also requires
+    # the code to be the newest one -- otherwise a live ticker whose company
+    # was reclassified would come back current under both its old sector and
+    # its new one.
+    frame = frame.with_columns(
+        (pl.col("is_current").fill_null(False) & pl.col("is_latest")).alias("is_current")
+    ).drop("is_latest")
+    return (
+        frame.join(directory.select("cik", "name", "exchange"), on="cik", how="left")
+        .with_columns(pl.lit(datetime.now(UTC)).alias("inserted_at"))
+        .sort(["ticker", "valid_from", "cik"])
+    )
+
+
+# ------------------------------------------------------------------ build
+
+
+async def run_build(
+    *, settings: Settings, token: str | None = None, submission_limit: int | None = None
+) -> dict[str, int]:
+    from .sec_client import SECClient
+
+    data_dir = Path(settings.data_dir)
+    dated = from_fundamental_filings(settings, token=token)
+    tickers = ticker_spans(settings, token=token)
+    directory = issuers(settings, token=token)
+
+    # The filers that have had a ticker but never filed XBRL: delisted before
+    # 2009, a fund, a foreign issuer on paper. Their code exists only in
+    # EDGAR's own record, and without them the universe is the survivors.
+    seen = set(dated["cik"].unique().to_list())
+    gap = sorted(set(tickers["cik"].unique().to_list()) - seen)
+    LOGGER.info("filers with a ticker and no XBRL filing: %d", len(gap))
+
+    async with SECClient(
+        user_agent=settings.sec_user_agent,
+        cache_dir=settings.cache_dir,
+        requests_per_second=settings.requests_per_second,
+    ) as client:
+        edgar = await edgar_sic_list(client)
+        snapshot, kinds = await submissions_snapshot(client, gap, limit=submission_limit)
+        concordance_bytes = await fetch_concordance(settings.cache_dir)
+
+    crosswalk, major_groups, divisions = parse_concordance(concordance_bytes)
+    LOGGER.info("divisions in the concordance: %d", len(divisions))
+
+    observations = pl.concat([dated, snapshot], how="vertical_relaxed")
+    LOGGER.info(
+        "observations: %d over %d filers", observations.height, observations["cik"].n_unique()
+    )
+
+    spans = build_spans(observations)
+    usage = observations.group_by("sic").agg(
+        pl.col("cik").n_unique().cast(pl.Int32).alias("filers"),
+        pl.len().cast(pl.Int32).alias("filings"),
+    )
+    naics_lookup = build_naics_lookup(crosswalk)
+    reference = build_sic_codes(
+        edgar, naics_lookup=naics_lookup, major_groups=major_groups, usage=usage
+    )
+    fallback = entity_fallback(kinds)
+    LOGGER.info("filers classified from their forms alone: %d", fallback.height)
+    classification = build_classification(spans, directory, reference, fallback)
+    by_ticker = build_by_ticker(tickers, spans, directory, fallback)
+    taxonomy = build_taxonomy_table()
+    taxonomy = taxonomy.join(
+        reference.group_by("industry_code").agg(pl.len().cast(pl.Int32).alias("edgar_codes")),
+        on="industry_code",
+        how="left",
+    ).with_columns(pl.col("edgar_codes").fill_null(0).cast(pl.Int32))
+
+    counts = {
+        "classification": _write(data_dir, "classification", classification),
+        "by_ticker": _write(data_dir, "by_ticker", by_ticker),
+        "spans": _write(data_dir, "spans", spans),
+        "observations": _write(data_dir, "observations", observations),
+        "sic_codes": _write(data_dir, "sic_codes", reference),
+        "naics_map": _write(data_dir, "naics_map", crosswalk),
+        "taxonomy": _write(data_dir, "taxonomy", taxonomy),
+    }
+    LOGGER.info("built %s at %s", counts, datetime.now(UTC).isoformat(timespec="seconds"))
+    return counts

recipe/cli.py

@@ -0,0 +1,81 @@
+"""Command line for the industry classification 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="industry-classification", description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    build = sub.add_parser("build", help="collect the codes and write every table")
+    build.add_argument(
+        "--submission-limit",
+        type=int,
+        default=None,
+        help="resolve at most N filers from the submissions archive (for quick runs)",
+    )
+
+    sub.add_parser("verify", help="run the quality gate and write the manifest")
+
+    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, submission_limit=args.submission_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 industry-classification/1.0 algo@limex.com"
+DEFAULT_HF_REPO = "ZipLime/industry-classification"
+
+# The sibling datasets this one is assembled from. Like the security master,
+# this dataset is mostly glue: the SIC code attached to a filer was stated by
+# the SEC on a filing that `company-fundamentals` already parsed, and the
+# ticker it hangs off was derived by `security-master` from Form 4 headers.
+SOURCE_REPOS = {
+    "fundamentals": "ZipLime/company-fundamentals",
+    "security_master": "ZipLime/security-master",
+}
+
+# Where a local checkout of a sibling lives, for iterating without downloading
+# anything. `INDUSTRY_SIBLINGS=/path/to/hf` makes the build read
+# `/path/to/hf/Company_fundamentals/data` instead of the Hub.
+SIBLING_DIRS = {
+    "fundamentals": "Company_fundamentals",
+    "security_master": "Security_master",
+}
+
+@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("INDUSTRY_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,229 @@
+"""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 two sibling tables -- twenty megabytes -- and about six
+# thousand small EDGAR lookups for the filers those tables do not cover. The
+# grouping that follows is seconds on half a million rows. Memory is modest
+# and so is bandwidth; the wall clock is the rate limiter, not the CPU.
+# The flavour also lives in the scheduled job on the Hub, which is what
+# actually decides the hardware -- changing it here alone changes nothing.
+UPDATE_FLAVOR = "cpu-basic"
+BACKFILL_FLAVOR = "cpu-basic"
+UPDATE_TIMEOUT = "2h"
+BACKFILL_TIMEOUT = "3h"
+# Monday 09:40 UTC, two hours after company-fundamentals and security-master.
+# This dataset is derived from both, and running before them would publish a
+# classification that lags its own sources by a week. The :40 slot is clear;
+# 08:10, 08:40 and 09:10 belong to other members of the family.
+DEFAULT_SCHEDULE = "40 9 * * 1"
+JOB_SCRIPT = "jobs/run.py"
+UPDATE_JOB_NAME = "industry-classification-update"
+BACKFILL_JOB_NAME = "industry-classification-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": "industry-classification"},
+        }
+
+
+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",
+    flavor: str = BACKFILL_FLAVOR,
+    timeout: str = BACKFILL_TIMEOUT,
+) -> JobSpec:
+    args = ["--mode", "build"]
+    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/manifest.py

@@ -0,0 +1,137 @@
+"""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 .schema import BUILD_VERSION, CONFIG_SCHEMAS
+from .store import read_table
+from .taxonomy import INDUSTRIES, SECTORS, TAXONOMY_VERSION
+
+RECIPE_ROOT = Path(__file__).resolve().parent.parent
+
+CONFIG_DESCRIPTIONS: dict[str, dict[str, str]] = {
+    "classification": {
+        "path": "data/classification/**/*.parquet",
+        "grain": "one SEC filer, with the sector and industry it is in now",
+    },
+    "by_ticker": {
+        "path": "data/by_ticker/**/*.parquet",
+        "grain": "one ticker over one window, with the sector it was in then",
+    },
+    "spans": {
+        "path": "data/spans/**/*.parquet",
+        "grain": "one run of filings that all stated the same SIC code",
+    },
+    "observations": {
+        "path": "data/observations/**/*.parquet",
+        "grain": "one dated statement that a filer was assigned a SIC code",
+    },
+    "sic_codes": {
+        "path": "data/sic_codes/**/*.parquet",
+        "grain": "one EDGAR SIC code, with its hierarchy, sector and NAICS bridge",
+    },
+    "naics_map": {
+        "path": "data/naics_map/**/*.parquet",
+        "grain": "one 1987 SIC to 1997 NAICS pair from the Census concordance",
+    },
+    "taxonomy": {
+        "path": "data/taxonomy/**/*.parquet",
+        "grain": "one industry of the ZipLime taxonomy and the SIC ranges it covers",
+    },
+}
+
+
+def recipe_hash(project_root: Path | None = None) -> str:
+    """Hash of the code that produced a build.
+
+    The taxonomy is part of the recipe rather than part of the data, so this
+    hash is what tells two revisions of the dataset apart when the sources did
+    not move but an industry was reassigned.
+    """
+    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("stated_on").min().alias("min_statement"),
+            pl.col("stated_on").max().alias("max_statement"),
+        )
+        .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("classification", 0)
+    manifest["config_rows"] = row_counts
+    manifest["configs"] = CONFIG_DESCRIPTIONS
+    manifest["coverage"] = _coverage(data_dir)
+    manifest["quality_ok"] = quality_ok
+    manifest["sectors"] = dict(SECTORS)
+    manifest["industries"] = {
+        code: {"sector": sector, "title": title}
+        for code, (sector, title) in INDUSTRIES.items()
+    }
+    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["taxonomy_version"] = TAXONOMY_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/naics.py

@@ -0,0 +1,61 @@
+"""The 1997 NAICS sectors, and what the crosswalk to them can and cannot say.
+
+The Census Bureau publishes a concordance from 1987 SIC to 1997 NAICS, which
+is the only free, official bridge between the classification the SEC still
+assigns and the one the rest of the US statistical system moved to in 1997.
+
+It is a weak bridge and the numbers say so. Measured over the filings in this
+corpus: 36% land on exactly one NAICS industry, 70% on exactly one NAICS
+sector, and 5% on nothing at all. The rest are one-to-many -- a 1987 industry
+that 1997 split in two, marked `pt` for "part" in the source file.
+
+So NAICS is published here as a crosswalk, not as an answer. `naics_1997` is
+filled only where a code resolves to exactly one industry, `naics_sector` only
+where it resolves to exactly one sector, and `naics_candidates` says how many
+there were. A single NAICS per company, picked by a tie-break, would read as
+fact and be a coin toss.
+"""
+
+from __future__ import annotations
+
+# 1997 NAICS sectors. Manufacturing, retail and transportation each span
+# several two-digit prefixes, which is why this is a map rather than a slice.
+NAICS_SECTORS: dict[str, str] = {
+    "11": "Agriculture, Forestry, Fishing and Hunting",
+    "21": "Mining",
+    "22": "Utilities",
+    "23": "Construction",
+    "31": "Manufacturing",
+    "32": "Manufacturing",
+    "33": "Manufacturing",
+    "42": "Wholesale Trade",
+    "44": "Retail Trade",
+    "45": "Retail Trade",
+    "48": "Transportation and Warehousing",
+    "49": "Transportation and Warehousing",
+    "51": "Information",
+    "52": "Finance and Insurance",
+    "53": "Real Estate and Rental and Leasing",
+    "54": "Professional, Scientific, and Technical Services",
+    "55": "Management of Companies and Enterprises",
+    "56": "Administrative and Support and Waste Management and Remediation Services",
+    "61": "Educational Services",
+    "62": "Health Care and Social Assistance",
+    "71": "Arts, Entertainment, and Recreation",
+    "72": "Accommodation and Food Services",
+    "81": "Other Services (except Public Administration)",
+    "92": "Public Administration",
+    "99": "Unclassified",
+}
+
+
+def sector_of(naics: str | None) -> tuple[str | None, str | None]:
+    """The sector a NAICS code belongs to, as (code, title)."""
+    if not naics or len(naics) < 2:
+        return None, None
+    prefix = naics[:2]
+    title = NAICS_SECTORS.get(prefix)
+    return (prefix, title) if title else (None, None)
+
+
+__all__ = ["NAICS_SECTORS", "sector_of"]

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 / "classification").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="industry-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 industry classification",
+    )
+    # 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,300 @@
+"""Checks that decide whether a build may be published.
+
+A classification dataset fails quietly. Nothing raises when a bank is labelled
+a materials company: the backtest runs, the sector-neutral hedge is placed
+against the wrong basket, and the result looks plausible. So the checks here
+are about the shape of the answer rather than its plumbing.
+
+Two of them earn their place:
+
+* how much of the live universe is unclassified. The SEC adds codes -- asset
+  backed securities and crypto assets both arrived after the 1987 manual --
+  and nothing else in the pipeline would notice that a new one fell through
+  the taxonomy into the catch-all.
+* how much of it lands in the single largest sector. The reason this dataset
+  exists is that the SIC divisions are unusable for investing, Manufacturing
+  alone being a third of the listed universe. A regression that collapsed the
+  taxonomy back towards its input would show up here and nowhere else.
+
+The floors are set below measured values so a regression fails and noise does
+not. All of them were set after measuring.
+"""
+
+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
+from .taxonomy import INDUSTRIES, RULES, SECTORS
+
+MIN_CLASSIFIED_FILERS = 20_000
+MIN_EDGAR_CODES = 400
+# Share of current tickers the dataset says something positive about. A
+# closed-end fund and a depositary receipt programme count: "this is a fund"
+# is an answer, and the point of the measure is to catch symbols the dataset
+# knows nothing whatsoever about.
+MIN_CURRENT_TICKER_COVERAGE = 0.95
+# Share of the live universe the dataset can say nothing at all about --
+# `UNCL_OTHER`, not `UNCL_ADR`, because "this is a depositary receipt
+# programme" is an answer. Measured at zero; the ceiling is for regressions.
+MAX_UNCLASSIFIED = 0.02
+# Symbols current for two filers that disagree about the sector. Measured at
+# 30, and every one checked was real: a ticker genuinely transferred (Barnes
+# Group to Barrick), a symbol reused after a delisting, or a fund whose Form 4
+# ticker box holds a share class. A lot more would mean the security master is
+# stitching histories to the wrong companies, which this would notice first.
+MAX_CONTRADICTORY_TICKERS = 40
+# Share of the live universe in the single largest sector. The SIC division
+# this replaces puts a third of the universe in Manufacturing.
+MAX_LARGEST_SECTOR = 0.30
+
+
+@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 check_taxonomy(report: QualityReport) -> None:
+    """The taxonomy is code, so it is checked like code.
+
+    Every rule has to name an industry that exists and every industry a sector
+    that exists, or the build writes nulls into the column the whole dataset
+    is for.
+    """
+    unknown_industries = {code for _, _, code in RULES if code not in INDUSTRIES}
+    if unknown_industries:
+        report.error(f"RULES name industries that do not exist: {sorted(unknown_industries)}")
+    unknown_sectors = {
+        sector for sector, _ in INDUSTRIES.values() if sector not in SECTORS
+    }
+    if unknown_sectors:
+        report.error(f"INDUSTRIES name sectors that do not exist: {sorted(unknown_sectors)}")
+    inverted = [(low, high) for low, high, _ in RULES if low > high]
+    if inverted:
+        report.error(f"RULES has {len(inverted)} inverted ranges, e.g. {inverted[:3]}")
+    report.metric("taxonomy_sectors", len(SECTORS))
+    report.metric("taxonomy_industries", len(INDUSTRIES))
+    report.metric("taxonomy_rules", len(RULES))
+
+
+def validate(data_dir: Path) -> QualityReport:
+    report = QualityReport()
+    data_dir = Path(data_dir)
+    check_taxonomy(report)
+
+    tables = {
+        name: read_table(data_dir, name).collect()
+        for name in ("classification", "by_ticker", "spans", "observations", "sic_codes",
+                     "naics_map", "taxonomy")
+    }
+    for name, frame in tables.items():
+        report.metric(f"rows_{name}", frame.height)
+
+    classification = tables["classification"]
+    if classification.is_empty():
+        report.error("classification is empty")
+        return report
+    if classification.height < MIN_CLASSIFIED_FILERS:
+        report.error(
+            f"only {classification.height} filers classified, "
+            f"below the {MIN_CLASSIFIED_FILERS} floor"
+        )
+    if classification["cik"].n_unique() != classification.height:
+        report.error("classification: duplicate CIKs")
+    for column in ("sector_code", "industry_code"):
+        nulls = classification[column].null_count()
+        if nulls:
+            report.error(f"classification.{column}: {nulls} nulls")
+    # A null code is legitimate exactly where the sector came from the forms a
+    # filer files rather than from a code the SEC assigned. Anywhere else it
+    # means a row lost its join.
+    assigned = classification.filter(pl.col("source") != "edgar_forms")
+    orphans = assigned.filter(pl.col("sic").is_null()).height
+    if orphans:
+        report.error(f"classification: {orphans} rows have no SIC and no reason to lack one")
+    derived = classification.height - assigned.height
+    report.metric("classified_from_forms", derived)
+
+    observations = tables["observations"]
+    for column in ("cik", "sic", "stated_on", "source"):
+        nulls = observations[column].null_count()
+        if nulls:
+            report.error(f"observations.{column}: {nulls} nulls")
+    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
+            )
+        },
+    )
+    bounds = observations.select(
+        pl.col("stated_on").min().alias("first"), pl.col("stated_on").max().alias("last")
+    ).row(0)
+    report.metric("coverage_first_statement", str(bounds[0]))
+    report.metric("coverage_last_statement", str(bounds[1]))
+
+    spans = tables["spans"]
+    reversed_spans = spans.filter(pl.col("valid_to") < pl.col("valid_from")).height
+    if reversed_spans:
+        report.error(f"spans: {reversed_spans} spans end before they start")
+    changed = spans.group_by("cik").agg(pl.len().alias("n")).filter(pl.col("n") > 1).height
+    report.metric("filers_reclassified", changed)
+
+    reference = tables["sic_codes"]
+    if reference.height < MIN_EDGAR_CODES:
+        report.error(
+            f"only {reference.height} EDGAR codes, below the {MIN_EDGAR_CODES} floor"
+        )
+    missing_titles = reference.filter(
+        pl.col("title").is_null() | (pl.col("title").str.strip_chars() == "")
+    ).height
+    if missing_titles:
+        report.error(f"sic_codes: {missing_titles} codes with no title")
+    missing_groups = reference.filter(pl.col("major_group_title").is_null()).height
+    if missing_groups:
+        report.warn(f"sic_codes: {missing_groups} codes with no major group title")
+    report.metric(
+        "sic_codes_by_level",
+        {
+            row["sic_level"]: row["n"]
+            for row in reference.group_by("sic_level").agg(pl.len().alias("n")).iter_rows(
+                named=True
+            )
+        },
+    )
+    report.metric(
+        "naics_unique_industry",
+        round(reference.filter(pl.col("naics_1997").is_not_null()).height / reference.height, 4),
+    )
+    report.metric(
+        "naics_unique_sector",
+        round(
+            reference.filter(pl.col("naics_sector").is_not_null()).height / reference.height, 4
+        ),
+    )
+
+    # The live universe: filers that still file and still have a symbol. The
+    # shape checks are about this set, not about every shell that ever filed.
+    live = classification.filter(
+        pl.col("is_active").fill_null(False) & pl.col("primary_ticker").is_not_null()
+    )
+    report.metric("live_filers", live.height)
+    if not live.is_empty():
+        shares = (
+            live.group_by("sector_code")
+            .agg(pl.len().alias("n"))
+            .with_columns((pl.col("n") / live.height).alias("share"))
+            .sort("share", descending=True)
+        )
+        report.metric(
+            "live_sector_share",
+            {row["sector_code"]: round(row["share"], 4) for row in shares.iter_rows(named=True)},
+        )
+        unclassified = live.filter(pl.col("industry_code") == "UNCL_OTHER").height / live.height
+        report.metric("live_unclassified_share", round(unclassified, 4))
+        report.metric(
+            "live_depositary_receipt_share",
+            round(live.filter(pl.col("industry_code") == "UNCL_ADR").height / live.height, 4),
+        )
+        if unclassified > MAX_UNCLASSIFIED:
+            report.error(
+                f"{unclassified:.1%} of the live universe is unclassified, above the "
+                f"{MAX_UNCLASSIFIED:.0%} ceiling — the SEC has probably added a code"
+            )
+        largest = shares.row(0, named=True)
+        report.metric("largest_live_sector", f"{largest['sector_code']} {largest['share']:.1%}")
+        if largest["share"] > MAX_LARGEST_SECTOR:
+            report.error(
+                f"sector {largest['sector_code']} holds {largest['share']:.1%} of the live "
+                f"universe, above the {MAX_LARGEST_SECTOR:.0%} ceiling — the taxonomy has "
+                "collapsed towards its input"
+            )
+
+    by_ticker = tables["by_ticker"]
+    current = by_ticker.filter(pl.col("is_current").fill_null(False))
+    report.metric("current_ticker_rows", current.height)
+    if not current.is_empty():
+        symbols = current["ticker"].n_unique()
+        named = current.filter(pl.col("industry_code") != "UNCL_OTHER")["ticker"].n_unique()
+        coverage = named / symbols
+        report.metric("current_tickers", symbols)
+        report.metric("current_ticker_coverage", round(coverage, 4))
+        if coverage < MIN_CURRENT_TICKER_COVERAGE:
+            report.error(
+                f"only {coverage:.1%} of current tickers resolve to a sector, below the "
+                f"{MIN_CURRENT_TICKER_COVERAGE:.0%} floor"
+            )
+        # A symbol current for two filers is the security master's known
+        # ambiguity, inherited here. It only hurts if the two disagree about
+        # what business the company is in.
+        shared = (
+            current.group_by("ticker")
+            .agg(pl.col("cik").n_unique().alias("filers"),
+                 pl.col("sector_code").n_unique().alias("sectors"))
+            .filter(pl.col("filers") > 1)
+        )
+        report.metric("ambiguous_current_tickers", shared.height)
+        contradictory = shared.filter(pl.col("sectors") > 1).height
+        report.metric("contradictory_current_tickers", contradictory)
+        if contradictory > MAX_CONTRADICTORY_TICKERS:
+            report.warn(
+                f"{contradictory} symbols are current for two filers that disagree "
+                "about the sector"
+            )
+        report.metric(
+            "current_tickers_by_industry_group",
+            {
+                row["industry_code"]: row["n"]
+                for row in current.filter(pl.col("sector_code").is_in(["UNCL", "FUND"]))
+                .group_by("industry_code").agg(pl.len().alias("n")).iter_rows(named=True)
+            },
+        )
+        report.metric(
+            "by_ticker_date_basis",
+            {
+                row["date_basis"]: row["n"]
+                for row in by_ticker.group_by("date_basis").agg(pl.len().alias("n")).iter_rows(
+                    named=True
+                )
+            },
+        )
+    return report
+
+
+__all__ = ["QualityReport", "check_taxonomy", "validate"]

recipe/schema.py

@@ -0,0 +1,195 @@
+"""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"
+
+# One dated statement that the SEC had a filer under a given code. This is the
+# evidence layer; everything else is a groupby over it, and anyone who
+# disagrees with how the spans were cut can cut their own.
+OBSERVATION_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "sic": pl.String,
+    "stated_on": pl.Date,
+    "knowledge_time": UTC_DATETIME,
+    # "xbrl" for a code read off a filing header, "submissions" for one read
+    # off EDGAR's current record of the filer. The second carries no history:
+    # it is what the SEC says today, dated the day the build ran.
+    "source": pl.String,
+    "source_ref": pl.String,
+    "is_dated": pl.Boolean,
+    "inserted_at": UTC_DATETIME,
+}
+
+# A run of consecutive filings that all stated the same code.
+#
+# `valid_to` is the last filing that stated it, not the day it stopped being
+# true. A company that files nothing for two years has a two-year gap in its
+# evidence, and pretending the span runs to the next filing would invent a
+# fact nobody published.
+SPAN_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "sic": pl.String,
+    "valid_from": pl.Date,
+    "valid_to": pl.Date,
+    "observations": pl.Int32,
+    "sources": pl.String,
+    "is_latest": pl.Boolean,
+    "rank_for_filer": pl.Int32,
+    "sector_code": pl.String,
+    "sector": pl.String,
+    "industry_code": pl.String,
+    "industry": pl.String,
+    "inserted_at": UTC_DATETIME,
+}
+
+# What a filer is classified as now: the newest code it has been seen under,
+# resolved all the way down the taxonomy and joined to its tickers.
+CLASSIFICATION_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "name": pl.String,
+    "primary_ticker": pl.String,
+    "all_tickers": pl.String,
+    "exchange": pl.String,
+    "is_active": pl.Boolean,
+    "sic": pl.String,
+    "sic_title": pl.String,
+    # "industry" for a real 1987 four-digit code, "industry_group" or
+    # "major_group" for one the SEC padded with zeros because it did not care
+    # to be more precise.
+    "sic_level": pl.String,
+    "sec_office": pl.String,
+    "division": pl.String,
+    "division_title": pl.String,
+    "major_group": pl.String,
+    "major_group_title": pl.String,
+    "industry_group": pl.String,
+    "sector_code": pl.String,
+    "sector": pl.String,
+    "industry_code": pl.String,
+    "industry": pl.String,
+    "naics_1997": pl.String,
+    "naics_title": pl.String,
+    "naics_sector": pl.String,
+    "naics_sector_title": pl.String,
+    "naics_candidates": pl.Int32,
+    "stated_on": pl.Date,
+    "observations": pl.Int32,
+    "source": pl.String,
+    "is_dated": pl.Boolean,
+    "first_seen": pl.Date,
+    "taxonomy_version": pl.String,
+    "inserted_at": UTC_DATETIME,
+}
+
+# The same answer keyed the way a strategy asks the question: by the symbol it
+# trades, over the window the symbol belonged to that company.
+TICKER_SCHEMA: dict[str, pl.DataType] = {
+    "ticker": pl.String,
+    "cik": pl.String,
+    "name": pl.String,
+    "exchange": pl.String,
+    "valid_from": pl.Date,
+    "valid_to": pl.Date,
+    "sic": pl.String,
+    "sector_code": pl.String,
+    "sector": pl.String,
+    "industry_code": pl.String,
+    "industry": pl.String,
+    # How much the dates are worth:
+    #   "dated"   - the window is the overlap of a ticker span and a code span,
+    #               both backed by filings. The code was in force then.
+    #   "undated" - a code is known for the filer, but nothing dates it to this
+    #               window: either it came from today's snapshot, or the spans
+    #               simply do not overlap. The filer's latest code is applied
+    #               across the whole window.
+    #   "unknown" - no code at all; the sector, if any, came from the forms the
+    #               filer files.
+    "date_basis": pl.String,
+    "is_current": pl.Boolean,
+    "inserted_at": UTC_DATETIME,
+}
+
+# EDGAR's own list of the codes it assigns, with everything derivable from a
+# code hung off it. 444 rows, and the join target for the three tables above.
+SIC_CODE_SCHEMA: dict[str, pl.DataType] = {
+    "sic": pl.String,
+    "title": pl.String,
+    "sec_office": pl.String,
+    "sic_level": pl.String,
+    "in_sic_1987": pl.Boolean,
+    "division": pl.String,
+    "division_title": pl.String,
+    "major_group": pl.String,
+    "major_group_title": pl.String,
+    "industry_group": pl.String,
+    "sector_code": pl.String,
+    "sector": pl.String,
+    "industry_code": pl.String,
+    "industry": pl.String,
+    "naics_1997": pl.String,
+    "naics_title": pl.String,
+    "naics_sector": pl.String,
+    "naics_sector_title": pl.String,
+    "naics_candidates": pl.Int32,
+    "filers": pl.Int32,
+    "filings": pl.Int32,
+    "inserted_at": UTC_DATETIME,
+}
+
+# The Census crosswalk as published: one row per (SIC, NAICS) pair, with the
+# part description where one 1987 industry was split across several 1997 ones.
+NAICS_MAP_SCHEMA: dict[str, pl.DataType] = {
+    "sic": pl.String,
+    "sic_title": pl.String,
+    "is_part": pl.Boolean,
+    "part_description": pl.String,
+    "naics_1997": pl.String,
+    "naics_title": pl.String,
+    "naics_sector": pl.String,
+    "naics_sector_title": pl.String,
+    "inserted_at": UTC_DATETIME,
+}
+
+# The taxonomy itself, so it can be read without reading Python.
+TAXONOMY_SCHEMA: dict[str, pl.DataType] = {
+    "sector_code": pl.String,
+    "sector": pl.String,
+    "industry_code": pl.String,
+    "industry": pl.String,
+    "sic_ranges": pl.String,
+    "edgar_codes": pl.Int32,
+    "taxonomy_version": pl.String,
+    "inserted_at": UTC_DATETIME,
+}
+
+CONFIG_SCHEMAS: dict[str, dict[str, pl.DataType]] = {
+    "classification": CLASSIFICATION_SCHEMA,
+    "by_ticker": TICKER_SCHEMA,
+    "spans": SPAN_SCHEMA,
+    "observations": OBSERVATION_SCHEMA,
+    "sic_codes": SIC_CODE_SCHEMA,
+    "naics_map": NAICS_MAP_SCHEMA,
+    "taxonomy": TAXONOMY_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/sic.py

@@ -0,0 +1,140 @@
+"""The shape of a SIC code, and what the SEC does to it.
+
+Two different things are called "SIC". The 1987 Standard Industrial
+Classification is a census taxonomy with 1 005 four-digit industries in 83
+major groups and 11 divisions. EDGAR's is a list of 444 codes the SEC assigns
+to filers, and only 284 of them are 1987 industries: the other 160 are the
+major group or the industry group padded with zeros, used when the SEC does
+not care to be more precise than "food" or "computer and office equipment".
+
+No real 1987 code ends in a zero -- checked against all 1 005 of them -- so
+the padding is unambiguous and `code_level` can read it off. That matters for
+the NAICS crosswalk, which is keyed on real four-digit industries and would
+silently drop two fifths of EDGAR's codes if they were joined as if they were
+the same thing.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# 1987 SIC Manual (Office of Management and Budget), divisions A-K as ranges of
+# major group. Published structure of a US government classification; the
+# ranges are asserted here and checked in the tests against the division
+# headers in the Census concordance file, which is the same structure stated
+# by the agency that maintains it.
+DIVISIONS: tuple[tuple[str, int, int, str], ...] = (
+    ("A", 1, 9, "Agriculture, Forestry and Fishing"),
+    ("B", 10, 14, "Mining"),
+    ("C", 15, 17, "Construction"),
+    ("D", 20, 39, "Manufacturing"),
+    ("E", 40, 49, "Transportation, Communications, Electric, Gas and Sanitary Services"),
+    ("F", 50, 51, "Wholesale Trade"),
+    ("G", 52, 59, "Retail Trade"),
+    ("H", 60, 67, "Finance, Insurance and Real Estate"),
+    ("I", 70, 89, "Services"),
+    ("J", 91, 97, "Public Administration"),
+    ("K", 99, 99, "Nonclassifiable Establishments"),
+)
+
+# The two major groups the Census concordance never prints a header row for:
+# it jumps from the division heading straight to 4011, and from the last
+# division heading straight to 9999. Titles are the 1987 manual's own.
+MAJOR_GROUP_FALLBACKS = {
+    "40": "Railroad Transportation",
+    "99": "Nonclassifiable Establishments",
+}
+
+# EDGAR codes whose major group says nothing about the business. 88 is
+# "Private Households" in the 1987 manual; the SEC reuses the range for two
+# registrant types that are not industries at all.
+EDGAR_ONLY_CODES = {
+    "8880": "American Depositary Receipts",
+    "8888": "Foreign Governments",
+    "9995": "Non-Operating Establishments",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Division:
+    letter: str
+    title: str
+
+
+def normalize(code: str | int | None) -> str | None:
+    """A SIC as four digits, or None if it is not one.
+
+    EDGAR writes agriculture as `100` in one place and `0100` in another, and
+    an empty string where a filer has no assigned code.
+    """
+    if code is None:
+        return None
+    text = str(code).strip()
+    if not text or not text.isdigit():
+        return None
+    text = text.lstrip("0") or "0"
+    if len(text) > 4 or text == "0":
+        return None
+    return text.zfill(4)
+
+
+def major_group(code: str) -> str:
+    return code[:2]
+
+
+def industry_group(code: str) -> str:
+    return code[:3]
+
+
+def code_level(code: str) -> str:
+    """How precise an EDGAR code is: a real industry, or a padded roll-up."""
+    if code.endswith("00"):
+        return "major_group"
+    if code.endswith("0"):
+        return "industry_group"
+    return "industry"
+
+
+def division_of(code: str) -> Division | None:
+    """The 1987 division a code sits in, or None where the range has no meaning.
+
+    `8880` and `8888` fall in major group 88 arithmetically, and major group 88
+    is Private Households. Returning Services for an American Depositary
+    Receipt would be worse than returning nothing.
+    """
+    if code in EDGAR_ONLY_CODES:
+        return None
+    group = int(major_group(code))
+    for letter, low, high, title in DIVISIONS:
+        if low <= group <= high:
+            return Division(letter, title)
+    return None
+
+
+def prefix_of(code: str) -> str:
+    """The digits of a code that actually carry meaning.
+
+    `2000` means all of major group 20, `2020` all of industry group 202, and
+    `2834` exactly one industry. Used to expand a roll-up into the real 1987
+    industries it stands for.
+    """
+    level = code_level(code)
+    if level == "major_group":
+        return code[:2]
+    if level == "industry_group":
+        return code[:3]
+    return code
+
+
+__all__ = [
+    "DIVISIONS",
+    "EDGAR_ONLY_CODES",
+    "MAJOR_GROUP_FALLBACKS",
+    "Division",
+    "code_level",
+    "division_of",
+    "industry_group",
+    "major_group",
+    "normalize",
+    "prefix_of",
+]

recipe/sources.py

@@ -0,0 +1,540 @@
+"""Where the classification comes from.
+
+Four sources, all free to redistribute:
+
+* `company-fundamentals`, a sibling dataset, for the code the SEC had a filer
+  under on the day of each XBRL filing. 440 000 dated statements since 2009.
+  This is the only free source of SIC *history* -- EDGAR's own record of a
+  filer states today's code and nothing before it.
+* EDGAR's per-filer submissions record, for the filers the first source never
+  sees: delisted before XBRL, a fund, a foreign issuer filing on paper. One
+  small request each, and it carries no history.
+* The SEC's published list of the 444 codes it assigns, for the title of each
+  and the office that reviews it.
+* The Census Bureau's 1987 SIC to 1997 NAICS concordance, for the bridge to
+  the classification the rest of the US statistical system uses -- and, as a
+  by-product, for the titles of the 1987 major groups and divisions.
+
+All four are US government works or derived from them. Nothing licensed goes
+in, which is the constraint the whole dataset is built around.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import html
+import logging
+import re
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+
+import httpx
+import polars as pl
+
+from .config import SIBLING_DIRS, SOURCE_REPOS, Settings
+from .naics import sector_of
+from .schema import OBSERVATION_SCHEMA, align, empty_frame
+from .sic import MAJOR_GROUP_FALLBACKS, normalize
+
+LOGGER = logging.getLogger(__name__)
+
+SIC_LIST_URL = "https://www.sec.gov/search-filings/standard-industrial-classification-sic-code-list"
+SUBMISSIONS_BULK_URL = (
+    "https://www.sec.gov/Archives/edgar/daily-index/bulkdata/submissions.zip"
+)
+CONCORDANCE_URL = "https://www.census.gov/naics/concordances/1987_SIC_to_1997_NAICS.xls"
+
+# SEC rebuilds the archive nightly, but a filer's assigned code moves on the
+# scale of years. A week-old copy is the same answer and one fewer gigabyte.
+BULK_MAX_AGE_SECONDS = 7 * 24 * 3600
+BULK_MAX_RESUMES = 12
+
+ENTITY_KIND_SCHEMA = {"cik": pl.String, "entity_kind": pl.String, "source_ref": pl.String}
+
+# census.gov answers 403 to the SEC-style User-Agent this project uses
+# everywhere else, and 200 to an ordinary browser string. The file is a static
+# reference table published for download, fetched once per build and cached.
+CENSUS_USER_AGENT = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+)
+
+_ROW = re.compile(r"<tr[^>]*>(.*?)</tr>", re.DOTALL)
+_CELL = re.compile(r"<t[dh][^>]*>(.*?)</t[dh]>", re.DOTALL)
+_TAG = re.compile(r"<[^>]+>")
+
+
+def _fresh(path: Path, max_age_seconds: float) -> bool:
+    return path.is_file() and (time.time() - path.stat().st_mtime) <= max_age_seconds
+
+
+def _text(fragment: str) -> str:
+    return re.sub(r"\s+", " ", html.unescape(_TAG.sub(" ", fragment))).strip()
+
+
+# ---------------------------------------------------------------- siblings
+
+
+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 _parquet_files(root: Path) -> list[Path]:
+    return sorted(
+        path
+        for path in root.rglob("*.parquet")
+        if not any(part.endswith(".delta") or part == "_delta_log" for part in path.parts)
+    )
+
+
+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 = _parquet_files(local / config)
+        if files:
+            LOGGER.info("reading %s/%s from %s", name, config, local)
+            return pl.scan_parquet(files).select(columns)
+
+    from huggingface_hub import snapshot_download
+
+    LOGGER.info("downloading data/%s from %s", config, SOURCE_REPOS[name])
+    root = Path(
+        snapshot_download(
+            repo_id=SOURCE_REPOS[name],
+            repo_type="dataset",
+            allow_patterns=[f"data/{config}/**"],
+            token=token,
+        )
+    )
+    files = _parquet_files(root / "data" / config)
+    if not files:
+        raise FileNotFoundError(f"{SOURCE_REPOS[name]} has no {config} parquet")
+    return pl.scan_parquet(files).select(columns)
+
+
+def from_fundamental_filings(settings: Settings, *, token: str | None = None) -> pl.DataFrame:
+    """The code the SEC had a filer under, on the day of each XBRL filing.
+
+    `accepted_at` is kept as the knowledge time rather than `filed_date`
+    because the two differ for anything filed after hours, and a classification
+    joined to intraday data on the filing date would be using a fact hours
+    before the market could have known it.
+    """
+    frame = (
+        sibling_frame(
+            settings,
+            "fundamentals",
+            "filings",
+            ["cik", "sic", "filed_date", "accepted_at", "accession_number"],
+            token=token,
+        )
+        .filter(
+            pl.col("cik").is_not_null()
+            & pl.col("filed_date").is_not_null()
+            & pl.col("sic").is_not_null()
+            & (pl.col("sic").str.strip_chars() != "")
+        )
+        .collect()
+    )
+    LOGGER.info("xbrl filings with a SIC: %d", frame.height)
+    return _observations(
+        frame.select(
+            pl.col("cik"),
+            pl.col("sic").map_elements(normalize, return_dtype=pl.String).alias("sic"),
+            pl.col("filed_date").alias("stated_on"),
+            pl.col("accepted_at").alias("knowledge_time"),
+            pl.lit("xbrl").alias("source"),
+            pl.col("accession_number").alias("source_ref"),
+            pl.lit(True).alias("is_dated"),
+        ).filter(pl.col("sic").is_not_null())
+    )
+
+
+def ticker_spans(settings: Settings, *, token: str | None = None) -> pl.DataFrame:
+    """Every ticker a filer has been seen under, and the window it held it."""
+    frame = (
+        sibling_frame(
+            settings,
+            "security_master",
+            "identifiers",
+            ["cik", "kind", "value", "valid_from", "valid_to", "is_current"],
+            token=token,
+        )
+        .filter(pl.col("kind") == "ticker")
+        .collect()
+    )
+    LOGGER.info("ticker spans: %d over %d filers", frame.height, frame["cik"].n_unique())
+    return frame.rename({"value": "ticker"}).drop("kind")
+
+
+def issuers(settings: Settings, *, token: str | None = None) -> pl.DataFrame:
+    """The filer directory: name, tickers, exchange, whether it still files."""
+    frame = sibling_frame(
+        settings,
+        "security_master",
+        "issuers",
+        ["cik", "name", "primary_ticker", "all_tickers", "exchange", "is_active", "first_seen"],
+        token=token,
+    ).collect()
+    LOGGER.info("issuers: %d", frame.height)
+    return frame
+
+
+# -------------------------------------------------------------------- SEC
+
+
+def _observations(frame: pl.DataFrame) -> pl.DataFrame:
+    if frame.is_empty():
+        return empty_frame(OBSERVATION_SCHEMA)
+    return align(frame.with_columns(pl.lit(datetime.now(UTC)).alias("inserted_at")),
+                 OBSERVATION_SCHEMA)
+
+
+# The page has carried 444 codes for years. A parse that returns far fewer
+# has met a layout change, and the alternative to failing is a build that
+# quietly loses the titles of two hundred industries.
+MIN_SIC_CODES = 400
+
+
+def parse_sic_list(page: str) -> pl.DataFrame:
+    """The three-column table on the SEC's SIC code list page."""
+    rows: list[dict] = []
+    for fragment in _ROW.findall(page):
+        cells = [_text(cell) for cell in _CELL.findall(fragment)]
+        if len(cells) != 3 or cells[0].strip().lower() == "sic code":
+            continue
+        code = normalize(cells[0])
+        if code:
+            rows.append({"sic": code, "sec_office": cells[1] or None, "title": cells[2]})
+    if not rows:
+        return pl.DataFrame(schema={"sic": pl.String, "sec_office": pl.String,
+                                    "title": pl.String})
+    return pl.DataFrame(rows).unique(subset=["sic"], keep="first").sort("sic")
+
+
+async def edgar_sic_list(client) -> pl.DataFrame:
+    """The 444 codes the SEC assigns, with the office that reviews each.
+
+    Scraped, because the SEC publishes this list as a web page and nowhere
+    else -- there is no CSV, no JSON and no bulk file.
+    """
+    page = await client.get_text(SIC_LIST_URL, max_age_seconds=7 * 24 * 3600)
+    frame = parse_sic_list(page)
+    LOGGER.info("EDGAR SIC list: %d codes", frame.height)
+    if frame.height < MIN_SIC_CODES:
+        raise RuntimeError(
+            f"the SEC SIC code list parsed to {frame.height} rows; it has had 444 for "
+            "years, so the page layout has changed and the parser needs looking at"
+        )
+    return frame
+
+
+async def download_bulk_submissions(client, cache_dir: Path) -> Path:
+    """EDGAR's whole submissions directory, as one file.
+
+    The obvious implementation asks `data.sec.gov/submissions/CIK*.json` once
+    per filer. Measured on the six thousand filers this build needs, that runs
+    at a fifth of a request per second: SEC answers the first few hundred and
+    then throttles, and the client spends its time in backoff. Eight hours for
+    six thousand small files.
+
+    SEC publishes this archive for exactly that reason. It is 1.5 GB and one
+    request, which arrives in about four minutes, and it is kinder to the
+    service than a crawl it would rather we did not run.
+
+    Streamed to disk rather than held in memory, and resumed by byte range if
+    the transfer breaks -- EDGAR closes long connections often enough that
+    restarting a gigabyte from zero would be a way to never finish.
+
+    The resume is deliberately suspicious of its own partial file. Every
+    attempt re-reads the size from disk, a server that answers a ranged
+    request with a whole body restarts the file rather than appending to it,
+    and the result is accepted only when the byte count matches what the
+    server declared *and* the zip's directory can be read. A partial download
+    that is merely plausible produces a `BadZipFile` thousands of lines later,
+    which is how this was found.
+    """
+    cache_dir = Path(cache_dir)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    target = cache_dir / "submissions-bulk.zip"
+    partial = cache_dir / "submissions-bulk.zip.part"
+    if _fresh(target, BULK_MAX_AGE_SECONDS) and _is_readable_zip(target):
+        LOGGER.info("submissions archive: cached (%.2f GB)", target.stat().st_size / 1e9)
+        return target
+    target.unlink(missing_ok=True)
+
+    headers = {"User-Agent": client.user_agent, "Accept-Encoding": "identity"}
+    for attempt in range(1, BULK_MAX_RESUMES + 1):
+        have = partial.stat().st_size if partial.is_file() else 0
+        request = dict(headers) | ({"Range": f"bytes={have}-"} if have else {})
+        try:
+            async with (
+                httpx.AsyncClient(timeout=300.0, follow_redirects=True) as fetcher,
+                fetcher.stream("GET", SUBMISSIONS_BULK_URL, headers=request) as response,
+            ):
+                response.raise_for_status()
+                # A server may answer a ranged request with the whole body.
+                # Appending that to what is already there is how a download
+                # ends up larger than the file it was copying.
+                resuming = response.status_code == 206
+                if have and not resuming:
+                    have = 0
+                declared = response.headers.get("content-length")
+                total = (int(declared) + have) if declared else None
+                with partial.open("ab" if have else "wb") as handle:
+                    if not have:
+                        handle.truncate(0)
+                    async for chunk in response.aiter_bytes(1 << 20):
+                        handle.write(chunk)
+        except (httpx.TransportError, httpx.TimeoutException, httpx.HTTPStatusError) as error:
+            LOGGER.warning(
+                "submissions archive interrupted at %.2f GB (%s); resuming",
+                (partial.stat().st_size if partial.is_file() else 0) / 1e9,
+                type(error).__name__,
+            )
+            if attempt == BULK_MAX_RESUMES:
+                raise
+            continue
+
+        size = partial.stat().st_size
+        if total is not None and size != total:
+            LOGGER.warning("submissions archive is %d bytes, expected %d", size, total)
+            if size > total:  # cannot be repaired by asking for more
+                partial.unlink(missing_ok=True)
+            continue
+        if not _is_readable_zip(partial):
+            LOGGER.warning("submissions archive did not open as a zip; starting over")
+            partial.unlink(missing_ok=True)
+            continue
+        partial.replace(target)
+        LOGGER.info("submissions archive: %.2f GB", target.stat().st_size / 1e9)
+        return target
+    raise RuntimeError("could not download EDGAR's submissions archive")
+
+
+def _is_readable_zip(path: Path) -> bool:
+    """Whether the central directory parses. Cheap: it is at the end."""
+    import zipfile
+
+    if not path.is_file():
+        return False
+    try:
+        with zipfile.ZipFile(path) as bundle:
+            return bool(bundle.namelist())
+    except (zipfile.BadZipFile, OSError):
+        return False
+
+
+# What a filer files says what kind of entity it is, where no industry code
+# does. Both of these are definitions rather than guesses: N-CSR is the
+# certified shareholder report of a registered management investment company,
+# N-2 its registration statement; F-6 is the registration statement for
+# American Depositary Receipts. A filer that files one is that kind of thing.
+INVESTMENT_COMPANY_FORMS = frozenset(
+    {"N-CSR", "N-CSRS", "N-2", "N-PORT", "N-PORT/A", "N-Q", "N-CEN", "24F-2NT", "40-17G"}
+)
+DEPOSITARY_RECEIPT_PREFIX = "F-6"
+
+
+def _entity_kind(payload: dict) -> str | None:
+    """Investment company or depositary receipt programme, from the evidence.
+
+    Checked in that order: a fund that also sponsors a receipt programme is
+    still a fund, which is the stronger statement about what the entity is.
+    """
+    recent = (payload.get("filings") or {}).get("recent") or {}
+    forms = {form for form in (recent.get("form") or []) if form}
+    if forms & INVESTMENT_COMPANY_FORMS or payload.get("entityType") == "investment":
+        return "investment_company"
+    if any(form.startswith(DEPOSITARY_RECEIPT_PREFIX) for form in forms):
+        return "depositary_receipt"
+    return None
+
+
+def read_bulk_sic(archive: Path, ciks: list[str]) -> tuple[list[dict], list[dict]]:
+    """What EDGAR currently holds for these filers: a code, or failing that,
+    what kind of entity they are.
+
+    Only the per-filer metadata member is read, never the paginated history
+    files beside it: `sic` is in the first one and the rest are filings.
+
+    The second return is the fallback. Sixteen hundred live symbols belong to
+    filers the SEC has never assigned an industry -- closed-end funds, ADR
+    programmes -- and `null` reads the same as "we failed" to anyone consuming
+    this. Saying "this is a fund" is both true and more useful, and it comes
+    from the forms rather than from the name.
+    """
+    import json
+    import zipfile
+
+    wanted = {cik: f"CIK{cik}.json" for cik in ciks}
+    today = datetime.now(UTC).date()
+    now = datetime.now(UTC)
+    rows: list[dict] = []
+    kinds: list[dict] = []
+    missing = 0
+    with zipfile.ZipFile(archive) as bundle:
+        present = set(bundle.namelist())
+        for cik, member in wanted.items():
+            if member not in present:
+                missing += 1
+                continue
+            try:
+                payload = json.loads(bundle.read(member))
+            except (json.JSONDecodeError, KeyError, OSError):
+                missing += 1
+                continue
+            code = normalize(payload.get("sic"))
+            if code:
+                rows.append({
+                    "cik": cik, "sic": code, "stated_on": today, "knowledge_time": now,
+                    "source": "submissions", "source_ref": member, "is_dated": False,
+                })
+                continue
+            kind = _entity_kind(payload)
+            if kind:
+                kinds.append({"cik": cik, "entity_kind": kind, "source_ref": member})
+    LOGGER.info(
+        "submissions archive: %d codes, %d entity kinds, for %d filers (%d absent)",
+        len(rows), len(kinds), len(ciks), missing,
+    )
+    return rows, kinds
+
+
+async def submissions_snapshot(
+    client, ciks: list[str], *, limit: int | None = None
+) -> tuple[pl.DataFrame, pl.DataFrame]:
+    """Today's code, and the entity kind where there is no code.
+
+    Explicitly undated. EDGAR states what the SEC has the filer under now,
+    with no record of when it was assigned, so `stated_on` is the day the
+    build ran and `is_dated` is false. Treating that as a dated observation
+    would put a 2026 opinion on a company that delisted in 2007.
+    """
+    if limit is not None:
+        ciks = ciks[:limit]
+    if not ciks:
+        return empty_frame(OBSERVATION_SCHEMA), pl.DataFrame(schema=ENTITY_KIND_SCHEMA)
+    LOGGER.info("filers to resolve from the submissions archive: %d", len(ciks))
+    archive = await download_bulk_submissions(client, Path(client.cache_dir))
+    rows, kinds = read_bulk_sic(archive, ciks)
+    return (
+        _observations(pl.DataFrame(rows) if rows else pl.DataFrame()),
+        pl.DataFrame(kinds, schema=ENTITY_KIND_SCHEMA) if kinds
+        else pl.DataFrame(schema=ENTITY_KIND_SCHEMA),
+    )
+
+
+# ----------------------------------------------------------------- Census
+
+
+async def fetch_concordance(cache_dir: Path) -> bytes:
+    """The Census SIC-to-NAICS workbook, cached on disk.
+
+    It is a 2008 file describing a 1997 classification: it does not change,
+    and a build that re-downloaded it every run would be asking the Census
+    Bureau for the same 360 KB every week for no reason.
+    """
+    cache_dir = Path(cache_dir)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    digest = hashlib.sha256(CONCORDANCE_URL.encode()).hexdigest()[:16]
+    cached = cache_dir / f"concordance-{digest}.xls"
+    if cached.is_file() and cached.stat().st_size > 10_000:
+        return cached.read_bytes()
+    async with httpx.AsyncClient(
+        headers={"User-Agent": CENSUS_USER_AGENT}, timeout=60.0, follow_redirects=True
+    ) as fetcher:
+        response = await fetcher.get(CONCORDANCE_URL)
+        response.raise_for_status()
+    payload = response.content
+    cached.write_bytes(payload)
+    LOGGER.info("census concordance: %d bytes", len(payload))
+    return payload
+
+
+def parse_concordance(payload: bytes) -> tuple[pl.DataFrame, dict[str, str], list[str]]:
+    """The crosswalk, the major group titles, and the division titles in order.
+
+    One file answers three questions because of how it is laid out: a row with
+    no SIC is a division heading, a two-digit SIC is a major group heading, and
+    a four-digit SIC is an industry with its NAICS counterparts. Reading the
+    hierarchy out of the same file as the crosswalk means the titles come from
+    the agency that maintains the classification rather than being typed in
+    here from a manual.
+    """
+    import io
+
+    frame = pl.read_excel(io.BytesIO(payload), has_header=True, infer_schema_length=0)
+    if frame.width < 5:
+        raise RuntimeError(f"concordance has {frame.width} columns, expected 5")
+    frame.columns = ["sic", "part", "title", "naics", "naics_title"][: frame.width]
+    frame = frame.with_columns(pl.col("sic").str.strip_chars())
+
+    divisions = [
+        row["title"].strip()
+        for row in frame.filter(pl.col("sic").is_null() & pl.col("title").is_not_null())
+        .iter_rows(named=True)
+    ]
+    major_groups = dict(MAJOR_GROUP_FALLBACKS)
+    major_groups.update({
+        row["sic"]: row["title"].strip()
+        for row in frame.filter(pl.col("sic").str.len_chars() == 2).iter_rows(named=True)
+        if row["title"]
+    })
+
+    now = datetime.now(UTC)
+    industries = frame.filter(
+        (pl.col("sic").str.len_chars() == 4) & pl.col("naics").is_not_null()
+    )
+    # A "pt" row is one slice of a 1987 industry that 1997 split up; its title
+    # column holds the slice's description, indented with dots in the source.
+    rows: list[dict] = []
+    titles: dict[str, str] = {}
+    for row in frame.filter(pl.col("sic").str.len_chars() == 4).iter_rows(named=True):
+        if not row["part"] and row["title"]:
+            titles.setdefault(row["sic"], row["title"].strip())
+    for row in industries.iter_rows(named=True):
+        is_part = bool(row["part"])
+        naics = (row["naics"] or "").strip()
+        sector, sector_title = sector_of(naics)
+        rows.append({
+            "sic": row["sic"],
+            "sic_title": titles.get(row["sic"]),
+            "is_part": is_part,
+            "part_description": (row["title"] or "").lstrip(". ").strip() if is_part else None,
+            "naics_1997": naics,
+            "naics_title": (row["naics_title"] or "").strip() or None,
+            "naics_sector": sector,
+            "naics_sector_title": sector_title,
+            "inserted_at": now,
+        })
+    LOGGER.info(
+        "concordance: %d pairs, %d major groups, %d divisions",
+        len(rows), len(major_groups), len(divisions),
+    )
+    return pl.DataFrame(rows), major_groups, divisions
+
+
+__all__ = [
+    "ENTITY_KIND_SCHEMA",
+    "MIN_SIC_CODES",
+    "download_bulk_submissions",
+    "edgar_sic_list",
+    "fetch_concordance",
+    "from_fundamental_filings",
+    "issuers",
+    "parse_concordance",
+    "parse_sic_list",
+    "read_bulk_sic",
+    "sibling_frame",
+    "sibling_path",
+    "submissions_snapshot",
+    "ticker_spans",
+]

recipe/store.py

@@ -0,0 +1,55 @@
+"""Write and read the published tables.
+
+Every table here is rebuilt in full on each run, because every one of them is
+a groupby over sources that are themselves rebuilt in full. There is no
+append-only state to protect and no partition key worth having: the largest
+table is half a million rows.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+import polars as pl
+
+from .schema import CONFIG_SCHEMAS
+
+PART_NAME = "part-00000.parquet"
+
+
+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 read_table(data_dir: Path, table: str) -> pl.LazyFrame:
+    root = Path(data_dir) / table
+    if not root.is_dir():
+        return pl.LazyFrame(schema=dict(CONFIG_SCHEMAS[table]))
+    files = sorted(root.rglob("*.parquet"))
+    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 config_row_counts(data_dir: Path) -> dict[str, int]:
+    return {name: table_rows(data_dir, name) for name in CONFIG_SCHEMAS}

recipe/taxonomy.py

@@ -0,0 +1,437 @@
+"""ZipLime's sector and industry taxonomy, defined over SIC ranges.
+
+Why this exists
+---------------
+The two classifications everyone actually uses in equity research -- GICS and
+ICB -- are licensed products. Their per-company assignments cannot be
+redistributed, and neither can a table that reproduces their structure. So
+this dataset does not contain them, does not approximate them, and should not
+be described as compatible with them: a sector here and a GICS sector of the
+same name will disagree on real companies, and the disagreements are listed
+in PIPELINE.md.
+
+What is free is the input: the SEC states a SIC code for every filer, and a
+SIC code is a US government work. What is missing is the rollup, because the
+SIC divisions are useless for investing -- Division D, Manufacturing, holds
+pharmaceuticals, semiconductors, oil refining and breweries in one bucket
+that covers a third of the listed universe.
+
+So the rollup below is written here, by ZipLime, and licensed Apache-2.0 with
+the rest of the recipe. It is an opinion about which businesses belong
+together, stated as code so it can be argued with.
+
+How to read it
+--------------
+`RULES` is ordered and the first match wins, so a narrow range always precedes
+the wider one it sits inside. Ranges are over the four-digit code as an
+integer, and they cover the EDGAR roll-up codes by construction: `2000` falls
+in the food range just as `2011` does.
+
+Judgement calls worth knowing about, each one a place where a reasonable
+person would do something else:
+
+* `6324` Hospital & Medical Service Plans is Health Care, not Financials.
+  Centene, Cigna, Elevance, Humana and Molina file under it, and an insurance
+  factor built over them measures hospital reimbursement, not underwriting.
+* `7370` Computer Programming & Data Processing is its own industry rather
+  than being folded into IT services, because it is where Alphabet, Baidu and
+  AppLovin sit alongside consultancies. SIC cannot separate an advertising
+  platform from a systems integrator; naming the bucket honestly is better
+  than pretending the split exists.
+* `8731` Commercial Physical & Biological Research holds contract research
+  organisations (Charles River, ICON) and research-stage drug developers
+  (Incyte) in one code. It is mapped to tools and services, which is wrong for
+  the drug developers, and there is nothing in the filing that would tell them
+  apart.
+* `6770` Blank Checks gets a sector of its own rather than being hidden in
+  Financials. It is the third most common code in the corpus -- 1 340 filers
+  -- and a SPAC is not a financial company, it is an empty one. Anybody
+  building a universe wants to drop it by name.
+* `3011` tyres sit with vehicle components rather than with rubber, and `2950`
+  asphalt with construction materials rather than with refining, because in
+  both cases the customer decides the cycle.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+TAXONOMY_VERSION = "1.0.0"
+
+SECTORS: dict[str, str] = {
+    "ENER": "Energy",
+    "MATR": "Materials",
+    "INDU": "Industrials",
+    "CONC": "Consumer Cyclical",
+    "COND": "Consumer Defensive",
+    "HLTH": "Health Care",
+    "FINS": "Financials",
+    "TECH": "Technology",
+    "TLCM": "Telecom & Media",
+    "UTIL": "Utilities",
+    "REAL": "Real Estate",
+    "SHEL": "Shell & Blank Check",
+    "FUND": "Funds & Trusts",
+    "GOVT": "Government",
+    "UNCL": "Unclassified",
+}
+
+# industry code -> (sector code, industry title)
+INDUSTRIES: dict[str, tuple[str, str]] = {
+    "ENER_EP": ("ENER", "Oil & Gas Exploration & Production"),
+    "ENER_SERVICES": ("ENER", "Oil & Gas Equipment & Services"),
+    "ENER_MIDSTREAM": ("ENER", "Oil & Gas Storage & Transportation"),
+    "ENER_REFINE": ("ENER", "Oil & Gas Refining & Marketing"),
+    "ENER_COAL": ("ENER", "Coal & Consumable Fuels"),
+    "MATR_CHEM": ("MATR", "Chemicals"),
+    "MATR_AGCHEM": ("MATR", "Fertilizers & Agricultural Chemicals"),
+    "MATR_METALMIN": ("MATR", "Metals & Mining"),
+    "MATR_PRECIOUS": ("MATR", "Gold & Precious Metals"),
+    "MATR_STEEL": ("MATR", "Steel"),
+    "MATR_NONFERROUS": ("MATR", "Aluminium & Nonferrous Metals"),
+    "MATR_FOREST": ("MATR", "Paper & Forest Products"),
+    "MATR_CONTAIN": ("MATR", "Containers & Packaging"),
+    "MATR_BLDGMAT": ("MATR", "Construction Materials"),
+    "MATR_RUBBER": ("MATR", "Rubber & Plastic Products"),
+    "INDU_AERO": ("INDU", "Aerospace & Defence"),
+    "INDU_MACH": ("INDU", "Machinery"),
+    "INDU_ELECEQ": ("INDU", "Electrical Equipment"),
+    "INDU_BLDGPROD": ("INDU", "Building Products"),
+    "INDU_CONSTR": ("INDU", "Construction & Engineering"),
+    "INDU_DISTRIB": ("INDU", "Trading Companies & Distributors"),
+    "INDU_COMMSVC": ("INDU", "Commercial Services & Supplies"),
+    "INDU_PROFSVC": ("INDU", "Professional Services"),
+    "INDU_WASTE": ("INDU", "Waste Management"),
+    "INDU_RAIL": ("INDU", "Rail Transportation"),
+    "INDU_GROUND": ("INDU", "Ground Transportation"),
+    "INDU_MARINE": ("INDU", "Marine Transportation"),
+    "INDU_AIRLINE": ("INDU", "Passenger Airlines"),
+    "INDU_LOGISTICS": ("INDU", "Air Freight & Logistics"),
+    "INDU_MISC": ("INDU", "Diversified Industrial Products"),
+    "CONC_AUTO": ("CONC", "Automobiles"),
+    "CONC_AUTOPART": ("CONC", "Automobile Components"),
+    "CONC_HOMEBLD": ("CONC", "Homebuilding"),
+    "CONC_DURABLES": ("CONC", "Household Durables"),
+    "CONC_LEISURE": ("CONC", "Leisure Products"),
+    "CONC_TEXTILE": ("CONC", "Textiles, Apparel & Luxury Goods"),
+    "CONC_RETAIL": ("CONC", "Specialty Retail"),
+    "CONC_BROADLINE": ("CONC", "Broadline Retail"),
+    "CONC_ECOMM": ("CONC", "Direct & Online Retail"),
+    "CONC_RESTAURANT": ("CONC", "Restaurants"),
+    "CONC_HOTEL": ("CONC", "Hotels, Gaming & Leisure Facilities"),
+    "CONC_EDUCATION": ("CONC", "Education Services"),
+    "CONC_CONSSVC": ("CONC", "Consumer Services"),
+    "COND_AGRI": ("COND", "Agricultural Products"),
+    "COND_FOOD": ("COND", "Food Products"),
+    "COND_BEV": ("COND", "Beverages"),
+    "COND_TOBACCO": ("COND", "Tobacco"),
+    "COND_HOUSEHOLD": ("COND", "Household & Personal Products"),
+    "COND_FOODDIST": ("COND", "Food & Beverage Distribution"),
+    "COND_FOODRETAIL": ("COND", "Food & Drug Retail"),
+    "HLTH_PHARMA": ("HLTH", "Pharmaceuticals"),
+    "HLTH_BIOTECH": ("HLTH", "Biotechnology"),
+    "HLTH_TOOLS": ("HLTH", "Life Sciences Tools & Diagnostics"),
+    "HLTH_DEVICE": ("HLTH", "Health Care Equipment & Supplies"),
+    "HLTH_PROVIDER": ("HLTH", "Health Care Providers & Services"),
+    "HLTH_MANAGED": ("HLTH", "Managed Health Care"),
+    "HLTH_DIST": ("HLTH", "Health Care Distributors"),
+    "FINS_BANK": ("FINS", "Banks"),
+    "FINS_THRIFT": ("FINS", "Thrifts & Savings Institutions"),
+    "FINS_CONSFIN": ("FINS", "Consumer Finance"),
+    "FINS_MORTGAGE": ("FINS", "Mortgage Finance"),
+    "FINS_CAPMKT": ("FINS", "Capital Markets"),
+    "FINS_INSURANCE": ("FINS", "Insurance"),
+    "FINS_DIVFIN": ("FINS", "Diversified Financial Services"),
+    "TECH_SOFTWARE": ("TECH", "Software"),
+    "TECH_INTERNET": ("TECH", "Internet Software & Services"),
+    "TECH_ITSVC": ("TECH", "IT Services"),
+    "TECH_SEMI": ("TECH", "Semiconductors & Semiconductor Equipment"),
+    "TECH_HARDWARE": ("TECH", "Technology Hardware & Equipment"),
+    "TECH_COMMEQ": ("TECH", "Communications Equipment"),
+    "TECH_ELECTRONIC": ("TECH", "Electronic Equipment & Components"),
+    "TLCM_TELECOM": ("TLCM", "Telecommunication Services"),
+    "TLCM_MEDIA": ("TLCM", "Media & Entertainment"),
+    "TLCM_PUBLISH": ("TLCM", "Publishing"),
+    "TLCM_ADVERT": ("TLCM", "Advertising & Marketing"),
+    "UTIL_ELEC": ("UTIL", "Electric Utilities"),
+    "UTIL_GAS": ("UTIL", "Gas Utilities"),
+    "UTIL_WATER": ("UTIL", "Water Utilities"),
+    "UTIL_MULTI": ("UTIL", "Multi-Utilities"),
+    "REAL_REIT": ("REAL", "Real Estate Investment Trusts"),
+    "REAL_MGMT": ("REAL", "Real Estate Management & Development"),
+    "SHEL_BLANK": ("SHEL", "Blank Check & Shell Companies"),
+    "SHEL_NONOP": ("SHEL", "Non-Operating Establishments"),
+    "FUND_INVEST": ("FUND", "Investment Companies & Funds"),
+    "FUND_TRUST": ("FUND", "Trusts"),
+    "FUND_ABS": ("FUND", "Asset-Backed Securities"),
+    "GOVT_SOVEREIGN": ("GOVT", "Sovereign & Supranational"),
+    "GOVT_PUBLIC": ("GOVT", "Public Administration"),
+    "UNCL_ADR": ("UNCL", "Depositary Receipts"),
+    "UNCL_OTHER": ("UNCL", "Unclassified"),
+}
+
+# (low, high, industry code) over the four-digit code read as an integer.
+# Ordered: the first range that contains the code wins, so every exception
+# precedes the range it is an exception to.
+RULES: tuple[tuple[int, int, str], ...] = (
+    # -- Division A: agriculture, forestry, fishing ------------------------
+    (800, 899, "MATR_FOREST"),
+    (100, 799, "COND_AGRI"),
+    (900, 999, "COND_AGRI"),
+    # -- Division B: mining ------------------------------------------------
+    (1040, 1049, "MATR_PRECIOUS"),
+    (1000, 1099, "MATR_METALMIN"),
+    (1200, 1299, "ENER_COAL"),
+    (1380, 1389, "ENER_SERVICES"),
+    (1300, 1399, "ENER_EP"),
+    (1400, 1499, "MATR_BLDGMAT"),
+    # -- Division C: construction ------------------------------------------
+    (1520, 1539, "CONC_HOMEBLD"),
+    (1500, 1799, "INDU_CONSTR"),
+    # -- Division D: manufacturing -----------------------------------------
+    (2080, 2089, "COND_BEV"),
+    (2000, 2099, "COND_FOOD"),
+    (2100, 2199, "COND_TOBACCO"),
+    (2200, 2399, "CONC_TEXTILE"),
+    (2430, 2439, "INDU_BLDGPROD"),
+    (2440, 2449, "MATR_CONTAIN"),
+    (2450, 2459, "CONC_HOMEBLD"),
+    (2400, 2499, "MATR_FOREST"),
+    (2510, 2519, "CONC_DURABLES"),
+    (2520, 2549, "INDU_COMMSVC"),
+    (2590, 2599, "CONC_DURABLES"),
+    (2500, 2599, "CONC_DURABLES"),
+    (2650, 2659, "MATR_CONTAIN"),
+    (2600, 2699, "MATR_FOREST"),
+    (2750, 2799, "INDU_COMMSVC"),
+    (2700, 2749, "TLCM_PUBLISH"),
+    (2830, 2833, "HLTH_PHARMA"),
+    (2834, 2834, "HLTH_PHARMA"),
+    (2835, 2835, "HLTH_TOOLS"),
+    (2836, 2836, "HLTH_BIOTECH"),
+    (2837, 2839, "HLTH_PHARMA"),
+    (2840, 2849, "COND_HOUSEHOLD"),
+    (2870, 2879, "MATR_AGCHEM"),
+    (2800, 2899, "MATR_CHEM"),
+    (2950, 2959, "MATR_BLDGMAT"),
+    (2900, 2999, "ENER_REFINE"),
+    (3011, 3011, "CONC_AUTOPART"),
+    (3021, 3021, "CONC_TEXTILE"),
+    (3000, 3099, "MATR_RUBBER"),
+    (3100, 3199, "CONC_TEXTILE"),
+    (3220, 3229, "MATR_CONTAIN"),
+    (3200, 3299, "MATR_BLDGMAT"),
+    (3300, 3329, "MATR_STEEL"),
+    (3330, 3369, "MATR_NONFERROUS"),
+    (3370, 3399, "MATR_STEEL"),
+    (3411, 3412, "MATR_CONTAIN"),
+    (3420, 3449, "INDU_BLDGPROD"),
+    (3480, 3489, "INDU_AERO"),
+    (3400, 3499, "INDU_MACH"),
+    (3533, 3533, "ENER_SERVICES"),
+    (3559, 3559, "TECH_SEMI"),
+    (3500, 3569, "INDU_MACH"),
+    (3576, 3576, "TECH_COMMEQ"),
+    (3570, 3579, "TECH_HARDWARE"),
+    (3580, 3599, "INDU_MACH"),
+    (3630, 3639, "CONC_DURABLES"),
+    (3651, 3651, "CONC_DURABLES"),
+    (3652, 3659, "TLCM_MEDIA"),
+    (3650, 3650, "CONC_DURABLES"),
+    (3660, 3669, "TECH_COMMEQ"),
+    (3695, 3695, "TECH_ELECTRONIC"),
+    (3674, 3674, "TECH_SEMI"),
+    (3670, 3679, "TECH_ELECTRONIC"),
+    (3600, 3699, "INDU_ELECEQ"),
+    (3714, 3715, "CONC_AUTOPART"),
+    (3716, 3716, "CONC_LEISURE"),
+    (3700, 3713, "CONC_AUTO"),
+    (3717, 3719, "CONC_AUTOPART"),
+    (3720, 3739, "INDU_AERO"),
+    (3740, 3749, "INDU_MACH"),
+    (3750, 3759, "CONC_LEISURE"),
+    (3760, 3769, "INDU_AERO"),
+    (3790, 3799, "CONC_LEISURE"),
+    (3770, 3789, "CONC_AUTO"),
+    (3800, 3819, "INDU_AERO"),
+    (3826, 3826, "HLTH_TOOLS"),
+    (3820, 3829, "TECH_ELECTRONIC"),
+    (3840, 3851, "HLTH_DEVICE"),
+    (3830, 3839, "TECH_ELECTRONIC"),
+    (3852, 3869, "TECH_ELECTRONIC"),
+    (3870, 3879, "CONC_TEXTILE"),
+    (3900, 3919, "CONC_TEXTILE"),
+    (3920, 3949, "CONC_LEISURE"),
+    (3950, 3959, "INDU_COMMSVC"),
+    (3960, 3969, "CONC_TEXTILE"),
+    (3970, 3989, "CONC_LEISURE"),
+    (3990, 3999, "INDU_MISC"),
+    # -- Division E: transport, communications, utilities ------------------
+    (4000, 4099, "INDU_RAIL"),
+    (4100, 4199, "INDU_GROUND"),
+    (4220, 4229, "INDU_LOGISTICS"),
+    (4200, 4299, "INDU_GROUND"),
+    (4300, 4399, "INDU_LOGISTICS"),
+    (4400, 4499, "INDU_MARINE"),
+    (4513, 4513, "INDU_LOGISTICS"),
+    (4580, 4599, "INDU_LOGISTICS"),
+    (4500, 4579, "INDU_AIRLINE"),
+    (4600, 4699, "ENER_MIDSTREAM"),
+    (4700, 4799, "INDU_LOGISTICS"),
+    (4830, 4849, "TLCM_MEDIA"),
+    (4800, 4899, "TLCM_TELECOM"),
+    (4920, 4929, "UTIL_GAS"),
+    (4930, 4939, "UTIL_MULTI"),
+    (4940, 4949, "UTIL_WATER"),
+    (4950, 4959, "INDU_WASTE"),
+    (4960, 4989, "UTIL_MULTI"),
+    (4900, 4999, "UTIL_ELEC"),
+    # -- Divisions F and G: wholesale and retail ---------------------------
+    (5047, 5047, "HLTH_DIST"),
+    (5122, 5122, "HLTH_DIST"),
+    (5140, 5149, "COND_FOODDIST"),
+    (5171, 5172, "ENER_REFINE"),
+    (5180, 5189, "COND_FOODDIST"),
+    (5000, 5199, "INDU_DISTRIB"),
+    (5200, 5299, "CONC_RETAIL"),
+    (5300, 5399, "CONC_BROADLINE"),
+    (5400, 5499, "COND_FOODRETAIL"),
+    (5500, 5799, "CONC_RETAIL"),
+    (5800, 5899, "CONC_RESTAURANT"),
+    (5912, 5912, "COND_FOODRETAIL"),
+    (5960, 5969, "CONC_ECOMM"),
+    (5900, 5999, "CONC_RETAIL"),
+    # -- Division H: finance, insurance, real estate -----------------------
+    (6035, 6036, "FINS_THRIFT"),
+    (6030, 6039, "FINS_THRIFT"),
+    (6000, 6099, "FINS_BANK"),
+    (6120, 6129, "FINS_THRIFT"),
+    (6140, 6149, "FINS_CONSFIN"),
+    (6111, 6111, "FINS_MORTGAGE"),
+    (6160, 6169, "FINS_MORTGAGE"),
+    (6189, 6189, "FUND_ABS"),
+    (6100, 6199, "FINS_DIVFIN"),
+    (6200, 6299, "FINS_CAPMKT"),
+    (6324, 6324, "HLTH_MANAGED"),
+    (6300, 6499, "FINS_INSURANCE"),
+    (6500, 6599, "REAL_MGMT"),
+    (6711, 6711, "FINS_BANK"),
+    (6700, 6719, "FINS_DIVFIN"),
+    (6720, 6729, "FUND_INVEST"),
+    (6730, 6739, "FUND_TRUST"),
+    (6740, 6769, "FINS_DIVFIN"),
+    (6770, 6770, "SHEL_BLANK"),
+    (6792, 6792, "ENER_EP"),
+    (6794, 6794, "INDU_PROFSVC"),
+    (6795, 6795, "ENER_EP"),
+    (6798, 6798, "REAL_REIT"),
+    (6771, 6799, "FUND_INVEST"),
+    # -- Division I: services ----------------------------------------------
+    (7000, 7099, "CONC_HOTEL"),
+    (7200, 7299, "CONC_CONSSVC"),
+    (7310, 7319, "TLCM_ADVERT"),
+    (7320, 7329, "INDU_PROFSVC"),
+    (7350, 7359, "INDU_DISTRIB"),
+    (7360, 7369, "INDU_PROFSVC"),
+    (7370, 7370, "TECH_INTERNET"),
+    (7372, 7372, "TECH_SOFTWARE"),
+    (7371, 7371, "TECH_ITSVC"),
+    (7373, 7379, "TECH_ITSVC"),
+    (7385, 7385, "TLCM_TELECOM"),
+    (7300, 7399, "INDU_COMMSVC"),
+    (7510, 7519, "INDU_GROUND"),
+    (7500, 7699, "CONC_CONSSVC"),
+    (7700, 7899, "TLCM_MEDIA"),
+    (7900, 7999, "CONC_HOTEL"),
+    (8071, 8071, "HLTH_TOOLS"),
+    (8000, 8099, "HLTH_PROVIDER"),
+    (8100, 8199, "INDU_PROFSVC"),
+    (8200, 8299, "CONC_EDUCATION"),
+    (8300, 8399, "CONC_CONSSVC"),
+    (8400, 8499, "CONC_HOTEL"),
+    (8500, 8699, "CONC_CONSSVC"),
+    (8711, 8711, "INDU_CONSTR"),
+    (8731, 8734, "HLTH_TOOLS"),
+    (8700, 8710, "INDU_CONSTR"),
+    (8712, 8730, "INDU_PROFSVC"),
+    (8735, 8799, "INDU_PROFSVC"),
+    (8880, 8880, "UNCL_ADR"),
+    (8888, 8888, "GOVT_SOVEREIGN"),
+    (8800, 8879, "UNCL_OTHER"),
+    (8881, 8887, "UNCL_OTHER"),
+    (8889, 8899, "UNCL_OTHER"),
+    (8900, 8999, "INDU_PROFSVC"),
+    # -- Divisions J and K: public administration, nonclassifiable ---------
+    (9721, 9721, "GOVT_SOVEREIGN"),
+    (9100, 9729, "GOVT_PUBLIC"),
+    (9995, 9995, "SHEL_NONOP"),
+    (9000, 9999, "UNCL_OTHER"),
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Assignment:
+    industry_code: str
+    industry: str
+    sector_code: str
+    sector: str
+
+
+def _assignment(industry_code: str) -> Assignment:
+    sector_code, industry = INDUSTRIES[industry_code]
+    return Assignment(industry_code, industry, sector_code, SECTORS[sector_code])
+
+
+UNCLASSIFIED = _assignment("UNCL_OTHER")
+
+# Where there is no industry code at all, what the filer files still says what
+# kind of thing it is. A closed-end fund has no industry and never will; a
+# depositary receipt programme has whatever industry its underlying has, which
+# EDGAR does not record. Both are better stated than left as a bare null,
+# which reads the same as a failure.
+ENTITY_KIND_INDUSTRY: dict[str, str] = {
+    "investment_company": "FUND_INVEST",
+    "depositary_receipt": "UNCL_ADR",
+}
+
+
+def classify_entity(kind: str | None) -> Assignment | None:
+    """Sector and industry implied by what a filer files, or None."""
+    industry_code = ENTITY_KIND_INDUSTRY.get(kind or "")
+    return _assignment(industry_code) if industry_code else None
+
+
+def classify(code: str | None) -> Assignment:
+    """Sector and industry for a four-digit SIC code.
+
+    A code nothing matches is unclassified rather than an error. EDGAR has
+    added codes before -- asset-backed securities and crypto assets both
+    arrived after the 1987 manual -- and a build that refused to run because
+    the SEC invented a code would be worse than one that labels it honestly
+    and lets the quality gate count how many there are.
+    """
+    if not code or not code.isdigit() or len(code) != 4:
+        return UNCLASSIFIED
+    value = int(code)
+    for low, high, industry_code in RULES:
+        if low <= value <= high:
+            return _assignment(industry_code)
+    return UNCLASSIFIED
+
+
+def sector_of(code: str | None) -> str:
+    return classify(code).sector_code
+
+
+__all__ = [
+    "ENTITY_KIND_INDUSTRY",
+    "INDUSTRIES",
+    "RULES",
+    "SECTORS",
+    "TAXONOMY_VERSION",
+    "UNCLASSIFIED",
+    "Assignment",
+    "classify",
+    "classify_entity",
+    "sector_of",
+]

tests/conftest.py

@@ -0,0 +1,75 @@
+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 statement(cik, sic, day, *, source="xbrl", ref="acc-1", dated=True):
+    return {
+        "cik": cik, "sic": sic, "stated_on": day,
+        "knowledge_time": datetime.combine(day, datetime.min.time(), tzinfo=UTC),
+        "source": source, "source_ref": ref, "is_dated": dated,
+        "inserted_at": datetime.now(UTC),
+    }
+
+
+@pytest.fixture
+def observations() -> pl.DataFrame:
+    """A de-SPAC, a steady company, and a filer EDGAR only knows about today.
+
+    Filer 1 is the case the point-in-time columns exist for: it filed as a
+    blank check, merged with a car maker and was reclassified. A dataset that
+    stated only today's code would put an automotive sector on its 2020
+    filings, when it was an empty shell.
+    """
+    rows = [
+        statement("0000000001", "6770", date(2020, 3, 2), ref="a1"),
+        statement("0000000001", "6770", date(2020, 8, 2), ref="a2"),
+        statement("0000000001", "3711", date(2021, 5, 2), ref="a3"),
+        statement("0000000001", "3711", date(2024, 5, 2), ref="a4"),
+        statement("0000000002", "2834", date(2012, 1, 5), ref="b1"),
+        statement("0000000002", "2834", date(2023, 1, 5), ref="b2"),
+        statement("0000000003", "6022", date(2026, 10, 1), source="submissions",
+                  ref="CIK0000000003.json", dated=False),
+    ]
+    return pl.DataFrame(rows)
+
+
+@pytest.fixture
+def tickers() -> pl.DataFrame:
+    """Ticker spans as the security master publishes them."""
+    return pl.DataFrame([
+        {"cik": "0000000001", "ticker": "SPAC", "valid_from": date(2020, 3, 2),
+         "valid_to": date(2021, 2, 1), "is_current": False},
+        {"cik": "0000000001", "ticker": "CARZ", "valid_from": date(2021, 5, 2),
+         "valid_to": date(2024, 5, 2), "is_current": True},
+        {"cik": "0000000002", "ticker": "PILL", "valid_from": date(2012, 1, 5),
+         "valid_to": date(2023, 1, 5), "is_current": True},
+        # Delisted in 2007: the only code EDGAR holds for it is today's.
+        {"cik": "0000000003", "ticker": "GONE", "valid_from": date(2006, 4, 1),
+         "valid_to": date(2007, 9, 1), "is_current": False},
+        # A filer nothing knows a code for at all.
+        {"cik": "0000000004", "ticker": "HUH", "valid_from": date(2011, 1, 1),
+         "valid_to": date(2012, 1, 1), "is_current": False},
+    ])
+
+
+@pytest.fixture
+def directory() -> pl.DataFrame:
+    return pl.DataFrame([
+        {"cik": f"000000000{n}", "name": name, "primary_ticker": ticker,
+         "all_tickers": ticker, "exchange": "NYSE", "is_active": active,
+         "first_seen": date(2006, 1, 1)}
+        for n, name, ticker, active in (
+            (1, "Car Co", "CARZ", True), (2, "Pill Co", "PILL", True),
+            (3, "Gone Co", "GONE", False), (4, "Huh Co", "HUH", False),
+        )
+    ])

tests/test_build.py

@@ -0,0 +1,154 @@
+"""What the derived tables must say about a company that changed business."""
+
+from __future__ import annotations
+
+from datetime import date
+
+import polars as pl
+
+from recipe.build import (
+    build_by_ticker,
+    build_classification,
+    build_spans,
+    build_taxonomy_table,
+    entity_fallback,
+)
+from recipe.schema import CONFIG_SCHEMAS
+
+
+def test_spans_are_runs_not_groups(observations):
+    spans = build_spans(observations)
+    first = spans.filter(pl.col("cik") == "0000000001").sort("valid_from")
+    assert first["sic"].to_list() == ["6770", "3711"]
+    assert first["valid_from"].to_list() == [date(2020, 3, 2), date(2021, 5, 2)]
+    # valid_to is the last filing that said so, not the day before the next.
+    assert first["valid_to"].to_list() == [date(2020, 8, 2), date(2024, 5, 2)]
+    assert first["observations"].to_list() == [2, 2]
+
+
+def test_a_company_reclassified_back_keeps_both_spans():
+    """A groupby on (filer, code) would merge these and lose the order."""
+    rows = [
+        {"cik": "1", "sic": "6770", "stated_on": date(2020, 1, 1), "knowledge_time": None,
+         "source": "xbrl", "source_ref": "a", "is_dated": True, "inserted_at": None},
+        {"cik": "1", "sic": "3711", "stated_on": date(2021, 1, 1), "knowledge_time": None,
+         "source": "xbrl", "source_ref": "b", "is_dated": True, "inserted_at": None},
+        {"cik": "1", "sic": "6770", "stated_on": date(2022, 1, 1), "knowledge_time": None,
+         "source": "xbrl", "source_ref": "c", "is_dated": True, "inserted_at": None},
+    ]
+    spans = build_spans(pl.DataFrame(rows)).sort("valid_from")
+    assert spans.height == 3
+    assert spans["rank_for_filer"].to_list() == [3, 2, 1]
+    assert spans["is_latest"].to_list() == [False, False, True]
+
+
+def test_the_latest_span_is_the_one_marked(observations):
+    spans = build_spans(observations)
+    latest = spans.filter(pl.col("is_latest")).sort("cik")
+    assert latest["cik"].to_list() == ["0000000001", "0000000002", "0000000003"]
+    assert latest["sic"].to_list() == ["3711", "2834", "6022"]
+
+
+def test_classification_is_one_row_per_filer(observations, directory):
+    spans = build_spans(observations)
+    reference = pl.DataFrame({
+        "sic": ["3711", "2834", "6022"],
+        "title": ["MOTOR VEHICLES", "PHARMACEUTICAL PREPARATIONS", "STATE COMMERCIAL BANKS"],
+        "sic_level": ["industry"] * 3, "sec_office": [None] * 3,
+        "division": ["D", "D", "H"], "division_title": ["Manufacturing"] * 2 + ["Finance"],
+        "major_group": ["37", "28", "60"], "major_group_title": [None] * 3,
+        "industry_group": ["371", "283", "602"],
+        "sector_code": ["CONC", "HLTH", "FINS"],
+        "sector": ["Consumer Cyclical", "Health Care", "Financials"],
+        "industry_code": ["CONC_AUTO", "HLTH_PHARMA", "FINS_BANK"],
+        "industry": ["Automobiles", "Pharmaceuticals", "Banks"],
+        "naics_1997": [None] * 3, "naics_title": [None] * 3,
+        "naics_sector": [None] * 3, "naics_sector_title": [None] * 3,
+        "naics_candidates": [0, 0, 0],
+    })
+    frame = build_classification(spans, directory, reference, entity_fallback(pl.DataFrame()))
+    assert frame.height == frame["cik"].n_unique() == 3
+    car = frame.filter(pl.col("cik") == "0000000001").row(0, named=True)
+    assert (car["sector_code"], car["sic"]) == ("CONC", "3711")
+    assert car["is_dated"] is True
+    bank = frame.filter(pl.col("cik") == "0000000003").row(0, named=True)
+    # Its only code came from today's snapshot, so it carries no history.
+    assert bank["is_dated"] is False
+
+
+def test_by_ticker_clips_to_the_overlap(observations, tickers, directory):
+    spans = build_spans(observations)
+    frame = build_by_ticker(tickers, spans, directory)
+
+    spac = frame.filter(pl.col("ticker") == "SPAC").row(0, named=True)
+    assert spac["sector_code"] == "SHEL"
+    assert spac["valid_to"] == date(2020, 8, 2)  # the SIC span ends first
+    assert spac["date_basis"] == "dated"
+
+    carz = frame.filter(pl.col("ticker") == "CARZ").row(0, named=True)
+    assert (carz["sector_code"], carz["is_current"]) == ("CONC", True)
+
+
+def test_a_ticker_that_predates_the_evidence_still_gets_a_row(tickers, observations, directory):
+    """Delisted in 2007, so no filing overlaps; dropping it would leave the
+    universe made of survivors."""
+    frame = build_by_ticker(tickers, build_spans(observations), directory)
+    gone = frame.filter(pl.col("ticker") == "GONE").row(0, named=True)
+    assert gone["date_basis"] == "undated"
+    assert gone["sector_code"] == "FINS"
+    assert (gone["valid_from"], gone["valid_to"]) == (date(2006, 4, 1), date(2007, 9, 1))
+
+
+def test_a_ticker_with_no_code_at_all_is_present_and_unclassified(
+    tickers, observations, directory
+):
+    frame = build_by_ticker(tickers, build_spans(observations), directory)
+    huh = frame.filter(pl.col("ticker") == "HUH").row(0, named=True)
+    assert (huh["date_basis"], huh["sector_code"], huh["sic"]) == ("unknown", "UNCL", None)
+
+
+def test_is_current_marks_exactly_one_row_per_live_ticker(tickers, observations, directory):
+    """A live ticker whose company was reclassified must not come back current
+    under both its old sector and its new one."""
+    frame = build_by_ticker(tickers, build_spans(observations), directory)
+    current = frame.filter(pl.col("is_current"))
+    assert current.height == current["ticker"].n_unique()
+    assert set(current["ticker"]) == {"CARZ", "PILL"}
+
+
+def test_taxonomy_table_lists_every_industry():
+    frame = build_taxonomy_table()
+    assert set(frame.columns) <= set(CONFIG_SCHEMAS["taxonomy"])
+    assert frame["industry_code"].n_unique() == frame.height
+    assert frame.filter(pl.col("industry_code") == "HLTH_PHARMA")["sic_ranges"].item()
+
+
+def test_a_filer_known_only_by_its_forms_still_gets_classified(
+    observations, tickers, directory
+):
+    """A closed-end fund has no industry code and never will. Saying "fund"
+    beats a null, which reads the same as a failure."""
+    kinds = pl.DataFrame({
+        "cik": ["0000000004"], "entity_kind": ["investment_company"],
+        "source_ref": ["CIK0000000004.json"],
+    })
+    fallback = entity_fallback(kinds)
+    assert fallback.row(0, named=True)["sector_code"] == "FUND"
+
+    frame = build_by_ticker(tickers, build_spans(observations), directory, fallback)
+    huh = frame.filter(pl.col("ticker") == "HUH").row(0, named=True)
+    assert (huh["sector_code"], huh["industry_code"]) == ("FUND", "FUND_INVEST")
+    assert huh["date_basis"] == "unknown"  # still no date behind it
+    assert huh["sic"] is None  # and no code was invented for it
+
+
+def test_the_fallback_never_overrides_an_assigned_code(observations, tickers, directory):
+    kinds = pl.DataFrame({
+        "cik": ["0000000002"], "entity_kind": ["investment_company"],
+        "source_ref": ["x"],
+    })
+    frame = build_by_ticker(
+        tickers, build_spans(observations), directory, entity_fallback(kinds)
+    )
+    pill = frame.filter(pl.col("ticker") == "PILL").row(0, named=True)
+    assert pill["sector_code"] == "HLTH"

tests/test_docs_and_jobs.py

@@ -0,0 +1,87 @@
+"""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
+from recipe.taxonomy import SECTORS
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _readme() -> str:
+    return (ROOT / "README.md").read_text(encoding="utf-8")
+
+
+def _frontmatter() -> dict:
+    text = _readme()
+    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_]+\}\}", _readme())
+
+
+def test_readme_names_every_sector():
+    """The card is where somebody decides whether the taxonomy suits them."""
+    text = _readme()
+    for code, name in SECTORS.items():
+        assert name in text, f"sector {code} ({name}) is not in the dataset card"
+
+
+def test_readme_states_that_this_is_not_gics_or_icb():
+    """The one claim that would be wrong and expensive to leave implied."""
+    text = _readme().lower()
+    assert "gics" in text and "icb" in text
+    assert "not gics" in text or "is not gics" in text or "neither gics" in text
+
+
+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, required - declared
+
+
+def test_schedule_runs_after_the_datasets_it_reads():
+    """Assembled from company-fundamentals (07:10 Mon) and security-master
+    (07:40 Mon); running before either publishes a week-old classification."""
+    minute, hour, _, _, weekday = DEFAULT_SCHEDULE.split()
+    assert weekday == "1", DEFAULT_SCHEDULE
+    assert (int(hour), int(minute)) > (7, 40), DEFAULT_SCHEDULE
+
+
+def test_manifest_lists_the_same_configs_as_the_schema():
+    path = ROOT / "manifest.json"
+    if not path.is_file():
+        return  # written by the first build
+    manifest = json.loads(path.read_text(encoding="utf-8"))
+    assert set(manifest["configs"]) == set(CONFIG_SCHEMAS)
+    assert set(manifest["sectors"]) == set(SECTORS)
+
+
+def test_notice_credits_every_source():
+    notice = (ROOT / "NOTICE").read_text(encoding="utf-8")
+    for source in ("Securities and Exchange Commission", "Census Bureau"):
+        assert source in notice

tests/test_sources.py

@@ -0,0 +1,216 @@
+"""Parsing the two scraped sources: a web page and a 2008 spreadsheet."""
+
+from __future__ import annotations
+
+import polars as pl
+
+from recipe.sic import DIVISIONS
+from recipe.sources import parse_concordance
+
+
+class _FakePage:
+    def __init__(self, text: str) -> None:
+        self._text = text
+
+    async def get_text(self, *_args, **_kwargs) -> str:
+        return self._text
+
+
+SIC_PAGE = """
+<table>
+<tr><th>SIC Code</th><th>Office</th><th>Industry Title</th></tr>
+<tr><td>100</td><td>Industrial Applications and Services</td>
+    <td>AGRICULTURAL PRODUCTION-CROPS</td></tr>
+<tr><td>2834</td><td>Office of Life Sciences</td><td>PHARMACEUTICAL&nbsp;PREPARATIONS</td></tr>
+<tr><td>6770</td><td>Multiple Offices</td><td>BLANK CHECKS</td></tr>
+</table>
+"""
+
+
+def test_sic_list_parses_three_column_rows():
+    from recipe.sources import parse_sic_list
+
+    frame = parse_sic_list(SIC_PAGE)
+    assert frame["sic"].to_list() == ["0100", "2834", "6770"]
+    assert frame.filter(pl.col("sic") == "2834")["title"].item() == "PHARMACEUTICAL PREPARATIONS"
+    assert frame.filter(pl.col("sic") == "6770")["sec_office"].item() == "Multiple Offices"
+
+
+async def test_sic_list_refuses_a_page_that_lost_its_table():
+    """A layout change must fail the build, not silently drop 200 titles."""
+    from recipe.sources import edgar_sic_list
+
+    try:
+        await edgar_sic_list(_FakePage(SIC_PAGE))
+    except RuntimeError as error:
+        assert "444" in str(error)
+    else:  # pragma: no cover - the guard is the point of the test
+        raise AssertionError("a three-row page should not have been accepted")
+
+
+CONCORDANCE = pl.DataFrame(
+    {
+        "SIC": [None, "28", "2834", "2836", "2836", None, "99", "9999"],
+        "Part Indicator": [None, None, None, "pt", "pt", None, None, None],
+        "SIC Titles and Part Descriptions": [
+            "Manufacturing", "Chemicals and allied products", "Pharmaceutical Preparations",
+            ".   Vaccines", ".   Other", "Nonclassifiable establishments",
+            "Nonclassifiable", "Nonclassifiable Establishments",
+        ],
+        "1997 NAICS": [None, None, "325412", "325414", "325411", None, None, "99999"],
+        "1997 NAICS Titles and Part Indicators": [
+            None, None, "Pharmaceutical Preparation Manufacturing",
+            "Biological Product Manufacturing", "Medicinal and Botanical Manufacturing",
+            None, None, "Unclassified Establishments",
+        ],
+    }
+)
+
+
+def _workbook() -> bytes:
+    import io
+
+    buffer = io.BytesIO()
+    CONCORDANCE.write_excel(buffer)
+    return buffer.getvalue()
+
+
+def test_concordance_separates_hierarchy_from_crosswalk():
+    crosswalk, major_groups, divisions = parse_concordance(_workbook())
+    assert divisions == ["Manufacturing", "Nonclassifiable establishments"]
+    assert major_groups["28"] == "Chemicals and allied products"
+    # Supplied here because the Census file never prints a header row for them.
+    assert major_groups["40"] == "Railroad Transportation"
+    assert set(crosswalk["sic"]) == {"2834", "2836", "9999"}
+
+
+def test_a_split_industry_keeps_every_candidate():
+    crosswalk, _, _ = parse_concordance(_workbook())
+    split = crosswalk.filter(pl.col("sic") == "2836")
+    assert split.height == 2
+    assert split["is_part"].to_list() == [True, True]
+    assert split["part_description"].to_list() == ["Vaccines", "Other"]
+    assert set(split["naics_sector"]) == {"32"}
+
+
+def test_division_ranges_are_ordered_and_do_not_overlap():
+    """The letters are asserted in code rather than read from a source, so
+    the structure they claim has to hold on its own terms."""
+    previous_high = 0
+    for letter, low, high, title in DIVISIONS:
+        assert low <= high, letter
+        assert low > previous_high, f"division {letter} overlaps the one before it"
+        assert title.strip() == title and title
+        previous_high = high
+
+
+def test_concordance_divisions_match_the_declared_count():
+    _, _, divisions = parse_concordance(_workbook())
+    assert len(set(divisions)) == len(divisions)
+    assert divisions[0] == "Manufacturing"
+
+
+def test_a_truncated_archive_is_not_accepted(tmp_path):
+    """Half the bug this guards: a partial download that fails as a
+    `BadZipFile` thousands of lines later instead of at the download."""
+    import zipfile
+
+    from recipe.sources import _is_readable_zip
+
+    good = tmp_path / "good.zip"
+    with zipfile.ZipFile(good, "w") as bundle:
+        bundle.writestr("CIK0000000001.json", '{"sic": "2834"}')
+    assert _is_readable_zip(good)
+
+    payload = good.read_bytes()
+    truncated = tmp_path / "truncated.zip"
+    truncated.write_bytes(payload[: len(payload) // 2])
+    assert not _is_readable_zip(truncated)
+
+    assert not _is_readable_zip(tmp_path / "absent.zip")
+
+
+def test_an_overlong_archive_still_opens_which_is_why_the_size_is_checked(tmp_path):
+    """The other half, and the reason there are two checks rather than one.
+
+    The real failure was a `.part` file another process was still writing:
+    the downloader appended to it and ended up 10 MB past the declared length.
+    A zip with bytes after its directory still opens -- the reader scans
+    backwards for the end record -- so only comparing the byte count against
+    what the server declared catches this.
+    """
+    import zipfile
+
+    from recipe.sources import _is_readable_zip
+
+    good = tmp_path / "good.zip"
+    with zipfile.ZipFile(good, "w") as bundle:
+        bundle.writestr("CIK0000000001.json", '{"sic": "2834"}')
+    overlong = tmp_path / "overlong.zip"
+    overlong.write_bytes(good.read_bytes() + b"\x00" * 4096)
+
+    assert _is_readable_zip(overlong)
+    assert overlong.stat().st_size != good.stat().st_size
+
+
+def test_read_bulk_sic_takes_only_the_metadata_member(tmp_path):
+    import zipfile
+
+    from recipe.sources import read_bulk_sic
+
+    archive = tmp_path / "submissions.zip"
+    with zipfile.ZipFile(archive, "w") as bundle:
+        bundle.writestr("CIK0000000001.json", '{"sic": "2834", "name": "Pill Co"}')
+        # The paginated history files beside it hold filings, not metadata.
+        bundle.writestr("CIK0000000001-submissions-001.json", '{"filings": []}')
+        bundle.writestr("CIK0000000002.json", '{"sic": "", "name": "No Code Co"}')
+        bundle.writestr("CIK0000000003.json", "not json at all")
+
+    rows, kinds = read_bulk_sic(
+        archive, ["0000000001", "0000000002", "0000000003", "0000000009"]
+    )
+    assert [row["sic"] for row in rows] == ["2834"]
+    assert rows[0]["is_dated"] is False
+    assert rows[0]["source"] == "submissions"
+    assert kinds == []
+
+
+def test_a_filer_with_no_code_is_identified_by_what_it_files(tmp_path):
+    """Sixteen hundred live symbols belong to filers the SEC never assigned an
+    industry. N-CSR and F-6 say what they are, by definition of the forms."""
+    import json
+    import zipfile
+
+    from recipe.sources import read_bulk_sic
+
+    def record(name, forms, entity="other"):
+        return json.dumps(
+            {"sic": "", "name": name, "entityType": entity,
+             "filings": {"recent": {"form": forms}}}
+        )
+
+    archive = tmp_path / "submissions.zip"
+    with zipfile.ZipFile(archive, "w") as bundle:
+        bundle.writestr("CIK0000000001.json", record("A Closed-End Fund", ["N-CSR", "4"]))
+        bundle.writestr("CIK0000000002.json", record("Foreign Co ADR", ["F-6EF", "SC 13D"]))
+        bundle.writestr("CIK0000000003.json", record("Dormant Shell", ["4"]))
+        bundle.writestr("CIK0000000004.json", record("A Fund", [], entity="investment"))
+        # A fund that also sponsors a receipt programme is still a fund.
+        bundle.writestr("CIK0000000005.json", record("Both", ["N-2", "F-6"]))
+
+    _, kinds = read_bulk_sic(archive, [f"000000000{n}" for n in range(1, 6)])
+    assert {row["cik"]: row["entity_kind"] for row in kinds} == {
+        "0000000001": "investment_company",
+        "0000000002": "depositary_receipt",
+        "0000000004": "investment_company",
+        "0000000005": "investment_company",
+    }
+
+
+def test_entity_kinds_resolve_to_a_fund_and_a_receipt():
+    from recipe.taxonomy import classify_entity
+
+    assert classify_entity("investment_company").sector_code == "FUND"
+    assert classify_entity("depositary_receipt").industry_code == "UNCL_ADR"
+    assert classify_entity(None) is None
+    assert classify_entity("something else") is None

tests/test_taxonomy.py

@@ -0,0 +1,106 @@
+"""The taxonomy is code, and the things that would break it quietly."""
+
+from __future__ import annotations
+
+import pytest
+
+from recipe.quality import QualityReport, check_taxonomy
+from recipe.sic import EDGAR_ONLY_CODES, code_level, division_of, normalize, prefix_of
+from recipe.taxonomy import INDUSTRIES, RULES, SECTORS, classify
+
+
+def test_every_rule_names_a_real_industry_and_sector():
+    report = QualityReport()
+    check_taxonomy(report)
+    assert report.errors == []
+
+
+def test_every_industry_is_reachable_from_some_rule():
+    """An industry no rule points at is a title nothing will ever carry."""
+    reachable = {code for _, _, code in RULES}
+    # The three catch-alls exist for codes outside EDGAR's current list.
+    unreachable = set(INDUSTRIES) - reachable
+    assert unreachable <= {"UNCL_OTHER", "FUND_TRUST", "GOVT_PUBLIC"}, unreachable
+
+
+def test_every_four_digit_code_classifies():
+    """No gap in the rules: every code the SEC could invent lands somewhere."""
+    for value in range(100, 10_000):
+        assignment = classify(f"{value:04d}")
+        assert assignment.industry_code in INDUSTRIES
+        assert assignment.sector_code in SECTORS
+
+
+@pytest.mark.parametrize(
+    ("sic", "sector", "industry"),
+    [
+        ("2834", "HLTH", "HLTH_PHARMA"),
+        ("2836", "HLTH", "HLTH_BIOTECH"),
+        # Managed care files under an insurance code and is not insurance.
+        ("6324", "HLTH", "HLTH_MANAGED"),
+        ("3674", "TECH", "TECH_SEMI"),
+        # Semiconductor equipment hides inside "special industry machinery".
+        ("3559", "TECH", "TECH_SEMI"),
+        ("7372", "TECH", "TECH_SOFTWARE"),
+        ("6022", "FINS", "FINS_BANK"),
+        ("6798", "REAL", "REAL_REIT"),
+        ("6770", "SHEL", "SHEL_BLANK"),
+        ("4911", "UTIL", "UTIL_ELEC"),
+        ("1311", "ENER", "ENER_EP"),
+        # A roll-up resolves to the same place as the industries beneath it.
+        ("2000", "COND", "COND_FOOD"),
+        ("2011", "COND", "COND_FOOD"),
+        ("8888", "GOVT", "GOVT_SOVEREIGN"),
+        ("8880", "UNCL", "UNCL_ADR"),
+    ],
+)
+def test_known_codes(sic, sector, industry):
+    assignment = classify(sic)
+    assert (assignment.sector_code, assignment.industry_code) == (sector, industry)
+
+
+def test_narrow_rules_beat_the_ranges_that_contain_them():
+    """First match wins, so an exception placed after its range is dead code."""
+    for index, (low, high, _) in enumerate(RULES):
+        for other_low, other_high, _ in RULES[index + 1:]:
+            contained = other_low >= low and other_high <= high
+            assert not (contained and (other_low, other_high) != (low, high)), (
+                f"range {other_low}-{other_high} sits inside the earlier "
+                f"{low}-{high} and can never match"
+            )
+
+
+def test_unclassified_rather_than_raising():
+    for value in (None, "", "abc", "12345", "0"):
+        assert classify(value).sector_code == "UNCL"
+
+
+def test_normalize_accepts_what_edgar_actually_writes():
+    assert normalize("100") == "0100"
+    assert normalize(2834) == "2834"
+    assert normalize(" 3571 ") == "3571"
+    assert normalize("") is None
+    assert normalize("0000") is None
+    assert normalize("12345") is None
+
+
+def test_code_level_reads_the_padding():
+    assert code_level("2000") == "major_group"
+    assert code_level("2020") == "industry_group"
+    assert code_level("2834") == "industry"
+    assert prefix_of("2000") == "20"
+    assert prefix_of("2020") == "202"
+    assert prefix_of("2834") == "2834"
+
+
+def test_divisions_cover_every_major_group_the_sec_uses():
+    assert division_of("2834").letter == "D"
+    assert division_of("6022").letter == "H"
+    assert division_of("9995") is None
+
+
+def test_edgar_inventions_have_no_division():
+    """88 is Private Households; calling an ADR a household service is worse
+    than saying nothing."""
+    for code in EDGAR_ONLY_CODES:
+        assert division_of(code) is None