dragonlimited/Dragon-Finance-Corpus

stored: 3.93 TB · product classes: 12 · jurisdiction: US + global official · training: none · figures: hub-measured

Dragon Finance Corpus — 3.93 TB across 12 product classes

A corpus of publicly available US and world financial data, compiled directly from primary sources and kept current by a continuous ingestion pipeline. Every product class of finance is represented — equities, credit, funds, rates, macro, commodities, real estate, FX, insurance and digital assets — each given a fixed share of the target, with the measured fill against that budget shown below so any class that is behind is visible rather than implied.

Before you use any of this, read DISCLAIMER.md. The Data is published for informational and research purposes only. It is not investment, financial, legal, tax or accounting advice, is not an offer or solicitation, and is not a system of record or a compliance product. It is assembled by automated agents with no per-record human review, may be incomplete, restated or miscoded, and must be independently verified before you rely on it. No warranty is given; liability is limited. Every figure on this page and in BENCHMARK.md measures stored bytes or tokens, not quality, completeness or fitness.

All figures are measured by the Hugging Face hub and are reconcilable against the repository pages, so the totals can be verified without trusting this card. Updated 2026-11-06 16:24 UTC.

How this was built, and what comes next: ROADMAP.md - the pipeline's phases, its operating procedure, and the sources it will never take.

Product mix

product class	repository	stored	budget	filled
equities	Dragon-Finance-Equities	2.86 TB	4.80 TB	59.5%
credit	Dragon-Finance-Credit	131.72 GB	2.60 TB	5.1%
funds	Dragon-Finance-Funds	18.67 GB	1.60 TB	1.2%
macro	Dragon-Finance-Macro	328.39 GB	1.80 TB	18.2%
rates	Dragon-Finance-Rates	828.80 MB	1.40 TB	0.1%
commodities	Dragon-Finance-Commodities	11.77 GB	1.20 TB	1.0%
realestate	Dragon-Finance-RealEstate	519.71 GB	1.20 TB	43.3%
fx	Dragon-Finance-FX	82.76 MB	600.00 GB	0.0%
insurance	Dragon-Finance-Insurance	55.73 GB	800.00 GB	7.0%
crypto	Dragon-Finance-Crypto	8.34 MB	600.00 GB	0.0%
global	Dragon-Finance-Global	3.28 GB	1.40 TB	0.2%
documents	Dragon-Finance-Documents	7.06 GB	2.00 TB	0.4%

Training-ready text by class

Measured 2026-11-06 16:14 UTC over 78 of 78 shard(s). Tokens use the one convention these cards share - chars / 4 over the chunked text - so each figure is reconcilable against the shards. A token count is what a training run consumes; the stored bytes above are the ore, not the metal. Class attribution uses the shard path's first segment, so a tier sharing a segment with another class is attributed to its dominant class, and a label nobody classified is reported as unclassified rather than assigned.

product class	chunks	text	tokens	share
equities	53,373,177	55.687 GB	13,921.7 M	98.93%
global	201,037	0.306 GB	76.4 M	0.54%
funds	163,385	0.127 GB	31.6 M	0.22%
documents	60,706	0.114 GB	28.5 M	0.20%
macro	72,871	0.045 GB	11.2 M	0.08%
insurance	5,195	0.008 GB	1.9 M	0.01%
rates	1,614	0.002 GB	0.4 M	0.00%
fx	213	0.000 GB	0.1 M	0.00%
crypto	262	0.000 GB	0.0 M	0.00%
credit	4	0.000 GB	0.0 M	0.00%
commodities	0	0.000 GB	0.0 M	0.00%
realestate	0	0.000 GB	0.0 M	0.00%

How this corpus was assembled

The Dragon Finance Corpus is compiled directly from primary sources and kept current by a continuous ingestion pipeline. Each product class is refreshed independently: new publications are collected, packed into immutable shards and published, and the card you are reading is regenerated from the resulting measurements - so the description and the data it describes cannot drift apart.

1. Source selection

Only official and free-public sources are used: US federal agencies and regulators (SEC/EDGAR, US Treasury, FRED, CFTC, FDIC, CFPB/HMDA, NCUA, BLS, Census, BEA, IRS, DOL, EIA, FEMA, NY Fed, Federal Reserve, Federal Register, OFAC, FHFA, USDA, SBA, Cboe, Chicago Fed), non-US official publishers (ECB, BIS, IMF, World Bank, Eurostat, Bank of England, UK Companies House, GLEIF), and US-regulated venue data whose terms permit redistribution. Where a source requires a key it is a free key; no paid subscription is used anywhere.

Deliberately excluded, and this exclusion is what allows an institution to cite the corpus: licensed or paywalled market data (consolidated tape, CME historicals, FINRA market data, NYSE and Nasdaq tape), registration-gated portals, and anything scraped from an aggregator. The authoritative statement of what is excluded, and the terms governing everything here, is DISCLAIMER.md.

2. Four collection shapes

shape	how it works	used for
URL-list mirror	a curated URL set is fetched, packed into shards and published	SEC bulk data sets, BIS, DOL Form 5500, USDA NASS, Census directory trees, EDGAR log files, venue candles
Direct ingest	files are collected under data/<source>/, then packed and published	EDGAR filings, XBRL, HMDA, FDIC, NCUA, CFPB, BLS, Census, FRED, Treasury, CFTC, Nasdaq, FINRA
Bulk relay	an unmetered object store is streamed into shards with no intermediate processing	volume sources that need no local processing
Per-filer EDGAR	one archive per company (CIK), collected as SEC complete submissions	the largest in-scope source: full filing history for the whole US filer universe

3. Source terms and access limits

Requests are paced per host, not per collection: every sec.gov host shares a single budget because SEC's fair-access policy is per client, and other hosts get their own. Requests carry an identifying User-Agent with a contact address, as SEC requires. A terminal 4xx is treated as a fact and not retried (a 404 will not heal); 429 and 5xx are retried with backoff, honouring Retry-After. Throughput is therefore a function of each source's stated limit rather than of our own capacity, which is the behaviour those terms ask for.

4. Why everything is a shard

The hub caps a directory at 10,000 files and these classes run to millions of objects, so each tree is packed into tar shards sized by bytes (about 1.8 GB). Shard size is an operational choice rather than taste: a shard is the unit of publication, so larger shards mean fewer publications per terabyte and smaller ones mean more. A byte target keeps the unit large enough to be efficient while ensuring a refresh republishes only what actually changed.

Shard names are keyed to content, never to sorted position: one archive per CIK for the EDGAR full tree, a UTC timestamp plus a random token for corpus shards. Positional names are a function of which files happened to be to hand at the time, so two collections can produce the same name for different contents - and that silently replaced a published shard once. Collision-free names are a requirement here, not a convention.

5. The publication record, and how a refresh resumes

Every published shard is recorded once, with its member count, its bytes, its sha256 and the range it covers (first/last URL, or CIK). Two rules make the corpus safe to extend:

• A recorded shard is re-verified against the hub. It is skipped only while the hub still lists it, so a repository that is emptied is refilled rather than believed. (Not hypothetical: a whole product class was once silently empty because the record said "done" while the repository was gone.)
• A shard is recorded only once every member has landed. A missed file is retried until it arrives rather than dropped from the record, so a gap is a delay and never a hole.

Because the record is authoritative and carried forward, resuming is incremental: a restart continues where it stopped and re-publishes nothing that is already stored.

6. Measured, never hand-typed

Every figure on this page, in DETAIL.md and in BENCHMARK.md is read from the hub's own usedStorage at publication time, so any reader can reconcile it against the repository pages without trusting this text. Capacity is never inferred from local disk: the hub is the durable copy of the corpus, and the hub is what is measured.

7. Documents count as data

Central banks, the IMF and statistical agencies publish much of their finance material as PDF. Those are text-extracted rather than skipped, so the publication corpora are training-ready text rather than stored bytes nothing can read. It is why the Documents and Global classes exist at all.

8. What is deliberately not here

No model weights, training samples, checkpoints or fine-tuned models - this account publishes data, and the chunked corpus is the final derived stage. Nothing here is a system of record, a compliance product or investment advice; see DISCLAIMER.md.

How to use it

Open a shard

Every product repository stores tar shards rather than loose files, because the hub caps a directory at 10,000 files and these tiers run to millions. A member keeps the source's own filename: a local-ingest shard holds yield_curve_1994.csv or hmda_2023_CA.csv, a per-filer EDGAR shard holds 0000320193-24-000123.txt, and a mirrored URL is named from its last path-and-query segment, so fredgraph.csv?id=DEXCAUS arrives as fredgraph.csv_id_DEXCAUS. Listing a shard before extracting it is always the reliable move:

import tarfile

with tarfile.open("0000.tar") as tf:
    print(tf.getnames()[:5])          # inspect before you extract
    tf.extractall("out/")             # members keep their original paths

To pull a single object without downloading the repository, use the Hub client (no clone, no credential needed for public data):

from huggingface_hub import hf_hub_download

p = hf_hub_download(repo_id="dragonlimited/Dragon-Finance-Equities",
                    filename="data/edgar_complete/cik-0000019617.tar",
                    repo_type="dataset")

Find what you want before you download it

Objects are named after their source, so the shard path is the index: data/hmda/…, fdic/deep/…, kraken/ohlc/…, fomc/…, cik-0000019617.tar. The pipeline/ directory in the Dragon-Finance-Corpus front door holds the publication record, and each entry names a shard, its member count and its byte size - so you can locate a tier and estimate its cost before fetching anything.

Resolving any file back to its source

• In a raw shard: the tar member name, plus the shard's sha256 in the publication record.
• In the chunked corpus: meta.file is <shard path>::<member name>, and meta.source is the tier - so every chunk resolves to the archive it came from, and from there to the publication record and the source URL.
• For the local-ingest tiers, pipeline/manifest.jsonl.txt additionally carries per-file provenance: URL, sha256 and fetch timestamp.

Worked examples

Four shapes cover most of what the corpus is used for. All of them need only the Hub client and the standard library.

One company's whole filing history, as text. Each EDGAR tar is one filer, and every member is a complete submission - the primary document plus every exhibit, with an SGML envelope around inline HTML:

from huggingface_hub import snapshot_download
import tarfile, re

snapshot_download("dragonlimited/Dragon-Finance-Equities", repo_type="dataset",
                  allow_patterns="data/edgar_complete/cik-0000320193.tar", local_dir="aapl")
with tarfile.open("aapl/data/edgar_complete/cik-0000320193.tar") as tf:
    for m in tf.getmembers()[:5]:
        print(m.name, m.size)              # e.g. 0000320193-24-000123.txt
    text = tf.extractfile("0000320193-24-000123.txt").read().decode("utf-8", "ignore")
    body = re.sub(r"<[^>]+>", " ", text)   # de-mark it yourself, or use the chunked corpus below

A panel from one class. A shard usually holds one file per period, which makes a panel a loop:

from huggingface_hub import hf_hub_download
import pandas as pd, tarfile

p = hf_hub_download("dragonlimited/Dragon-Finance-Rates", repo_type="dataset",
                    filename="data/treasury/0000.tar")
with tarfile.open(p) as tf:                       # members: yield_curve_1990.csv, ...
    frames = [pd.read_csv(tf.extractfile(m)) for m in tf.getmembers()]
panel = pd.concat(frames, ignore_index=True)      # read the header; do not assume column names

Loan-level records by state and year. HMDA members are named hmda_<year>_<state>.csv, so file selection is a glob rather than a parse:

from huggingface_hub import snapshot_download
import pandas as pd, tarfile, glob

snapshot_download("dragonlimited/Dragon-Finance-Credit", repo_type="dataset",
                  allow_patterns="data/hmda/*.tar", local_dir="hmda")
rows = []
for shard in glob.glob("hmda/data/hmda/*.tar"):
    with tarfile.open(shard) as tf:
        for m in tf.getmembers():
            if m.name.startswith("hmda_2023_"):   # one year across every state
                rows.append(pd.read_csv(tf.extractfile(m)))

Training text, without downloading the raw shards. This is what the chunked corpus exists for: one JSON object per line, 512-token windows with 64 tokens of overlap, each carrying its provenance.

from huggingface_hub import hf_hub_download
import json

p = hf_hub_download("dragonlimited/Dragon-Finance-Corpus", repo_type="dataset",
                    filename="corpus/chunks-20261104T174041Z-07cdc4.jsonl")   # any shard of the set
with open(p) as fh:
    for line in fh:
        rec = json.loads(line)
        if rec["meta"]["source"] == "fomc":       # e.g. every FOMC document, already extracted
            print(rec["meta"]["file"], rec["meta"]["tokens"], rec["text"][:80])

The shard list changes as the corpus grows, so take the names from corpus/ rather than hardcoding one; corpus/README.md documents the schema and the current source mix.

Caveats that matter when you analyse it

• Mixed vintages. Filings are amended and series are revised; the corpus holds what the source published and is not a point-in-time snapshot. Keep an as-of date in any analysis.
• Automated assembly, no per-record human review. Ingestion, parsing and any enrichment are mechanical and can be wrong. Numeric and tabular material dominates the raw store relative to prose; check the per-class token figures before assuming text volume.
• Attribution and licences travel with each source. FRED is CC-BY-4.0 (attribution required), SEC EDGAR is US public record (identifying User-Agent and fair-access limits required), HMDA carries FFIEC/CFPB terms, exchange data carries venue terms. You are responsible for complying with the source terms before any redistribution.
• Not a system of record. Verify before you rely on it. See DISCLAIMER.md for the full terms, including the limits of liability.

Repositories

repository	size	objects
Dragon-Finance-Equities	2.86 TB	1,268
Dragon-Finance-RealEstate	519.71 GB	235
Dragon-Finance-Macro	328.39 GB	268
Dragon-Finance-Credit	131.72 GB	53
Dragon-Finance-Corpus	103.24 GB	85
Dragon-Finance-Insurance	55.73 GB	257
Dragon-Finance-Funds	18.67 GB	91
Dragon-Finance-Commodities	11.77 GB	13
Dragon-Finance-Documents	7.06 GB	7
Dragon-Finance-Global	3.28 GB	7
Dragon-Finance-Rates	828.80 MB	22
Dragon-Finance-FX	82.76 MB	6
Dragon-Finance-Crypto	8.34 MB	21
Dragon-Finance-Pipeline	0.0 KB	0

Sources

source	jurisdiction	product class	dataset	licence
SEC EDGAR	US	equities & disclosure	filings + exhibits	US public record
SEC bulk data sets	US	equities & disclosure	FinStmt, Notes, MIDAS	US public record
SEC Form 13F	US	funds & asset management	institutional holdings	US public record
SEC Form N-PORT	US	funds & asset management	monthly fund holdings	US public record
SEC Form N-CEN	US	funds & asset management	fund census	US public record
CFPB HMDA	US	loans & mortgages	loan-level mortgage	public / FFIEC terms
FDIC	US	banking & credit unions	institution financials	public
NCUA	US	banking & credit unions	credit-union call reports	public
FRED	US	macro & statistics	rates + macro series	CC-BY-4.0
BLS / Census	US	macro & statistics	CPI, PPI, ACS, CBP, econ census	public
US Treasury	US	fixed income & rates	yield curve, auctions, fiscal	public domain
CFTC	US	commodities & energy	commitments of traders	public
EIA / USDA	US	commodities & energy	energy + agricultural series	public
Kraken / Coinbase	US	market microstructure	venue OHLC candles	exchange terms; budget-capped
NY Fed	US	fixed income & rates	reference rates, SOMA holdings	public
Chicago Fed	US	banking & credit unions	commercial bank data	public
Federal Register	US	equities & disclosure	financial rules and notices	US public record
OFAC	US	equities & disclosure	sanctions lists (SDN, consolidated)	public
FHFA	US	housing & real estate	house price index	public
Zillow research	US	housing & real estate	home value and rent indices	commercial - NON-OFFICIAL
DOL Form 5500	US	insurance & pensions	pension and welfare plan filings	US public record
FEMA openFEMA	US	insurance & pensions	NFIP policies and claims	public
Cboe	US	market microstructure	volatility indices	public
World Bank	global	macro & statistics	world development indicators (catalogue)	CC-BY-4.0
IMF	global	macro & statistics	world economic indicators (DataMapper)	IMF terms
BIS	global	banking & rates	bulk statistics: rates, credit, debt	BIS terms
Eurostat	EU	macro & statistics	European statistics (SDMX datasets)	public
ECB Data Portal	EU	fixed income & rates	yield curve, bank rates, money supply	ECB terms
UK Companies House	UK	equities & disclosure	daily company accounts (iXBRL)	OGL v3
Federal Reserve FOMC	US	documents & publications	statements, minutes, historical transcripts (PDF)	US public record

Layout

Each product repository stores tar shards rather than loose files — the hub caps a directory at 10,000 files and these tiers run to millions. Members keep their original names and paths.

import tarfile
with tarfile.open("0000.tar") as tf:
    print(tf.getnames()[:5])
    tf.extractall("out/")

Derived artefacts

This repository is also the home of the derived artefacts, so there is one home per concern: the product repositories hold the raw shards, and this front door holds the cards and everything built from them.

path	what it holds
corpus/chunks-*.jsonl	chunked corpus - 54,042,112 chunks (~14124M tokens) so far of ~512-token windows over the raw shards, one JSON object per line (text, meta.source, meta.file, meta.chunk). Growing; see corpus/README.md.
DISCLAIMER.md	authoritative terms of use - the notice to read first
DETAIL.md, PRODUCT_MIX.md, BENCHMARK.md	measured coverage, budget fill, and size against comparable finance corpora
ROADMAP.md	how it is gathered, and what comes next - the phases and their state, the operating procedure, the guarantees and the permanent exclusions. The one card that states intentions rather than measurements.

Text is extracted from PDFs as well as tables (pdf_text, page-capped), because a large part of central-bank, IMF and statistical-release finance material is published as PDF - so the document corpora are training-ready text rather than stored bytes nothing can read.

No model weights, training samples or checkpoints are produced or published here. The chunked corpus is the final derived stage; nothing downstream of it exists on this account.

How the chunked corpus is made

The raw shards above are the ore; corpus/chunks-*.jsonl in the front door is the metal. It is built one shard at a time: each tar is downloaded, read member by member and deleted again, so one shard is held at a time.

• Text extraction, per format. PDFs are text-extracted (page-capped), because a large part of central-bank, IMF and statistical-release finance material is published as PDF. HTML and SGML - which includes EDGAR's complete submissions, an SGML envelope around inline HTML - is de-marked. Archives inside a shard (.zip, .gz) are opened and read inside, with an entry budget per shard.
• Chunks are token-accurate. Windows are 512 tokens with 64 tokens of overlap, measured with a real tokenizer - used purely as a ruler, so that "a 512-token chunk" means the same thing to every consumer.
• Ceilings keep the corpus readable. A per-document cap stops one pathological file dominating, a per-tier cap stops one tier dominating, and the numeric tiers (futures tables, venue candles) get a much smaller cap so kilobytes of number grids cannot swamp prose. Truncation is recorded in the publication record, never silent.
• Output is sharded, not one file. The hub has no delta upload, so a single growing file would be re-pushed in full every round. Shards roll at a fixed size and are published one at a time; the shard still being written is published from a frozen snapshot, so an upload never reads a file that is growing underneath it.
• Resumable. A shard read in full is recorded, so a resumed run continues rather than restarting.

The full procedure - every extraction rule, every cap, the exact record schema and how to consume the chunks - is in corpus/README.md.

Integrity

Every shard records its sha256, its member count and the source key range it covers. Shards are append-only, so extending the corpus adds new shards rather than rewriting existing ones and a resumed collection re-publishes only what changed. A shard whose member is missing is never recorded as complete, so a missed file is retried rather than dropped.

Reproduce

Sources are public and keyless; reproducing or extending the corpus needs only bandwidth and disk.