Update the security master

LICENSE

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

NOTICE

@@ -0,0 +1,11 @@
+ZipLime US Corporate Actions
+Copyright 2026 ZipLime
+
+Derived from ZipLime/company-fundamentals, which is itself the SEC's Financial
+Statement Data Sets — a US Government work in the public domain.
+
+Split events other than those the filer tagged are inferred from restated
+per-share figures and are labelled with the method and confidence that produced
+them. They are not statements of record.
+
+The SEC does not endorse, certify or verify this dataset.

PIPELINE.md

@@ -0,0 +1,135 @@
+# How this dataset is built
+
+Every step is in [`recipe/`](recipe/), at the same revision as the data.
+
+## What could not be built, and why it matters
+
+The first job was finding out what is actually reachable. The answer is
+narrower than the name "corporate actions" suggests, and worth stating plainly
+because everything else follows from it.
+
+SEC's Financial Statement Data Sets carry `num.txt` — **numeric facts only**.
+Dividend dates are typed as dates in XBRL, so they are in the filings and not
+in the bulk data. The XBRL API is not a way around it: a request for
+`DividendsPayableDateOfRecordDayMonthAndYear` returns 404, because that
+endpoint serves unit-bearing facts and a date has no unit.
+
+So there are no ex-dates, no record dates, no pay dates here. There is no free
+structured source for them. What remains is still worth having: per-share
+amounts by fiscal period, and split ratios.
+
+## Dividends
+
+Six tags carry per-share dividends, and they mean different things.
+`CommonStockDividendsPerShareDeclared` is a decision; `…CashPaid` is a cash
+movement; the preferred variants are a claim that ranks ahead of the common
+holder. They are kept apart rather than coalesced into one number.
+
+Facts from both the consolidated and the dimensional tables are read. The
+dimensional ones matter: a dividend declared after the period closed is tagged
+`SubsequentEventType=SubsequentEvent`, which makes it the one dividend fact
+that is not history — the declaration is already public when the filing is.
+
+`period_start` is derived from `period_end` and the fact's own `quarters`. A
+per-share dividend dated to an instant is a filer error and is dropped rather
+than assigned a day it did not cover.
+
+## Splits: the trace, not the event
+
+There is no free feed of US stock splits. There is, in a dataset that never
+overwrites what a filing said, the trace a split leaves: it forces the company
+to restate every earlier per-share figure by the ratio. Two filings covering
+the same quarter, one before the split and one after, differ by exactly that
+factor.
+
+This is stronger than the signal most people reach for. A jump in shares
+outstanding looks identical for a two-for-one split and for an equity raise
+that doubled the count. Only a split reaches back and rewrites the past.
+
+Three sources are combined and each is labelled:
+
+| Method | Filers | Standing |
+|---|---|---|
+| `xbrl_tag` | 514 rows | the filer tagged the conversion ratio — authority |
+| `eps_restatement` | 5 105 rows | inferred from restated per-share figures |
+| `share_count` | — | never used alone; cannot tell a split from an issuance |
+
+Validated against the tagged ratios: **73% of the companies with a tagged ratio
+also have the same ratio inferred**, and the inferred method reaches seven
+times as many companies.
+
+### Four things this got wrong first
+
+**The ratio list was handwritten and incomplete.** It had 2:1 through 20:1 and
+a few m:n forms, and no 6:1 — so Deckers' 2024 split, the very case this
+dataset exists to fix, was invisible. The evidence was all there; the ratio
+simply was not in the table.
+
+**Generating the list instead was worse.** Every simple fraction with small
+numerator and denominator gives 144 ratios, thirteen of whose tolerance bands
+overlap, and an ordinary 1.83× restatement then resolved to "eleven-for-six".
+The list is written out again, completed, and nothing between 0.85 and 1.18 is
+admitted at all: a five percent stock dividend and a five percent restatement
+leave the same trace.
+
+**One restated period is not evidence.** A single figure that happens to land
+on a clean ratio produced a four-for-one Tesla split in 2020 that never
+happened. Two is the floor; four or more earns `medium`; the count grades the
+claim rather than gating it, because a real split restates every prior period a
+filing shows — Apple's 2020 split left 36 of them.
+
+**Extreme ratios need more.** Earnings of minus two cents restated to minus
+forty dollars is a genuine one-for-a-thousand consolidation, and it is also
+what a rounding change looks like on a company whose EPS never left the third
+decimal. Ratios past 50× or under 0.02 now require the stronger evidence
+threshold.
+
+### The detection window
+
+A split gets a window, never a date. `detected_after` is the acceptance of the
+last filing that still used the old figures; `detected_before` the first that
+used the new. Deckers lands in 2024-08-01 → 2024-10-31, and the split was
+2024-09-16.
+
+Combining windows across restated periods takes their intersection, which is
+tighter. The intersection can be empty, and when it is, that is not an
+arithmetic slip — it means the evidence spans two events at the same ratio, a
+company that split two-for-one twice. The union is used then, a window that
+certainly contains them, rather than publishing one that ends before it starts.
+
+## The adjustment factor
+
+The table the rest of it is for. Walking the splits backwards from today gives,
+for every span, the product of every split that happened after it: Apple is
+28.0 before 2014, 4.0 between, 1.0 now. Multiply an as-filed share count by it,
+or divide an as-filed EPS, and the figure lines up with a split-adjusted price
+series.
+
+The gate checks that the newest span of every filer has a factor of exactly
+one. Anything else means the walk started from the wrong end, and the whole
+company's history would be off by a constant.
+
+## Verification
+
+[`quality.py`](recipe/quality.py) gates publication. Beyond the usual null and
+range checks: every published ratio must be one companies actually declare
+(1.83 is a restatement that slipped through, not a split), detection windows
+must not end before they start, and the agreement between the tagged and
+inferred methods must stay above 65% — a drop means the restatement signal has
+started picking up something that is not a split.
+
+## Schedule
+
+A Hugging Face Job runs weekly on Monday at 08:10 UTC, half an hour after the
+fundamentals rebuild it reads. Nothing else is fetched: this dataset has no
+source of its own.
+
+## What is not done
+
+* **No dates for dividends.** See the top of this document.
+* **No splits before 2009.** The restatement trace needs XBRL.
+* **No separation of special from regular dividends.** The filings usually do
+  not distinguish them either.
+* **No stock dividends under 18%.** Indistinguishable from a restatement.
+* **`share_count` is computed but not published as a method.** It corroborates;
+  it cannot stand alone.

README.md

@@ -0,0 +1,177 @@
+---
+license: apache-2.0
+language:
+  - en
+pretty_name: US Corporate Actions — dividends and splits, point-in-time
+size_categories:
+  - 100K<n<1M
+task_categories:
+  - tabular-regression
+  - time-series-forecasting
+tags:
+  - finance
+  - sec
+  - edgar
+  - xbrl
+  - dividends
+  - stock-splits
+  - corporate-actions
+  - point-in-time
+  - ziplime
+configs:
+  - config_name: dividends
+    data_files:
+      - split: train
+        path: "data/dividends/*.parquet"
+  - config_name: splits
+    data_files:
+      - split: train
+        path: "data/splits/*.parquet"
+  - config_name: adjustment_factors
+    data_files:
+      - split: train
+        path: "data/adjustment_factors/*.parquet"
+  - config_name: pit
+    data_files:
+      - split: train
+        path: "data/pit/*.parquet"
+---
+
+# US Corporate Actions — dividends and splits
+
+**391 639 dividends from 3 327 filers · 5 619 splits from 3 814 filers ·
+2005 to 2026**
+
+Built to close a specific hole. A filing states shares and earnings per share
+as of the day it was made; every price series is adjusted for splits since.
+Multiply one by the other and the answer is wrong by the split factor — on
+Deckers that turned a 6.9% earnings yield into 41.7%, a P/E of 1.8.
+
+The pipeline lives in [`recipe/`](recipe/) at the same revision as the data.
+See [PIPELINE.md](PIPELINE.md) for the method.
+
+## Read this before anything else
+
+**There are no ex-dates, record dates or pay dates here, and there is no free
+source for them.** SEC's structured data carries only numeric facts; the
+date-typed XBRL facts exist inside filings but not in the bulk data sets, and
+the XBRL API returns 404 for them. What this dataset has is what can be had
+from public filings: how much per share, over which fiscal period, known from
+when — and split ratios recovered from the trace a split leaves in restated
+figures.
+
+If you need an ex-date calendar, this is not it, and nothing free is.
+
+## The adjustment factor
+
+This is the table most people want. Multiply an as-filed per-share figure by
+`cumulative_split_factor` to put it on the same basis as a split-adjusted price
+series.
+
+```python
+import polars as pl
+
+factors = pl.read_parquet("data/adjustment_factors/*.parquet")
+
+# Deckers: a 6-for-1 split detected between 2024-08-01 and 2024-10-31
+factors.filter(pl.col("cik") == "0000910521")
+# valid_from    valid_to      cumulative_split_factor  splits_after
+# null          2024-10-31    6.0                      1
+# 2024-10-31    null          1.0                      0
+```
+
+Shares outstanding filed before that window need multiplying by six; earnings
+per share need dividing by it. Apple carries 28.0 before its 2014 seven-for-one
+(7 × 4), 4.0 between the two, and 1.0 today.
+
+## Splits, and how confident to be
+
+No free feed of US splits exists. What exists, in a dataset that keeps every
+filing's own version of a period, is the trace: a split forces the company to
+restate every earlier per-share figure by the ratio. Two filings covering the
+same quarter, one before and one after, differ by exactly that factor.
+
+That is stronger than the obvious signal. A jump in shares outstanding looks
+identical for a two-for-one split and an equity raise that doubled the count;
+only a split reaches back and rewrites the past.
+
+| Confidence | Rows | What it means |
+|---|---|---|
+| `high` | 514 | the filer tagged the conversion ratio, or both methods found it |
+| `medium` | 3 728 | inferred from four or more restated figures |
+| `low` | 1 377 | inferred from two or three |
+
+Verified against the ratios filers tagged themselves: the two methods agree for
+**73%** of the companies where both exist, and the inferred method reaches
+seven times as many companies.
+
+Each split carries a **window**, not a date: `detected_after` is the last
+filing that still used the old figures, `detected_before` the first that used
+the new. Deckers' September 2024 split lands in 2024-08-01 → 2024-10-31. That
+is as precise as filings allow, and a date invented inside that window would be
+a fiction.
+
+Reverse splits outnumber forward ones almost three to one — 3 933 to 1 686 —
+which is what the SEC filer universe actually looks like once you leave the
+index names: shells consolidate to keep a listing far more often than
+successful companies split.
+
+## Dividends
+
+Per-share amounts as filings stated them, for a fiscal period.
+
+| | |
+|---|---|
+| `declared` | 276 299 — a decision made in the period |
+| `cash_paid` | 115 340 — cash that moved in the period |
+| common / preferred | 369 413 / 22 226 |
+| restated later | 223 583 rows are a second or later report of the same period |
+| subsequent events | 769 declared after the period closed, disclosed in the filing that follows |
+
+Declared and paid are kept apart rather than merged: they are different facts,
+and a company can declare in one quarter and pay in the next. Preferred
+dividends are included because a preferred coupon ranks ahead of the common
+holder, and a yield computed without it is wrong for exactly the companies
+where it matters.
+
+`period_start` is derived from `period_end` and `quarters`; a dividend fact
+dated to an instant is dropped rather than assigned a day it did not cover.
+
+## Configs
+
+| Config | Rows | What one row is |
+|---|---|---|
+| `dividends` | 391 639 | one per-share dividend a filing stated for one period |
+| `splits` | 5 619 | one split, with the window it must have happened in |
+| `adjustment_factors` | 9 433 | one span and the factor that puts an as-filed figure on today's basis |
+| `pit` | 397 258 | one point-in-time action event, plus a Delta table for ziplime |
+
+`entity_id` in `pit` is the issuer CIK, the same key used across the family, so
+this joins directly to
+[company-fundamentals](https://huggingface.co/datasets/ZipLime/company-fundamentals),
+[insider-trading](https://huggingface.co/datasets/ZipLime/insider-trading) and
+[security-master](https://huggingface.co/datasets/ZipLime/security-master).
+
+## Known gaps
+
+* **No dividend dates.** See above. The period is the finest granularity
+  available.
+* **A split window is a window.** Typically one quarter wide.
+* **Splits before 2009 are not visible.** The restatement trace needs XBRL, and
+  XBRL starts in 2009 Q1. A company that split in 2006 shows no split here.
+* **Stock dividends under 18% are not detected.** A five percent stock dividend
+  and a five percent restatement leave the same trace, so nothing between 0.85
+  and 1.18 is admitted as a split rather than risk phantom factors.
+* **Special and irregular dividends are not separated** from regular ones. The
+  filing usually does not distinguish them either.
+* **Low-confidence splits are published, not hidden.** Filter on `confidence`
+  if a wrong factor would be worse than a missing one.
+
+## Provenance and updates
+
+Derived entirely from
+[ZipLime/company-fundamentals](https://huggingface.co/datasets/ZipLime/company-fundamentals),
+which is itself SEC XBRL — US Government work, public domain. No source of its
+own is fetched.
+
+Rebuilt weekly, Monday 08:10 UTC, after the dataset it reads.

data/adjustment_factors/part-00000.parquet

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

data/dividends/part-00000.parquet

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

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

@@ -0,0 +1,4 @@
+{"commitInfo":{"timestamp":1788777421655,"operation":"WRITE","operationParameters":{"mode":"Overwrite"},"engineInfo":"delta-rs:py-1.6.2","operationMetrics":{"execution_time_ms":173,"num_added_files":1,"num_added_rows":397258,"num_partitions":0,"num_removed_files":0},"clientVersion":"delta-rs.py-1.6.2"}}
+{"protocol":{"minReaderVersion":1,"minWriterVersion":2}}
+{"metaData":{"id":"c997adf7-aa2c-45f7-920b-2e446f6ac9b6","name":null,"description":null,"format":{"provider":"parquet","options":{}},"schemaString":"{\"type\":\"struct\",\"fields\":[{\"name\":\"pit_event_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"entity_id\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"event_date\",\"type\":\"date\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_date\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}},{\"name\":\"knowledge_estimated\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"action_type\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"amount_per_share\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"currency\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"split_ratio\",\"type\":\"double\",\"nullable\":true,\"metadata\":{}},{\"name\":\"security_class\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"quarters\",\"type\":\"integer\",\"nullable\":true,\"metadata\":{}},{\"name\":\"is_subsequent_event\",\"type\":\"boolean\",\"nullable\":true,\"metadata\":{}},{\"name\":\"confidence\",\"type\":\"string\",\"nullable\":true,\"metadata\":{}},{\"name\":\"ingested_at\",\"type\":\"timestamp\",\"nullable\":true,\"metadata\":{}}]}","partitionColumns":[],"createdTime":1788777421485,"configuration":{}}}
+{"add":{"path":"part-00000-b78602dd-42f6-4e85-9422-9c3d727a372e-c000.snappy.parquet","partitionValues":{},"size":5546989,"modificationTime":1788777421653,"dataChange":true,"stats":"{\"numRecords\":397258,\"minValues\":{\"action_type\":\"dividend_cash_paid\",\"amount_per_share\":-0.0,\"pit_event_id\":\"0000001961|split|0.2\",\"quarters\":1,\"entity_id\":\"0000001750\",\"event_date\":\"2005-03-31\",\"currency\":\"AFN\",\"split_ratio\":0.001,\"security_class\":\"common\",\"is_subsequent_event\":false,\"confidence\":\"high\",\"knowledge_date\":\"2009-04-15T20:44:00Z\",\"ingested_at\":\"2026-09-07T10:36:48.268812Z\",\"knowledge_estimated\":false},\"maxValues\":{\"confidence\":\"medium\",\"ingested_at\":\"2026-09-07T10:36:48.268812Z\",\"entity_id\":\"0002115119\",\"pit_event_id\":\"0002082866|split|1.8\",\"security_class\":\"preferred\",\"knowledge_date\":\"2026-06-30T20:51:00Z\",\"action_type\":\"split\",\"event_date\":\"2026-12-31\",\"quarters\":53,\"knowledge_estimated\":true,\"currency\":\"shares/USD\",\"split_ratio\":30.0,\"amount_per_share\":1125000000.0,\"is_subsequent_event\":true},\"nullCount\":{\"split_ratio\":391639,\"security_class\":5619,\"confidence\":0,\"event_date\":0,\"is_subsequent_event\":0,\"amount_per_share\":5619,\"action_type\":0,\"entity_id\":0,\"ingested_at\":0,\"currency\":5619,\"knowledge_estimated\":0,\"quarters\":5619,\"pit_event_id\":0,\"knowledge_date\":0}}","tags":null,"baseRowId":null,"defaultRowCommitVersion":null,"clusteringProvider":null}}

data/pit/corporate_actions.delta/part-00000-b78602dd-42f6-4e85-9422-9c3d727a372e-c000.snappy.parquet

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

data/pit/part-00000.parquet

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

data/splits/part-00000.parquet

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

jobs/run.py

@@ -0,0 +1,101 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#   "httpx>=0.27,<1",
+#   "polars>=1.24,<2",
+#   "pyarrow>=18,<21",
+#   "deltalake>=0.22,<2",
+#   "huggingface-hub>=1.19,<2",
+#   "pytest>=8,<9",
+#   "pytest-asyncio>=0.24,<1",
+#   "ruff>=0.11,<1",
+#   "pyyaml>=6,<7",
+# ]
+# ///
+"""Hugging Face Jobs entry point for the ZipLime corporate-actions dataset.
+
+    restore repository -> lint -> tests -> build -> verify -> publish
+
+The build reads two sibling datasets from the Hub. That is the point of this
+one: it is glue, and what it says has to be derivable from what the others
+published, not from a working copy that only exists on somebody's laptop.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+DEFAULT_REPO = "ZipLime/corporate-actions"
+DEFAULT_WORKSPACE = "/tmp/corporate-actions"
+
+
+def log(message: str) -> None:
+    print(f"[corporate-actions] {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("--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")
+    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
+
+    code = run([sys.executable, "-m", "recipe.cli", "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,187 @@
+{
+  "bundle_storage_class": "ziplime.data.services.file_system_delta_lake_bundle_storage.FileSystemDeltaLakeBundleStorage",
+  "bundle_storage_data": {
+    "table_uri": "data/pit/corporate_actions.delta"
+  },
+  "config_rows": {
+    "adjustment_factors": 9433,
+    "dividends": 391639,
+    "pit": 397258,
+    "splits": 5619
+  },
+  "config_schemas": {
+    "adjustment_factors": {
+      "cik": "String",
+      "confidence": "String",
+      "cumulative_split_factor": "Float64",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "splits_after": "Int32",
+      "valid_from": "Date",
+      "valid_to": "Date"
+    },
+    "dividends": {
+      "accepted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "accession_number": "String",
+      "amount_per_share": "Float64",
+      "cik": "String",
+      "currency": "String",
+      "filed_date": "Date",
+      "fiscal_period": "String",
+      "fiscal_year": "Int32",
+      "form": "String",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_subsequent_event": "Boolean",
+      "kind": "String",
+      "period_end": "Date",
+      "period_start": "Date",
+      "quarters": "Int32",
+      "revision": "Int32",
+      "security_class": "String"
+    },
+    "pit": {
+      "action_type": "String",
+      "amount_per_share": "Float64",
+      "confidence": "String",
+      "currency": "String",
+      "entity_id": "String",
+      "event_date": "Date",
+      "ingested_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_subsequent_event": "Boolean",
+      "knowledge_date": "Datetime(time_unit='us', time_zone='UTC')",
+      "knowledge_estimated": "Boolean",
+      "pit_event_id": "String",
+      "quarters": "Int32",
+      "security_class": "String",
+      "split_ratio": "Float64"
+    },
+    "splits": {
+      "cik": "String",
+      "confidence": "String",
+      "corroborated_by": "String",
+      "detected_after": "Datetime(time_unit='us', time_zone='UTC')",
+      "detected_before": "Datetime(time_unit='us', time_zone='UTC')",
+      "effective_period_end": "Date",
+      "evidence_observations": "Int32",
+      "inserted_at": "Datetime(time_unit='us', time_zone='UTC')",
+      "is_reverse": "Boolean",
+      "method": "String",
+      "ratio": "Float64",
+      "ratio_label": "String"
+    }
+  },
+  "configs": {
+    "adjustment_factors": {
+      "grain": "one span and the factor that puts an as-filed per-share figure on today's basis",
+      "path": "data/adjustment_factors/**/*.parquet"
+    },
+    "dividends": {
+      "grain": "one per-share dividend a filing stated for one period",
+      "path": "data/dividends/**/*.parquet"
+    },
+    "pit": {
+      "delta_path": "data/pit/corporate_actions.delta",
+      "grain": "one point-in-time corporate action event",
+      "path": "data/pit/**/*.parquet"
+    },
+    "splits": {
+      "grain": "one split, with the window it must have happened in",
+      "path": "data/splits/**/*.parquet"
+    }
+  },
+  "coverage": {
+    "max_event": "2026-12-31",
+    "max_knowledge": "2026-06-30T20:51:00+00:00",
+    "min_event": "2005-03-31",
+    "min_knowledge": "2009-04-15T20:44:00+00:00"
+  },
+  "data_type": "PIT_DATA",
+  "dataset": "corporate-actions",
+  "entity_domain": "us_equities",
+  "entity_id": "issuer_cik",
+  "event_date": "period_end for dividends, detection window end for splits",
+  "event_date_type": "date",
+  "frequency_seconds": null,
+  "generated_at": "2026-09-07T10:38:46.006778+00:00",
+  "knowledge_date": "accepted_at",
+  "knowledge_date_policy": {
+    "note": "A split's knowledge date is the earliest moment it was demonstrably public, which is later than it happened and therefore safe. No ex-date, record date or pay date exists in any free structured source.",
+    "primary": "EDGAR acceptance of the filing that stated the dividend, or of the first filing showing split-restated figures"
+  },
+  "knowledge_date_type": "timestamp[us, tz=UTC]",
+  "name": "corporate_actions",
+  "pit": {
+    "append_only": false,
+    "knowledge_lag_model": "sec_edgar_acceptance",
+    "restatement_policy": "dividends carry a revision per re-report; splits are rebuilt from the full restatement history each run"
+  },
+  "pretty_name": "ZipLime US Corporate Actions: dividends and splits (PIT)",
+  "quality_ok": true,
+  "rows": 397258,
+  "source": {
+    "build_version": "1.0.0",
+    "coverage_note": "Split detection requires XBRL restatement history, which begins in 2009 Q1. Dividend periods reach back to 2005 through comparative figures in early filings.",
+    "coverage_start": "2009-01-01",
+    "license": "US Government work — public domain",
+    "origin": "ZipLime/company-fundamentals (SEC Financial Statement Data Sets)",
+    "package_version": "1.0.0",
+    "recipe": "recipe/",
+    "recipe_hash": "sha256:f7aabfcffe4c240efda7e95e223e2602c3fe9cf292ee6a9fe17629eaf5fa92d8",
+    "schedule": "10 8 * * 1"
+  },
+  "split_ratios_recognised": [
+    "1:1000",
+    "1:750",
+    "1:500",
+    "1:400",
+    "1:300",
+    "1:250",
+    "1:200",
+    "1:150",
+    "1:120",
+    "1:100",
+    "1:80",
+    "1:75",
+    "1:60",
+    "1:50",
+    "1:40",
+    "1:35",
+    "1:30",
+    "1:25",
+    "1:20",
+    "1:16",
+    "1:15",
+    "1:12",
+    "1:10",
+    "1:8",
+    "1:7",
+    "1:6",
+    "1:5",
+    "1:4",
+    "1:3",
+    "1:2",
+    "5:4",
+    "4:3",
+    "3:2",
+    "5:3",
+    "7:4",
+    "9:5",
+    "2:1",
+    "5:2",
+    "3:1",
+    "7:2",
+    "4:1",
+    "5:1",
+    "6:1",
+    "7:1",
+    "8:1",
+    "9:1",
+    "10:1",
+    "12:1",
+    "15:1",
+    "20:1",
+    "25:1",
+    "30:1"
+  ],
+  "trading_calendar_name": null,
+  "version": "1.0.0"
+}

pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=75", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ziplime-corporate-actions"
+version = "1.0.0"
+description = "Point-in-time US corporate actions: dividends and stock splits"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "Apache-2.0"}
+authors = [{name = "ZipLime"}]
+dependencies = [
+  "httpx>=0.27,<1",
+  "polars>=1.24,<2",
+  "pyarrow>=18,<21",
+  "deltalake>=0.22,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8,<9",
+  "pytest-asyncio>=0.24,<1",
+  "ruff>=0.11,<1",
+  "pyyaml>=6,<7",
+]
+publish = ["huggingface-hub>=1.19,<2"]
+
+[project.scripts]
+ziplime-corporate-actions = "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 corporate actions: dividends per period and split ratios, point in time."""
+
+__version__ = "1.0.0"

recipe/build.py

@@ -0,0 +1,213 @@
+"""Read the fundamentals dataset, derive the actions, write the tables."""
+
+from __future__ import annotations
+
+import logging
+import shutil
+from datetime import UTC, datetime, time
+from pathlib import Path
+
+import polars as pl
+
+from .config import SIBLING_DIR, SOURCE_REPO, Settings
+from .dividends import build_dividends
+from .schema import ADJUSTMENT_SCHEMA, CONFIG_SCHEMAS, PIT_SCHEMA, align, empty_frame
+from .splits import combine, from_restatements, from_tags
+from .store import atomic_write_parquet
+
+LOGGER = logging.getLogger(__name__)
+
+PIT_DELTA_NAME = "corporate_actions.delta"
+MAX_ROWS_PER_FILE = 5_000_000
+
+
+def _source_files(settings: Settings, config: str, token: str | None) -> list[Path]:
+    if settings.siblings_dir is not None:
+        local = settings.siblings_dir / SIBLING_DIR / "data" / config
+        files = sorted(
+            path for path in local.rglob("*.parquet")
+            if not any(part.endswith(".delta") for part in path.parts)
+        )
+        if files:
+            return files
+    from huggingface_hub import snapshot_download
+
+    LOGGER.info("downloading %s/%s", SOURCE_REPO, config)
+    root = Path(
+        snapshot_download(
+            repo_id=SOURCE_REPO, repo_type="dataset",
+            allow_patterns=[f"data/{config}/**"], token=token,
+        )
+    )
+    return sorted(
+        path for path in (root / "data" / config).rglob("*.parquet")
+        if not any(part.endswith(".delta") for part in path.parts)
+    )
+
+
+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
+
+
+def build_adjustment_factors(splits: pl.DataFrame, *, horizon: datetime) -> pl.DataFrame:
+    """What to multiply an as-filed per-share figure by, to match today's prices.
+
+    This is the table that closes the hole. A filing states shares as of the
+    day it was made; every price series is adjusted for splits since. Multiply
+    one by the other and the answer is wrong by the split factor -- the failure
+    that turned a 6.9% earnings yield into 41.7% and a P/E of 1.8.
+
+    The factor is cumulative and stepwise: for a company that split two-for-one
+    in 2020 and three-for-one in 2024, a figure filed in 2019 needs six, one
+    filed in 2021 needs three, one filed today needs one.
+    """
+    if splits.is_empty():
+        return empty_frame(ADJUSTMENT_SCHEMA)
+
+    events = (
+        splits.filter(pl.col("detected_before").is_not_null())
+        .select("cik", "ratio", "confidence", pl.col("detected_before").dt.date().alias("on"))
+        .sort(["cik", "on"])
+    )
+    rows: list[dict] = []
+    horizon_day = horizon.date()
+    for cik, group in events.group_by("cik", maintain_order=True):
+        cik_value = cik[0] if isinstance(cik, tuple) else cik
+        days = group["on"].to_list()
+        ratios = group["ratio"].to_list()
+        confidences = group["confidence"].to_list()
+        # Walk backwards: the factor for a span is the product of every split
+        # that happened after it.
+        cumulative = 1.0
+        boundaries = [*days, horizon_day]
+        for index in range(len(days) - 1, -1, -1):
+            cumulative *= ratios[index]
+            rows.append({
+                "cik": cik_value,
+                "valid_from": None if index == 0 else boundaries[index - 1],
+                "valid_to": boundaries[index],
+                "cumulative_split_factor": cumulative,
+                "splits_after": len(days) - index,
+                "confidence": min(confidences[index:], key=lambda c: {"high": 0, "medium": 1}.get(c, 2)),
+            })
+        rows.append({
+            "cik": cik_value, "valid_from": boundaries[-2], "valid_to": None,
+            "cumulative_split_factor": 1.0, "splits_after": 0,
+            "confidence": "high",
+        })
+    frame = pl.DataFrame(rows, strict=False).with_columns(
+        pl.lit(datetime.now(UTC)).alias("inserted_at")
+    )
+    return align(frame, ADJUSTMENT_SCHEMA).sort(["cik", "valid_to"])
+
+
+def build_pit(dividends: pl.DataFrame, splits: pl.DataFrame, *, run_at: datetime) -> pl.DataFrame:
+    """Both action types in one point-in-time table.
+
+    A dividend's knowledge date is the acceptance of the filing that stated it,
+    to the second. A split's is the acceptance of the first filing that showed
+    the restated figures -- the earliest moment the split was demonstrably
+    public, which is later than it happened and therefore safe.
+    """
+    parts: list[pl.DataFrame] = []
+    if not dividends.is_empty():
+        parts.append(
+            dividends.with_columns(
+                pl.concat_str(
+                    [pl.col("accession_number"), pl.col("kind"), pl.col("security_class"),
+                     pl.col("period_end").cast(pl.String)], separator="|"
+                ).alias("pit_event_id"),
+                pl.col("cik").alias("entity_id"),
+                pl.col("period_end").alias("event_date"),
+                pl.col("accepted_at").alias("knowledge_date"),
+                pl.lit(False).alias("knowledge_estimated"),
+                pl.concat_str([pl.lit("dividend_"), pl.col("kind")]).alias("action_type"),
+                pl.lit(None, dtype=pl.Float64).alias("split_ratio"),
+                pl.lit("high").alias("confidence"),
+            )
+        )
+    if not splits.is_empty():
+        parts.append(
+            splits.with_columns(
+                pl.concat_str(
+                    [pl.col("cik"), pl.lit("split"), pl.col("ratio").cast(pl.String)],
+                    separator="|",
+                ).alias("pit_event_id"),
+                pl.col("cik").alias("entity_id"),
+                pl.col("detected_before").dt.date().alias("event_date"),
+                pl.col("detected_before").alias("knowledge_date"),
+                pl.lit(True).alias("knowledge_estimated"),
+                pl.lit("split").alias("action_type"),
+                pl.col("ratio").alias("split_ratio"),
+                pl.lit(None, dtype=pl.Float64).alias("amount_per_share"),
+                pl.lit(None, dtype=pl.String).alias("currency"),
+                pl.lit(None, dtype=pl.String).alias("security_class"),
+                pl.lit(None, dtype=pl.Int32).alias("quarters"),
+                pl.lit(False).alias("is_subsequent_event"),
+            )
+        )
+    if not parts:
+        return empty_frame(PIT_SCHEMA)
+    frame = pl.concat([align(part, PIT_SCHEMA) for part in parts], how="vertical_relaxed")
+    return frame.with_columns(pl.lit(run_at).alias("ingested_at")).sort(
+        ["entity_id", "event_date", "knowledge_date"]
+    )
+
+
+def run_build(*, settings: Settings, token: str | None = None) -> dict[str, int]:
+    data_dir = Path(settings.data_dir)
+    run_at = datetime.now(UTC)
+
+    facts = pl.scan_parquet(_source_files(settings, "facts", token))
+    dimensional = pl.scan_parquet(_source_files(settings, "facts_dimensional", token))
+    fundamentals = pl.scan_parquet(_source_files(settings, "fundamentals", token))
+
+    dividends = build_dividends(
+        pl.concat(
+            [facts.select(
+                "cik", "accession_number", "tag", "value", "unit", "period_end", "quarters",
+                "form", "fiscal_year", "fiscal_period", "filed_date", "accepted_at",
+             ).with_columns(pl.lit(None, dtype=pl.String).alias("segments")),
+             dimensional.select(
+                "cik", "accession_number", "tag", "value", "unit", "period_end", "quarters",
+                "form", "fiscal_year", "fiscal_period", "filed_date", "accepted_at", "segments",
+             )],
+            how="vertical_relaxed",
+        )
+    )
+    LOGGER.info("dividends: %d rows, %d filers", dividends.height, dividends["cik"].n_unique())
+
+    tagged = from_tags(pl.concat([facts, dimensional], how="diagonal_relaxed"))
+    inferred = from_restatements(fundamentals)
+    splits = combine(tagged, inferred)
+    LOGGER.info(
+        "splits: %d (tagged %d, inferred %d), %d filers",
+        splits.height, tagged.height, inferred.height, splits["cik"].n_unique(),
+    )
+
+    factors = build_adjustment_factors(splits, horizon=run_at)
+    pit = build_pit(dividends, splits, run_at=run_at)
+
+    counts = {
+        "dividends": _write(data_dir, "dividends", dividends),
+        "splits": _write(data_dir, "splits", splits),
+        "adjustment_factors": _write(data_dir, "adjustment_factors", factors),
+        "pit": _write(data_dir, "pit", pit),
+    }
+    delta = data_dir / "pit" / PIT_DELTA_NAME
+    if delta.exists():
+        shutil.rmtree(delta)
+    if not pit.is_empty():
+        align(pit, PIT_SCHEMA).write_delta(str(delta), mode="overwrite")
+    _ = time
+    return counts

recipe/cli.py

@@ -0,0 +1,74 @@
+"""Command line for the corporate actions recipe."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+from pathlib import Path
+
+from .build import run_build
+from .config import Settings
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="corporate-actions", description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("build", help="derive dividends, splits and adjustment factors")
+    verify = sub.add_parser("verify", help="run the quality gate and write the manifest")
+    verify.add_argument("--strict", action="store_true")
+    publish = sub.add_parser("publish", help="mirror the built tree to Hugging Face")
+    publish.add_argument("--repo", default=None)
+
+    args = parser.parse_args(argv)
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s | %(message)s"
+    )
+    settings = Settings.from_env()
+    data_dir = Path(settings.data_dir)
+
+    if args.command == "build":
+        from .manifest import build_manifest
+        from .quality import validate
+
+        counts = run_build(settings=settings)
+        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":
+        from .manifest import build_manifest
+        from .quality import validate
+        from .store import config_row_counts
+
+        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
+        from .quality import validate
+
+        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,32 @@
+"""Runtime configuration."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_HF_REPO = "ZipLime/corporate-actions"
+
+# Everything here is derived from one sibling dataset. No new source is
+# fetched: the dividends were already parsed out of XBRL, and the splits are
+# recovered from the restatement history that dataset keeps precisely because
+# it never overwrites what a filing said.
+SOURCE_REPO = "ZipLime/company-fundamentals"
+SIBLING_DIR = "Company_fundamentals"
+
+
+@dataclass(frozen=True, slots=True)
+class Settings:
+    data_dir: Path = Path("data")
+    hf_repo: str = DEFAULT_HF_REPO
+    siblings_dir: Path | None = None
+
+    @classmethod
+    def from_env(cls, **overrides) -> Settings:
+        siblings = os.environ.get("CORPORATE_ACTIONS_SIBLINGS")
+        return cls(
+            data_dir=Path(overrides.get("data_dir") or os.environ.get("DATA_DIR", "data")),
+            hf_repo=overrides.get("hf_repo") or os.environ.get("HF_DATASET_REPO", DEFAULT_HF_REPO),
+            siblings_dir=Path(siblings) if siblings else None,
+        )

recipe/dividends.py

@@ -0,0 +1,79 @@
+"""Dividends per share, as filings stated them.
+
+The tag zoo is smaller here than for the income statement but still real:
+`CommonStockDividendsPerShareDeclared` is what most filers use,
+`CommonStockDividendsPerShareCashPaid` is what the rest use, and the two mean
+different things -- declared is a decision, paid is a cash movement in the
+period. They are kept apart rather than coalesced.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import polars as pl
+
+from .schema import DIVIDEND_SCHEMA, align, empty_frame
+
+# tag -> (kind, security class). Preferred dividends are included because a
+# preferred coupon is a claim ahead of the common holder, and a yield computed
+# without it is wrong for exactly the companies where it matters.
+DIVIDEND_TAGS: dict[str, tuple[str, str]] = {
+    "CommonStockDividendsPerShareDeclared": ("declared", "common"),
+    "CommonStockDividendsPerShareCashPaid": ("cash_paid", "common"),
+    "PreferredStockDividendsPerShareDeclared": ("declared", "preferred"),
+    "PreferredStockDividendsPerShareCashPaid": ("cash_paid", "preferred"),
+    "DividendsPayableAmountPerShare": ("payable", "common"),
+    "CommonStockDividendsPerShareCashPaidNetOfTax": ("cash_paid", "common"),
+}
+
+# A filing may state a dividend declared after the period closed, tagged as a
+# subsequent event. It is forward-looking information -- the declaration is
+# already public when the filing is -- and dropping it would discard the one
+# dividend fact that is not history.
+SUBSEQUENT_EVENT = "SubsequentEvent"
+
+
+def build_dividends(facts: pl.LazyFrame | pl.DataFrame) -> pl.DataFrame:
+    """Every per-share dividend fact, consolidated and dimensional alike."""
+    lazy = facts.lazy() if isinstance(facts, pl.DataFrame) else facts
+    mapping = pl.DataFrame(
+        [
+            {"tag": tag, "kind": kind, "security_class": security}
+            for tag, (kind, security) in DIVIDEND_TAGS.items()
+        ]
+    ).lazy()
+
+    frame = (
+        lazy.filter(pl.col("value").is_not_null() & (pl.col("value") >= 0))
+        .join(mapping, on="tag", how="inner")
+        .with_columns(
+            pl.col("segments").fill_null("").str.contains(SUBSEQUENT_EVENT)
+            .alias("is_subsequent_event"),
+            pl.col("unit").alias("currency"),
+            pl.col("value").alias("amount_per_share"),
+        )
+        .collect()
+    )
+    if frame.is_empty():
+        return empty_frame(DIVIDEND_SCHEMA)
+
+    # The period a per-share dividend covers is a duration, and the fact's own
+    # `quarters` says how long. An instant-dated dividend per share is a filer
+    # error and is dropped rather than dated to a day it did not cover.
+    frame = frame.filter(pl.col("quarters") > 0).with_columns(
+        pl.col("period_end")
+        .dt.offset_by(pl.format("-{}mo", pl.col("quarters") * 3))
+        .alias("period_start")
+    )
+
+    frame = frame.sort(["cik", "kind", "security_class", "period_end", "quarters", "accepted_at"])
+    frame = frame.with_columns(
+        pl.col("accepted_at")
+        .rank("ordinal")
+        .over(["cik", "kind", "security_class", "period_end", "quarters"])
+        .cast(pl.Int32)
+        .alias("revision"),
+        pl.lit(datetime.now(UTC)).alias("inserted_at"),
+    )
+    return align(frame, DIVIDEND_SCHEMA)

recipe/hf_jobs.py

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

recipe/manifest.py

@@ -0,0 +1,119 @@
+"""The bundle descriptor, rebuilt from what is actually on disk."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import polars as pl
+
+from . import __version__
+from .build import PIT_DELTA_NAME
+from .schema import BUILD_VERSION, CONFIG_SCHEMAS
+from .store import read_table
+
+RECIPE_ROOT = Path(__file__).resolve().parent.parent
+
+CONFIG_DESCRIPTIONS: dict[str, dict[str, str]] = {
+    "dividends": {
+        "path": "data/dividends/**/*.parquet",
+        "grain": "one per-share dividend a filing stated for one period",
+    },
+    "splits": {
+        "path": "data/splits/**/*.parquet",
+        "grain": "one split, with the window it must have happened in",
+    },
+    "adjustment_factors": {
+        "path": "data/adjustment_factors/**/*.parquet",
+        "grain": "one span and the factor that puts an as-filed per-share figure on today's basis",
+    },
+    "pit": {
+        "path": "data/pit/**/*.parquet",
+        "delta_path": f"data/pit/{PIT_DELTA_NAME}",
+        "grain": "one point-in-time corporate action event",
+    },
+}
+
+
+def recipe_hash(project_root: Path | None = None) -> str:
+    """Hash of the code that produced a build.
+
+    The root defaults to the installed recipe rather than being derived from
+    `data_dir`: a run writing elsewhere would otherwise hash an empty file set,
+    which reads as a valid hash and proves nothing.
+    """
+    root = (project_root or RECIPE_ROOT).resolve()
+    digest = hashlib.sha256()
+    files = sorted(
+        {
+            path
+            for pattern in ("recipe/**/*.py", "jobs/**/*.py", "tests/**/*.py", "pyproject.toml")
+            for path in root.glob(pattern)
+            if path.is_file()
+        }
+    )
+    if not files:
+        raise FileNotFoundError(f"no recipe sources under {root}")
+    for path in files:
+        digest.update(str(path.relative_to(root)).encode())
+        digest.update(b"\0")
+        digest.update(path.read_bytes())
+        digest.update(b"\0")
+    return f"sha256:{digest.hexdigest()}"
+
+
+def _coverage(data_dir: Path) -> dict[str, str | None]:
+    bounds = read_table(data_dir, "pit").select(
+        pl.col("event_date").min().alias("min_event"),
+        pl.col("event_date").max().alias("max_event"),
+        pl.col("knowledge_date").min().alias("min_knowledge"),
+        pl.col("knowledge_date").max().alias("max_knowledge"),
+    ).collect()
+    if bounds.is_empty():
+        return {}
+    row = bounds.row(0, named=True)
+    return {k: (v.isoformat() if v is not None else None) for k, v in row.items()}
+
+
+def build_manifest(*, data_dir: Path, row_counts: dict[str, int], quality_ok: bool) -> dict[str, Any]:
+    data_dir = Path(data_dir)
+    project_root = data_dir.resolve().parent
+    path = project_root / "manifest.json"
+    manifest: dict[str, Any] = json.loads(path.read_text()) if path.exists() else {}
+
+    manifest["generated_at"] = datetime.now(UTC).isoformat()
+    manifest["rows"] = row_counts.get("pit", 0)
+    manifest["config_rows"] = row_counts
+    manifest["configs"] = CONFIG_DESCRIPTIONS
+    manifest["coverage"] = _coverage(data_dir)
+    manifest["quality_ok"] = quality_ok
+    from .splits import KNOWN_RATIOS
+
+    manifest["split_ratios_recognised"] = [label for _ratio, label in KNOWN_RATIOS]
+    manifest["config_schemas"] = {
+        name: {column: str(dtype) for column, dtype in schema.items()}
+        for name, schema in CONFIG_SCHEMAS.items()
+    }
+    source = dict(manifest.get("source") or {})
+    source["recipe_hash"] = recipe_hash()
+    source["build_version"] = BUILD_VERSION
+    source["package_version"] = __version__
+    manifest["source"] = source
+
+    descriptor, temporary = tempfile.mkstemp(prefix=".manifest-", suffix=".json", dir=project_root)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+            json.dump(manifest, handle, indent=2, sort_keys=True, ensure_ascii=False)
+            handle.write("\n")
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+    return manifest

recipe/publish.py

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

recipe/quality.py

@@ -0,0 +1,162 @@
+"""Checks that decide whether a build may be published.
+
+Splits are the risky half. A wrong ratio does not raise -- it rescales a
+company's whole per-share history by a factor of two and the result still looks
+like a price series. So the checks are about the ratios being declared ones,
+the factors composing consistently, and the inferred set not drifting away from
+the tagged set that validates it.
+"""
+
+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 .splits import KNOWN_RATIOS
+from .store import read_table
+
+MIN_DIVIDEND_FILERS = 2_000
+MIN_SPLIT_FILERS = 800
+# The inferred method agreed with the tagged ratio for 79% of the companies
+# where both exist. The floor sits below that: a drop means the restatement
+# signal has started picking up something that is not a split.
+MIN_METHOD_AGREEMENT = 0.65
+
+
+@dataclass
+class QualityReport:
+    errors: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    metrics: dict[str, Any] = field(default_factory=dict)
+
+    def error(self, message: str) -> None:
+        self.errors.append(message)
+
+    def warn(self, message: str) -> None:
+        self.warnings.append(message)
+
+    def metric(self, name: str, value: Any) -> None:
+        self.metrics[name] = value
+
+    @property
+    def ok(self) -> bool:
+        return not self.errors
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "ok": self.ok,
+            "generated_at": datetime.now(UTC).isoformat(),
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "metrics": self.metrics,
+        }
+
+    def write(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(self.as_dict(), indent=2, default=str), encoding="utf-8")
+
+
+def validate(data_dir: Path) -> QualityReport:
+    report = QualityReport()
+    data_dir = Path(data_dir)
+    dividends = read_table(data_dir, "dividends").collect()
+    splits = read_table(data_dir, "splits").collect()
+    factors = read_table(data_dir, "adjustment_factors").collect()
+    pit = read_table(data_dir, "pit").collect()
+
+    for name, frame in (("dividends", dividends), ("splits", splits),
+                        ("adjustment_factors", factors), ("pit", pit)):
+        report.metric(f"rows_{name}", frame.height)
+
+    if dividends.is_empty():
+        report.error("dividends table is empty")
+        return report
+
+    filers = dividends["cik"].n_unique()
+    report.metric("dividend_filers", filers)
+    if filers < MIN_DIVIDEND_FILERS:
+        report.error(f"only {filers} filers pay dividends, below the {MIN_DIVIDEND_FILERS} floor")
+    negative = dividends.filter(pl.col("amount_per_share") < 0).height
+    if negative:
+        report.error(f"dividends: {negative} negative amounts per share")
+    report.metric(
+        "dividends_by_kind",
+        {r["kind"]: r["n"] for r in dividends.group_by("kind").agg(pl.len().alias("n")).iter_rows(named=True)},
+    )
+    report.metric(
+        "dividend_subsequent_events",
+        dividends.filter(pl.col("is_subsequent_event")).height,
+    )
+    restated = dividends.filter(pl.col("revision") > 1).height
+    report.metric("dividend_restated_rows", restated)
+
+    if splits.is_empty():
+        report.error("splits table is empty")
+        return report
+
+    split_filers = splits["cik"].n_unique()
+    report.metric("split_filers", split_filers)
+    report.metric(
+        "splits_by_method",
+        {r["method"]: r["n"] for r in splits.group_by("method").agg(pl.len().alias("n")).iter_rows(named=True)},
+    )
+    report.metric(
+        "splits_by_confidence",
+        {r["confidence"]: r["n"] for r in splits.group_by("confidence").agg(pl.len().alias("n")).iter_rows(named=True)},
+    )
+    if split_filers < MIN_SPLIT_FILERS:
+        report.error(f"only {split_filers} filers have a split, below the {MIN_SPLIT_FILERS} floor")
+
+    # Every published ratio has to be one companies actually declare. A ratio of
+    # 1.83 is a restatement that slipped through, not a split.
+    allowed = [ratio for ratio, _label in KNOWN_RATIOS]
+    stray = splits.filter(~pl.col("ratio").is_in(allowed)).height
+    if stray:
+        report.error(f"splits: {stray} rows carry a ratio that is not a declared one")
+    if splits.filter(pl.col("detected_before") < pl.col("detected_after")).height:
+        report.error("splits: detection windows that end before they start")
+
+    # Agreement is measured over the events strong enough to be relied on. The
+    # low-confidence tail is published for completeness, not for gating.
+    strong = splits.filter(pl.col("confidence").is_in(["high", "medium"]))
+    both = strong.filter(pl.col("corroborated_by") == "xbrl_tag+eps_restatement")["cik"].n_unique()
+    tagged_filers = strong.filter(pl.col("method") == "xbrl_tag")["cik"].n_unique()
+    if tagged_filers:
+        agreement = both / tagged_filers
+        report.metric("method_agreement", round(agreement, 4))
+        if agreement < MIN_METHOD_AGREEMENT:
+            report.error(
+                f"the inferred and tagged methods agree for {agreement:.1%} of tagged filers, "
+                f"below the {MIN_METHOD_AGREEMENT:.0%} floor"
+            )
+
+    if not factors.is_empty():
+        report.metric("factor_filers", factors["cik"].n_unique())
+        if factors.filter(pl.col("cumulative_split_factor") <= 0).height:
+            report.error("adjustment_factors: non-positive factor")
+        # The newest span of every filer is the present, where nothing needs
+        # adjusting. A factor other than one there means the walk backwards
+        # started from the wrong end.
+        latest = factors.filter(pl.col("valid_to").is_null())
+        wrong = latest.filter(pl.col("cumulative_split_factor") != 1.0).height
+        if wrong:
+            report.error(f"adjustment_factors: {wrong} filers whose current factor is not 1.0")
+        report.metric("factor_max", float(factors["cumulative_split_factor"].max()))
+
+    if not pit.is_empty():
+        for column in ("entity_id", "event_date", "knowledge_date"):
+            if pit[column].null_count():
+                report.error(f"pit.{column}: {pit[column].null_count()} nulls")
+        report.metric(
+            "pit_by_action",
+            {r["action_type"]: r["n"] for r in pit.group_by("action_type").agg(pl.len().alias("n")).iter_rows(named=True)},
+        )
+    return report
+
+
+__all__ = ["QualityReport", "validate"]

recipe/schema.py

@@ -0,0 +1,109 @@
+"""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 dividend as a filing stated it: an amount per share for a fiscal period.
+#
+# Not an event with an ex-date. SEC's structured data carries no dividend dates
+# at all -- the date-typed XBRL facts exist in filings but `num.txt` holds only
+# numeric ones, and the XBRL API returns 404 for them. What is here is what can
+# be had: how much per share, over which period, known from when.
+DIVIDEND_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "accession_number": pl.String,
+    "kind": pl.String,
+    "security_class": pl.String,
+    "period_start": pl.Date,
+    "period_end": pl.Date,
+    "quarters": pl.Int32,
+    "amount_per_share": pl.Float64,
+    "currency": pl.String,
+    "is_subsequent_event": pl.Boolean,
+    "form": pl.String,
+    "fiscal_year": pl.Int32,
+    "fiscal_period": pl.String,
+    "filed_date": pl.Date,
+    "accepted_at": UTC_DATETIME,
+    "revision": pl.Int32,
+    "inserted_at": UTC_DATETIME,
+}
+
+# One split, and the window it must have happened in.
+#
+# A split has no date here either, and saying otherwise would be invention. It
+# is detected by the trace it leaves: a filing restates an earlier period's per
+# share figures by the split ratio, so the split falls between the filing that
+# still used the old numbers and the one that used the new.
+SPLIT_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "ratio": pl.Float64,
+    "ratio_label": pl.String,
+    "is_reverse": pl.Boolean,
+    "detected_after": UTC_DATETIME,
+    "detected_before": UTC_DATETIME,
+    "effective_period_end": pl.Date,
+    "method": pl.String,
+    "confidence": pl.String,
+    "corroborated_by": pl.String,
+    "evidence_observations": pl.Int32,
+    "inserted_at": UTC_DATETIME,
+}
+
+# The number a user actually needs: multiply an as-filed per-share figure by
+# this to put it on the same footing as a split-adjusted price series.
+ADJUSTMENT_SCHEMA: dict[str, pl.DataType] = {
+    "cik": pl.String,
+    "valid_from": pl.Date,
+    "valid_to": pl.Date,
+    "cumulative_split_factor": pl.Float64,
+    "splits_after": pl.Int32,
+    "confidence": pl.String,
+    "inserted_at": UTC_DATETIME,
+}
+
+PIT_SCHEMA: dict[str, pl.DataType] = {
+    "pit_event_id": pl.String,
+    "entity_id": pl.String,
+    "event_date": pl.Date,
+    "knowledge_date": UTC_DATETIME,
+    "knowledge_estimated": pl.Boolean,
+    "action_type": pl.String,
+    "amount_per_share": pl.Float64,
+    "currency": pl.String,
+    "split_ratio": pl.Float64,
+    "security_class": pl.String,
+    "quarters": pl.Int32,
+    "is_subsequent_event": pl.Boolean,
+    "confidence": pl.String,
+    "ingested_at": UTC_DATETIME,
+}
+
+CONFIG_SCHEMAS: dict[str, dict[str, pl.DataType]] = {
+    "dividends": DIVIDEND_SCHEMA,
+    "splits": SPLIT_SCHEMA,
+    "adjustment_factors": ADJUSTMENT_SCHEMA,
+    "pit": PIT_SCHEMA,
+}
+
+
+def empty_frame(schema: Mapping[str, pl.DataType]) -> pl.DataFrame:
+    return pl.DataFrame(schema=dict(schema))
+
+
+def align(frame: pl.DataFrame, schema: Mapping[str, pl.DataType]) -> pl.DataFrame:
+    missing = [
+        pl.lit(None, dtype=dtype).alias(name)
+        for name, dtype in schema.items()
+        if name not in frame.columns
+    ]
+    if missing:
+        frame = frame.with_columns(missing)
+    return frame.select([pl.col(n).cast(d, strict=False) for n, d in schema.items()])

recipe/splits.py

@@ -0,0 +1,305 @@
+"""Finding splits in the trace they leave behind.
+
+There is no free structured feed of US stock splits. What there is, in a
+dataset that keeps every filing's own version of a period, is the trace: a
+split forces a company to restate every earlier per-share figure by the split
+ratio. Two filings covering the same quarter, one before the split and one
+after, differ by exactly that factor.
+
+That is a stronger signal than the obvious one. A jump in shares outstanding
+looks the same for a two-for-one split and for an equity raise that doubled the
+count; only a split reaches back and rewrites the past.
+
+Three methods are combined, each labelled:
+
+    xbrl_tag          the filer tagged the conversion ratio itself
+    eps_restatement   an earlier period's EPS was restated by a clean ratio
+    share_count       shares outstanding jumped by a clean ratio
+
+`xbrl_tag` is authority. `eps_restatement` covers three times as many companies
+and agrees with the tagged ratio for 79% of the firms where both exist.
+`share_count` is never used alone -- it cannot tell a split from an issuance --
+only to corroborate.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+
+import polars as pl
+
+from .schema import SPLIT_SCHEMA, align, empty_frame
+
+LOGGER = logging.getLogger(__name__)
+
+# Ratios a split is actually declared in.
+#
+# Written out rather than generated. The first version of this list was also
+# written out and omitted six-for-one, which made Deckers' 2024 split invisible
+# -- the evidence was there, the ratio was not in the table. The fix was to
+# complete the list, not to accept any simple fraction: generating them gave a
+# hundred and forty ratios, and an ordinary 1.83x restatement then resolved to
+# "eleven-for-six".
+#
+# Nothing between 0.85 and 1.18 is admitted at all. A five percent stock
+# dividend and a five percent restatement leave the same trace, and calling one
+# the other would put a phantom split into the adjustment factors.
+FORWARD_RATIOS: tuple[tuple[float, str], ...] = (
+    (1.25, "5:4"), (4 / 3, "4:3"), (1.5, "3:2"), (5 / 3, "5:3"), (1.75, "7:4"),
+    (1.8, "9:5"), (2.0, "2:1"), (2.5, "5:2"), (3.0, "3:1"), (3.5, "7:2"),
+    (4.0, "4:1"), (5.0, "5:1"), (6.0, "6:1"), (7.0, "7:1"), (8.0, "8:1"),
+    (9.0, "9:1"), (10.0, "10:1"), (12.0, "12:1"), (15.0, "15:1"), (20.0, "20:1"),
+    (25.0, "25:1"), (30.0, "30:1"),
+)
+# Reverse splits run to much larger denominators: a shell consolidating
+# one-for-a-thousand to regain a listing is routine.
+REVERSE_DENOMINATORS: tuple[int, ...] = (
+    2, 3, 4, 5, 6, 7, 8, 10, 12, 15, 16, 20, 25, 30, 35, 40, 50, 60, 75, 80,
+    100, 120, 150, 200, 250, 300, 400, 500, 750, 1000,
+)
+
+KNOWN_RATIOS: tuple[tuple[float, str], ...] = tuple(
+    sorted(
+        {
+            **{round(1 / denominator, 10): f"1:{denominator}" for denominator in REVERSE_DENOMINATORS},
+            **{round(ratio, 10): label for ratio, label in FORWARD_RATIOS},
+        }.items()
+    )
+)
+
+# Tight enough that no two admitted ratios can claim the same measurement.
+RATIO_TOLERANCE = 0.01
+
+# One restated figure is not evidence: a single period whose EPS happens to land
+# on a clean ratio after a correction produced a four-for-one Tesla split in
+# 2020 that never happened. Two is the floor for publishing at all.
+#
+# Above the floor the count grades the claim instead of gating it. A real split
+# restates every prior period a filing shows -- Apple's 2020 split left 36 of
+# them -- so a handful is weaker evidence than a pile, and the reader should be
+# told which they have rather than have the thin cases silently removed.
+MIN_RESTATEMENT_EVIDENCE = 2
+STRONG_RESTATEMENT_EVIDENCE = 4
+
+# An extreme ratio is where a tiny denominator does the most damage: earnings of
+# minus two cents restated to minus forty dollars is a genuine one-for-a-
+# thousand consolidation, and so is a rounding change on a company whose EPS
+# never left the third decimal. Shells really do consolidate at these ratios --
+# 4 305 of the reverse splits found here are theirs -- so the answer is not to
+# refuse them but to demand the corroboration that separates the two.
+EXTREME_RATIO_HIGH = 50.0
+EXTREME_RATIO_LOW = 0.02
+
+SPLIT_RATIO_TAGS = (
+    "StockholdersEquityNoteStockSplitConversionRatio1",
+    "StockholdersEquityNoteStockSplitConversionRatio",
+    "StockholdersEquityNoteStockSplitConversionRatio2",
+)
+
+
+def snap_ratio(value: float | None) -> tuple[float, str] | None:
+    """The declared ratio a measurement corresponds to, or nothing."""
+    if value is None or value <= 0:
+        return None
+    for ratio, label in KNOWN_RATIOS:
+        if abs(value - ratio) <= RATIO_TOLERANCE * ratio:
+            return ratio, label
+    return None
+
+
+def _snapped(column: str) -> pl.Expr:
+    expr = pl.when(pl.lit(False)).then(pl.lit(None, dtype=pl.Float64))
+    for ratio, _label in KNOWN_RATIOS:
+        tolerance = RATIO_TOLERANCE * ratio
+        expr = expr.when(
+            (pl.col(column) > ratio - tolerance) & (pl.col(column) < ratio + tolerance)
+        ).then(pl.lit(ratio))
+    return expr.otherwise(pl.lit(None, dtype=pl.Float64))
+
+
+def _label() -> pl.Expr:
+    expr = pl.when(pl.lit(False)).then(pl.lit(None, dtype=pl.String))
+    for ratio, label in KNOWN_RATIOS:
+        expr = expr.when(pl.col("ratio") == ratio).then(pl.lit(label))
+    return expr.otherwise(pl.lit(None, dtype=pl.String))
+
+
+def from_restatements(fundamentals: pl.LazyFrame | pl.DataFrame) -> pl.DataFrame:
+    """Splits inferred from per-share figures being restated.
+
+    Both EPS and the weighted share count are used, and they move in opposite
+    directions: after a two-for-one split the restated EPS is half of what was
+    first reported, and the restated share count is double. Taking the ratio in
+    the direction that yields the split factor for each keeps the two
+    comparable.
+    """
+    lazy = fundamentals.lazy() if isinstance(fundamentals, pl.DataFrame) else fundamentals
+    per_share = ["eps_diluted", "eps_basic"]
+    counts = ["shares_diluted_weighted", "shares_basic_weighted"]
+
+    frame = (
+        lazy.filter(pl.col("concept").is_in([*per_share, *counts]))
+        .filter(pl.col("value").is_not_null() & (pl.col("value").abs() > 0.01))
+        .collect()
+    )
+    if frame.is_empty():
+        return empty_frame(SPLIT_SCHEMA)
+
+    grouped = (
+        frame.sort("accepted_at")
+        .group_by(["cik", "concept", "period_end", "quarters"])
+        .agg(
+            pl.col("value").first().alias("first_value"),
+            pl.col("value").last().alias("last_value"),
+            pl.col("accepted_at").first().alias("detected_after"),
+            pl.col("accepted_at").last().alias("detected_before"),
+            pl.len().alias("reports"),
+        )
+        .filter(pl.col("reports") > 1)
+    )
+    grouped = grouped.with_columns(
+        pl.when(pl.col("concept").is_in(per_share))
+        .then(pl.col("first_value") / pl.col("last_value"))
+        .otherwise(pl.col("last_value") / pl.col("first_value"))
+        .alias("measured")
+    )
+    grouped = grouped.with_columns(_snapped("measured").alias("ratio")).filter(
+        pl.col("ratio").is_not_null()
+    )
+    if grouped.is_empty():
+        return empty_frame(SPLIT_SCHEMA)
+
+    # Every period the company restated by the same factor is evidence of one
+    # split, not of many, so the windows are combined.
+    #
+    # The tight combination is the intersection: the split happened after the
+    # last filing that still used the old numbers and before the first that
+    # used the new. That intersection can be empty, and when it is, it is not
+    # an arithmetic slip -- it means the evidence spans more than one event at
+    # the same ratio, a company that split two-for-one twice. Falling back to
+    # the union keeps a window that certainly contains them, instead of
+    # publishing one that ends before it starts.
+    events = (
+        grouped.group_by(["cik", "ratio"])
+        .agg(
+            pl.col("detected_after").max().alias("tight_after"),
+            pl.col("detected_before").min().alias("tight_before"),
+            pl.col("detected_after").min().alias("wide_after"),
+            pl.col("detected_before").max().alias("wide_before"),
+            pl.col("period_end").max().alias("effective_period_end"),
+            pl.len().cast(pl.Int32).alias("evidence_observations"),
+            pl.col("concept").unique().sort().str.join("|").alias("corroborated_by"),
+        )
+        .with_columns(
+            pl.lit("eps_restatement").alias("method"),
+            _label().alias("ratio_label"),
+            (pl.col("ratio") < 1).alias("is_reverse"),
+        )
+        .with_columns(
+            (pl.col("tight_after") <= pl.col("tight_before")).alias("_tight"),
+        )
+        .with_columns(
+            pl.when(pl.col("_tight"))
+            .then(pl.col("tight_after"))
+            .otherwise(pl.col("wide_after"))
+            .alias("detected_after"),
+            pl.when(pl.col("_tight"))
+            .then(pl.col("tight_before"))
+            .otherwise(pl.col("wide_before"))
+            .alias("detected_before"),
+        )
+    )
+    enough = pl.when(
+        (pl.col("ratio") >= EXTREME_RATIO_HIGH) | (pl.col("ratio") <= EXTREME_RATIO_LOW)
+    ).then(pl.lit(STRONG_RESTATEMENT_EVIDENCE)).otherwise(pl.lit(MIN_RESTATEMENT_EVIDENCE))
+    return align(events.filter(pl.col("evidence_observations") >= enough), SPLIT_SCHEMA)
+
+
+def from_tags(facts: pl.LazyFrame | pl.DataFrame) -> pl.DataFrame:
+    """Splits the filer tagged with a conversion ratio."""
+    lazy = facts.lazy() if isinstance(facts, pl.DataFrame) else facts
+    frame = (
+        lazy.filter(pl.col("tag").is_in(SPLIT_RATIO_TAGS))
+        .filter(pl.col("value").is_not_null() & (pl.col("value") > 0) & (pl.col("value") < 200))
+        .select("cik", "value", "period_end", "accepted_at")
+        .collect()
+    )
+    if frame.is_empty():
+        return empty_frame(SPLIT_SCHEMA)
+
+    # A filer may write a three-for-two split as 1.5 or as its reciprocal.
+    # Both readings are snapped and whichever lands on a declared ratio wins.
+    frame = frame.with_columns(
+        pl.coalesce([_snapped("value"), _snapped_reciprocal()]).alias("ratio")
+    ).filter(pl.col("ratio").is_not_null())
+    if frame.is_empty():
+        return empty_frame(SPLIT_SCHEMA)
+
+    events = (
+        frame.group_by(["cik", "ratio"])
+        .agg(
+            pl.col("accepted_at").min().alias("detected_after"),
+            pl.col("accepted_at").min().alias("detected_before"),
+            pl.col("period_end").max().alias("effective_period_end"),
+            pl.len().cast(pl.Int32).alias("evidence_observations"),
+        )
+        .with_columns(
+            pl.lit("xbrl_tag").alias("method"),
+            pl.lit("tagged_ratio").alias("corroborated_by"),
+            _label().alias("ratio_label"),
+            (pl.col("ratio") < 1).alias("is_reverse"),
+        )
+    )
+    return align(events, SPLIT_SCHEMA)
+
+
+def _snapped_reciprocal() -> pl.Expr:
+    expr = pl.when(pl.lit(False)).then(pl.lit(None, dtype=pl.Float64))
+    for ratio, _label in KNOWN_RATIOS:
+        tolerance = RATIO_TOLERANCE * ratio
+        expr = expr.when(
+            (1 / pl.col("value") > ratio - tolerance) & (1 / pl.col("value") < ratio + tolerance)
+        ).then(pl.lit(ratio))
+    return expr.otherwise(pl.lit(None, dtype=pl.Float64))
+
+
+def combine(tagged: pl.DataFrame, inferred: pl.DataFrame) -> pl.DataFrame:
+    """One row per split, with the strongest method that found it.
+
+    A split found both ways is one split with high confidence, not two rows.
+    A split found only by restatement keeps the medium label: it agreed with
+    the tagged ratio for 79% of the companies where both exist, which is worth
+    publishing and not worth calling certain.
+    """
+    if tagged.is_empty() and inferred.is_empty():
+        return empty_frame(SPLIT_SCHEMA)
+    both = pl.concat([tagged, inferred], how="vertical_relaxed")
+    ranked = (
+        both.with_columns(
+            pl.col("method").replace_strict({"xbrl_tag": 0, "eps_restatement": 1}, default=2)
+            .alias("_rank")
+        )
+        .sort(["cik", "ratio", "_rank"])
+        .group_by(["cik", "ratio"], maintain_order=True)
+        .agg(
+            pl.all().exclude("_rank").first(),
+            pl.col("method").n_unique().alias("_methods"),
+        )
+    )
+    ranked = ranked.with_columns(
+        pl.when(pl.col("_methods") > 1)
+        .then(pl.lit("high"))
+        .when(pl.col("method") == "xbrl_tag")
+        .then(pl.lit("high"))
+        .when(pl.col("evidence_observations") >= STRONG_RESTATEMENT_EVIDENCE)
+        .then(pl.lit("medium"))
+        .otherwise(pl.lit("low"))
+        .alias("confidence"),
+        pl.when(pl.col("_methods") > 1)
+        .then(pl.lit("xbrl_tag+eps_restatement"))
+        .otherwise(pl.col("corroborated_by"))
+        .alias("corroborated_by"),
+        pl.lit(datetime.now(UTC)).alias("inserted_at"),
+    )
+    return align(ranked, SPLIT_SCHEMA).sort(["cik", "detected_before"])

recipe/store.py

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

tests/conftest.py

@@ -0,0 +1,62 @@
+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 _eps(cik, period_end, quarters, value, accepted, concept="eps_diluted"):
+    return {"cik": cik, "concept": concept, "period_end": period_end, "quarters": quarters,
+            "value": value, "accepted_at": accepted, "accession_number": f"acc-{accepted:%Y%m%d}"}
+
+
+@pytest.fixture
+def fundamentals() -> pl.DataFrame:
+    """A four-for-one split: every prior period's EPS is restated to a quarter."""
+    before = datetime(2020, 5, 1, tzinfo=UTC)
+    after = datetime(2020, 11, 1, tzinfo=UTC)
+    rows = []
+    for index, period in enumerate(
+        [date(2018, 12, 31), date(2019, 3, 31), date(2019, 6, 30), date(2019, 9, 30),
+         date(2019, 12, 31)]
+    ):
+        rows.append(_eps("0000000001", period, 4 if index in (0, 4) else 1, 4.0, before))
+        rows.append(_eps("0000000001", period, 4 if index in (0, 4) else 1, 1.0, after))
+    # A company whose EPS was merely corrected, by a ratio no split is declared in.
+    rows.append(_eps("0000000002", date(2019, 12, 31), 4, 1.83, before))
+    rows.append(_eps("0000000002", date(2019, 12, 31), 4, 1.0, after))
+    # A single restated period at a clean ratio: too thin to publish.
+    rows.append(_eps("0000000003", date(2019, 12, 31), 4, 2.0, before))
+    rows.append(_eps("0000000003", date(2019, 12, 31), 4, 1.0, after))
+    return pl.DataFrame(rows, strict=False)
+
+
+@pytest.fixture
+def facts() -> pl.DataFrame:
+    """Dividend facts and one tagged split ratio."""
+    rows = [
+        {"cik": "0000000001", "accession_number": "acc-1", "tag": "CommonStockDividendsPerShareDeclared",
+         "value": 0.25, "unit": "USD", "period_end": date(2020, 3, 31), "quarters": 1,
+         "form": "10-Q", "fiscal_year": 2020, "fiscal_period": "Q1",
+         "filed_date": date(2020, 5, 1), "accepted_at": datetime(2020, 5, 1, tzinfo=UTC),
+         "segments": None},
+        {"cik": "0000000001", "accession_number": "acc-2", "tag": "CommonStockDividendsPerShareDeclared",
+         "value": 0.30, "unit": "USD", "period_end": date(2020, 6, 30), "quarters": 1,
+         "form": "10-Q", "fiscal_year": 2020, "fiscal_period": "Q2",
+         "filed_date": date(2020, 8, 1), "accepted_at": datetime(2020, 8, 1, tzinfo=UTC),
+         "segments": "SubsequentEventType=SubsequentEvent;"},
+        {"cik": "0000000004", "accession_number": "acc-3",
+         "tag": "StockholdersEquityNoteStockSplitConversionRatio1",
+         "value": 6.0, "unit": "pure", "period_end": date(2024, 9, 30), "quarters": 0,
+         "form": "10-Q", "fiscal_year": 2024, "fiscal_period": "Q3",
+         "filed_date": date(2024, 10, 31), "accepted_at": datetime(2024, 10, 31, tzinfo=UTC),
+         "segments": None},
+    ]
+    return pl.DataFrame(rows, strict=False)

tests/test_corporate_actions.py

@@ -0,0 +1,133 @@
+"""Dividends, split detection, and the factor that reconciles filings to prices."""
+
+from __future__ import annotations
+
+from datetime import UTC, date, datetime
+from itertools import pairwise
+
+import polars as pl
+import pytest
+
+from recipe.build import build_adjustment_factors, build_pit
+from recipe.dividends import build_dividends
+from recipe.splits import (
+    KNOWN_RATIOS,
+    RATIO_TOLERANCE,
+    combine,
+    from_restatements,
+    from_tags,
+    snap_ratio,
+)
+
+
+def test_no_two_ratios_can_claim_one_measurement():
+    """Bands must not touch, or a measurement resolves to whichever is listed first."""
+    ratios = [ratio for ratio, _label in KNOWN_RATIOS]
+    touching = [
+        (low, high)
+        for low, high in pairwise(ratios)
+        if high - low <= RATIO_TOLERANCE * (low + high)
+    ]
+    assert not touching, touching
+
+
+@pytest.mark.parametrize(
+    ("measured", "expected"),
+    [
+        (6.0, "6:1"), (5.97, "6:1"), (2.0, "2:1"), (1.5, "3:2"), (0.1, "1:10"),
+        (0.001, "1:1000"),
+        # A five percent stock dividend and a five percent restatement leave the
+        # same trace, so nothing near one is admitted.
+        (1.05, None), (0.96, None),
+        # An ordinary restatement that lands on no declared ratio.
+        (1.83, None), (2.31, None),
+    ],
+)
+def test_only_declared_ratios_are_recognised(measured, expected):
+    got = snap_ratio(measured)
+    assert (got[1] if got else None) == expected
+
+
+def test_six_for_one_is_recognised():
+    """Deckers' 2024 split was invisible because 6:1 was missing from the list."""
+    assert snap_ratio(6.0) == (6.0, "6:1")
+
+
+def test_a_split_is_found_in_the_restated_periods(fundamentals):
+    splits = from_restatements(fundamentals)
+    row = splits.filter(pl.col("cik") == "0000000001").row(0, named=True)
+    assert row["ratio"] == 4.0 and row["ratio_label"] == "4:1"
+    assert row["method"] == "eps_restatement"
+    assert row["evidence_observations"] == 5
+    assert row["detected_after"] <= row["detected_before"]
+
+
+def test_an_ordinary_restatement_is_not_a_split(fundamentals):
+    splits = from_restatements(fundamentals)
+    assert splits.filter(pl.col("cik") == "0000000002").is_empty()
+
+
+def test_one_restated_period_is_too_thin(fundamentals):
+    splits = from_restatements(fundamentals)
+    assert splits.filter(pl.col("cik") == "0000000003").is_empty()
+
+
+def test_a_tagged_ratio_outranks_an_inferred_one(fundamentals, facts):
+    combined = combine(from_tags(facts), from_restatements(fundamentals))
+    tagged = combined.filter(pl.col("cik") == "0000000004").row(0, named=True)
+    assert tagged["method"] == "xbrl_tag" and tagged["confidence"] == "high"
+    inferred = combined.filter(pl.col("cik") == "0000000001").row(0, named=True)
+    assert inferred["confidence"] == "medium", "inferred alone is not certain"
+
+
+def test_dividends_keep_their_amount_and_period(facts):
+    """Regression: the amount column was never populated and every row was null."""
+    dividends = build_dividends(facts)
+    row = dividends.filter(pl.col("period_end") == date(2020, 3, 31)).row(0, named=True)
+    assert row["amount_per_share"] == 0.25
+    assert row["currency"] == "USD"
+    assert row["period_start"] == date(2019, 12, 31)
+    assert row["kind"] == "declared" and row["security_class"] == "common"
+
+
+def test_a_dividend_declared_after_the_period_is_flagged(facts):
+    dividends = build_dividends(facts)
+    row = dividends.filter(pl.col("period_end") == date(2020, 6, 30)).row(0, named=True)
+    assert row["is_subsequent_event"] is True
+
+
+def test_the_factor_undoes_the_split(fundamentals, facts):
+    """The number that turns a 41.7% earnings yield back into 6.9%."""
+    splits = combine(from_tags(facts), from_restatements(fundamentals))
+    factors = build_adjustment_factors(splits, horizon=datetime(2026, 1, 1, tzinfo=UTC))
+    company = factors.filter(pl.col("cik") == "0000000001").sort("cumulative_split_factor")
+    assert company["cumulative_split_factor"].to_list() == [1.0, 4.0]
+    current = company.filter(pl.col("valid_to").is_null()).row(0, named=True)
+    assert current["cumulative_split_factor"] == 1.0, "nothing to adjust in the present"
+    past = company.filter(pl.col("valid_from").is_null()).row(0, named=True)
+    assert past["cumulative_split_factor"] == 4.0 and past["splits_after"] == 1
+
+
+def test_factors_compose_across_two_splits():
+    splits = pl.DataFrame(
+        [
+            {"cik": "1", "ratio": 7.0, "confidence": "high",
+             "detected_before": datetime(2014, 7, 23, tzinfo=UTC)},
+            {"cik": "1", "ratio": 4.0, "confidence": "high",
+             "detected_before": datetime(2020, 10, 29, tzinfo=UTC)},
+        ],
+        strict=False,
+    )
+    factors = build_adjustment_factors(splits, horizon=datetime(2026, 1, 1, tzinfo=UTC))
+    oldest = factors.filter(pl.col("valid_from").is_null()).row(0, named=True)
+    assert oldest["cumulative_split_factor"] == 28.0, "seven then four is twenty-eight"
+    assert oldest["splits_after"] == 2
+
+
+def test_pit_carries_both_action_types(fundamentals, facts):
+    splits = combine(from_tags(facts), from_restatements(fundamentals))
+    pit = build_pit(build_dividends(facts), splits, run_at=datetime(2026, 1, 1, tzinfo=UTC))
+    kinds = set(pit["action_type"].to_list())
+    assert "split" in kinds and any(k.startswith("dividend_") for k in kinds)
+    assert pit["entity_id"].null_count() == 0
+    assert pit["knowledge_date"].null_count() == 0