Datasets:

ZipLime
/

security-master

"""Checks that decide whether a build may be published.
A security master fails quietly. A wrong ticker does not raise; it silently
sends a backtest to another company's price series, and the result looks
plausible. So the checks here are about identity: that a ticker current for one
filer is not simultaneously current for another, that intervals are ordered,
that the CUSIP bridge resolves the names everyone actually looks up.
"""

from __future__ import annotations

import json
from dataclasses import dataclass, field
from datetime import UTC, datetime
from pathlib import Path
from typing import Any

import polars as pl

from .store import read_table

# Floors measured on the corpus, set below what it gives so a regression fails
# and noise does not.
MIN_TICKER_COVERAGE = 0.70
# Weighted by how often a CUSIP appears in settlement records, and counting
# only instruments that could resolve. A plain count of matched CUSIPs is the
# wrong measure: two thirds of the CUSIPs ever traded are one-off warrants,
# foreign lines and delisted shells, and exchange-traded funds -- which settle
# like shares and file nothing -- can never resolve at all. By count the bridge
# looks 37% complete; it covers 88% of the position value actually held in 13F.
MIN_CUSIP_WEIGHTED_MATCH = 0.60
MIN_ISSUERS = 15_000
# A ticker genuinely belongs to two filers at once only in odd cases -- a
# reorganisation mid-transfer, a dual filer. Above this share it means the
# ticker history is being stitched to the wrong companies.
MAX_AMBIGUOUS_CURRENT_TICKERS = 0.02


@dataclass
class QualityReport:
    errors: list[str] = field(default_factory=list)
    warnings: list[str] = field(default_factory=list)
    metrics: dict[str, Any] = field(default_factory=dict)

    def error(self, message: str) -> None:
        self.errors.append(message)

    def warn(self, message: str) -> None:
        self.warnings.append(message)

    def metric(self, name: str, value: Any) -> None:
        self.metrics[name] = value

    @property
    def ok(self) -> bool:
        return not self.errors

    def as_dict(self) -> dict[str, Any]:
        return {
            "ok": self.ok,
            "generated_at": datetime.now(UTC).isoformat(),
            "errors": self.errors,
            "warnings": self.warnings,
            "metrics": self.metrics,
        }

    def write(self, path: Path) -> None:
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(json.dumps(self.as_dict(), indent=2, default=str), encoding="utf-8")


def validate(data_dir: Path) -> QualityReport:
    report = QualityReport()
    data_dir = Path(data_dir)

    observations = read_table(data_dir, "observations").collect()
    identifiers = read_table(data_dir, "identifiers").collect()
    issuers = read_table(data_dir, "issuers").collect()
    cusip_map = read_table(data_dir, "cusip_map").collect()
    pit = read_table(data_dir, "pit").collect()

    for name, frame in (
        ("observations", observations), ("identifiers", identifiers),
        ("issuers", issuers), ("cusip_map", cusip_map), ("pit", pit),
    ):
        report.metric(f"rows_{name}", frame.height)
    if issuers.is_empty():
        report.error("issuers table is empty")
        return report
    if issuers.height < MIN_ISSUERS:
        report.error(f"only {issuers.height} issuers, below the {MIN_ISSUERS} floor")

    for column in ("cik", "kind", "value", "observed_on", "source"):
        nulls = observations[column].null_count()
        if nulls:
            report.error(f"observations.{column}: {nulls} nulls")

    reversed_spans = identifiers.filter(pl.col("valid_to") < pl.col("valid_from")).height
    if reversed_spans:
        report.error(f"identifiers: {reversed_spans} spans end before they start")

    duplicates = identifiers.height - identifiers.select("cik", "kind", "value").unique().height
    if duplicates:
        report.error(f"identifiers: {duplicates} duplicate (cik, kind, value) rows")

    if issuers["cik"].n_unique() != issuers.height:
        report.error("issuers: duplicate CIKs")

    with_ticker = issuers.filter(pl.col("primary_ticker").is_not_null()).height
    coverage = with_ticker / issuers.height
    report.metric("issuers_with_ticker", round(coverage, 4))
    active = issuers.filter(pl.col("is_active"))
    report.metric("issuers_active", active.height)
    if not active.is_empty():
        active_coverage = active.filter(pl.col("primary_ticker").is_not_null()).height / active.height
        report.metric("active_issuers_with_ticker", round(active_coverage, 4))
        if active_coverage < MIN_TICKER_COVERAGE:
            report.error(
                f"only {active_coverage:.1%} of active issuers have a ticker, "
                f"below the {MIN_TICKER_COVERAGE:.0%} floor"
            )

    # The check that matters most: a ticker current for two filers at once means
    # somebody's history has been attached to the wrong company.
    current = identifiers.filter((pl.col("kind") == "ticker") & pl.col("is_current"))
    if not current.is_empty():
        ambiguous = (
            current.group_by("value").agg(pl.col("cik").n_unique().alias("filers"))
            .filter(pl.col("filers") > 1)
        )
        share = ambiguous.height / current["value"].n_unique()
        report.metric("ambiguous_current_tickers", ambiguous.height)
        report.metric("ambiguous_current_ticker_share", round(share, 4))
        if share > MAX_AMBIGUOUS_CURRENT_TICKERS:
            report.error(
                f"{ambiguous.height} tickers are current for more than one filer "
                f"({share:.1%}) — histories are being stitched to the wrong companies"
            )

    if not cusip_map.is_empty():
        matched = cusip_map.filter(pl.col("cik").is_not_null()).height
        report.metric("cusip_rows", cusip_map.height)
        report.metric("cusip_matched_share", round(matched / cusip_map.height, 4))
        resolvable = cusip_map.filter(~pl.col("looks_like_fund").fill_null(False))
        weight = resolvable["observations"].sum() or 1
        rate = resolvable.filter(pl.col("cik").is_not_null())["observations"].sum() / weight
        report.metric("cusip_weighted_match", round(rate, 4))
        report.metric("cusip_fund_rows", cusip_map.height - resolvable.height)
        report.metric(
            "cusip_by_confidence",
            {
                row["match_confidence"]: row["n"]
                for row in cusip_map.group_by("match_confidence")
                .agg(pl.len().alias("n")).iter_rows(named=True)
            },
        )
        if rate < MIN_CUSIP_WEIGHTED_MATCH:
            report.error(
                f"only {rate:.1%} of non-fund CUSIP traffic resolved to a filer, "
                f"below the {MIN_CUSIP_WEIGHTED_MATCH:.0%} floor"
            )
        if cusip_map.select("cusip", "ticker").unique().height != cusip_map.height:
            report.error("cusip_map: duplicate (cusip, ticker) rows")
        # A fund family shares one CUSIP prefix, so a fund inheriting its filer
        # from that prefix means one accidental ticker collision has named every
        # fund under it. This is how IVV, IWM and EFA came to be ICF International.
        inherited_funds = cusip_map.filter(
            pl.col("looks_like_fund").fill_null(False)
            & (pl.col("match_method") == "cusip6_inherited")
        ).height
        report.metric("cusip_fund_rows_inherited", inherited_funds)
        if inherited_funds:
            report.error(
                f"cusip_map: {inherited_funds} fund rows took a filer from their CUSIP "
                f"prefix — a fund family's prefix names no operating company"
            )
        report.metric(
            "cusip_name_conflicts",
            cusip_map.filter(pl.col("match_method") == "name_conflict").height,
        )

    if not pit.is_empty():
        if pit.height != identifiers.height:
            report.error(
                f"pit has {pit.height} events for {identifiers.height} identifier spans"
            )
        for column in ("entity_id", "event_date", "knowledge_date"):
            if pit[column].null_count():
                report.error(f"pit.{column}: {pit[column].null_count()} nulls")

    bounds = observations.select(
        pl.col("observed_on").min().alias("first"), pl.col("observed_on").max().alias("last")
    ).row(0)
    report.metric("coverage_first_observation", str(bounds[0]))
    report.metric("coverage_last_observation", str(bounds[1]))
    report.metric(
        "observations_by_source",
        {
            row["source"]: row["n"]
            for row in observations.group_by("source").agg(pl.len().alias("n")).iter_rows(named=True)
        },
    )
    return report


__all__ = ["QualityReport", "validate"]

	"""Checks that decide whether a build may be published.

	A security master fails quietly. A wrong ticker does not raise; it silently
	sends a backtest to another company's price series, and the result looks
	plausible. So the checks here are about identity: that a ticker current for one
	filer is not simultaneously current for another, that intervals are ordered,
	that the CUSIP bridge resolves the names everyone actually looks up.
	"""

	from __future__ import annotations

	import json
	from dataclasses import dataclass, field
	from datetime import UTC, datetime
	from pathlib import Path
	from typing import Any

	import polars as pl

	from .store import read_table

	# Floors measured on the corpus, set below what it gives so a regression fails
	# and noise does not.
	MIN_TICKER_COVERAGE = 0.70
	# Weighted by how often a CUSIP appears in settlement records, and counting
	# only instruments that could resolve. A plain count of matched CUSIPs is the
	# wrong measure: two thirds of the CUSIPs ever traded are one-off warrants,
	# foreign lines and delisted shells, and exchange-traded funds -- which settle
	# like shares and file nothing -- can never resolve at all. By count the bridge
	# looks 37% complete; it covers 88% of the position value actually held in 13F.
	MIN_CUSIP_WEIGHTED_MATCH = 0.60
	MIN_ISSUERS = 15_000
	# A ticker genuinely belongs to two filers at once only in odd cases -- a
	# reorganisation mid-transfer, a dual filer. Above this share it means the
	# ticker history is being stitched to the wrong companies.
	MAX_AMBIGUOUS_CURRENT_TICKERS = 0.02


	@dataclass
	class QualityReport:
	errors: list[str] = field(default_factory=list)
	warnings: list[str] = field(default_factory=list)
	metrics: dict[str, Any] = field(default_factory=dict)

	def error(self, message: str) -> None:
	self.errors.append(message)

	def warn(self, message: str) -> None:
	self.warnings.append(message)

	def metric(self, name: str, value: Any) -> None:
	self.metrics[name] = value

	@property
	def ok(self) -> bool:
	return not self.errors

	def as_dict(self) -> dict[str, Any]:
	return {
	"ok": self.ok,
	"generated_at": datetime.now(UTC).isoformat(),
	"errors": self.errors,
	"warnings": self.warnings,
	"metrics": self.metrics,
	}

	def write(self, path: Path) -> None:
	path.parent.mkdir(parents=True, exist_ok=True)
	path.write_text(json.dumps(self.as_dict(), indent=2, default=str), encoding="utf-8")


	def validate(data_dir: Path) -> QualityReport:
	report = QualityReport()
	data_dir = Path(data_dir)

	observations = read_table(data_dir, "observations").collect()
	identifiers = read_table(data_dir, "identifiers").collect()
	issuers = read_table(data_dir, "issuers").collect()
	cusip_map = read_table(data_dir, "cusip_map").collect()
	pit = read_table(data_dir, "pit").collect()

	for name, frame in (
	("observations", observations), ("identifiers", identifiers),
	("issuers", issuers), ("cusip_map", cusip_map), ("pit", pit),
	):
	report.metric(f"rows_{name}", frame.height)
	if issuers.is_empty():
	report.error("issuers table is empty")
	return report
	if issuers.height < MIN_ISSUERS:
	report.error(f"only {issuers.height} issuers, below the {MIN_ISSUERS} floor")

	for column in ("cik", "kind", "value", "observed_on", "source"):
	nulls = observations[column].null_count()
	if nulls:
	report.error(f"observations.{column}: {nulls} nulls")

	reversed_spans = identifiers.filter(pl.col("valid_to") < pl.col("valid_from")).height
	if reversed_spans:
	report.error(f"identifiers: {reversed_spans} spans end before they start")

	duplicates = identifiers.height - identifiers.select("cik", "kind", "value").unique().height
	if duplicates:
	report.error(f"identifiers: {duplicates} duplicate (cik, kind, value) rows")

	if issuers["cik"].n_unique() != issuers.height:
	report.error("issuers: duplicate CIKs")

	with_ticker = issuers.filter(pl.col("primary_ticker").is_not_null()).height
	coverage = with_ticker / issuers.height
	report.metric("issuers_with_ticker", round(coverage, 4))
	active = issuers.filter(pl.col("is_active"))
	report.metric("issuers_active", active.height)
	if not active.is_empty():
	active_coverage = active.filter(pl.col("primary_ticker").is_not_null()).height / active.height
	report.metric("active_issuers_with_ticker", round(active_coverage, 4))
	if active_coverage < MIN_TICKER_COVERAGE:
	report.error(
	f"only {active_coverage:.1%} of active issuers have a ticker, "
	f"below the {MIN_TICKER_COVERAGE:.0%} floor"
	)

	# The check that matters most: a ticker current for two filers at once means
	# somebody's history has been attached to the wrong company.
	current = identifiers.filter((pl.col("kind") == "ticker") & pl.col("is_current"))
	if not current.is_empty():
	ambiguous = (
	current.group_by("value").agg(pl.col("cik").n_unique().alias("filers"))
	.filter(pl.col("filers") > 1)
	)
	share = ambiguous.height / current["value"].n_unique()
	report.metric("ambiguous_current_tickers", ambiguous.height)
	report.metric("ambiguous_current_ticker_share", round(share, 4))
	if share > MAX_AMBIGUOUS_CURRENT_TICKERS:
	report.error(
	f"{ambiguous.height} tickers are current for more than one filer "
	f"({share:.1%}) — histories are being stitched to the wrong companies"
	)

	if not cusip_map.is_empty():
	matched = cusip_map.filter(pl.col("cik").is_not_null()).height
	report.metric("cusip_rows", cusip_map.height)
	report.metric("cusip_matched_share", round(matched / cusip_map.height, 4))
	resolvable = cusip_map.filter(~pl.col("looks_like_fund").fill_null(False))
	weight = resolvable["observations"].sum() or 1
	rate = resolvable.filter(pl.col("cik").is_not_null())["observations"].sum() / weight
	report.metric("cusip_weighted_match", round(rate, 4))
	report.metric("cusip_fund_rows", cusip_map.height - resolvable.height)
	report.metric(
	"cusip_by_confidence",
	{
	row["match_confidence"]: row["n"]
	for row in cusip_map.group_by("match_confidence")
	.agg(pl.len().alias("n")).iter_rows(named=True)
	},
	)
	if rate < MIN_CUSIP_WEIGHTED_MATCH:
	report.error(
	f"only {rate:.1%} of non-fund CUSIP traffic resolved to a filer, "
	f"below the {MIN_CUSIP_WEIGHTED_MATCH:.0%} floor"
	)
	if cusip_map.select("cusip", "ticker").unique().height != cusip_map.height:
	report.error("cusip_map: duplicate (cusip, ticker) rows")
	# A fund family shares one CUSIP prefix, so a fund inheriting its filer
	# from that prefix means one accidental ticker collision has named every
	# fund under it. This is how IVV, IWM and EFA came to be ICF International.
	inherited_funds = cusip_map.filter(
	pl.col("looks_like_fund").fill_null(False)
	& (pl.col("match_method") == "cusip6_inherited")
	).height
	report.metric("cusip_fund_rows_inherited", inherited_funds)
	if inherited_funds:
	report.error(
	f"cusip_map: {inherited_funds} fund rows took a filer from their CUSIP "
	f"prefix — a fund family's prefix names no operating company"
	)
	report.metric(
	"cusip_name_conflicts",
	cusip_map.filter(pl.col("match_method") == "name_conflict").height,
	)

	if not pit.is_empty():
	if pit.height != identifiers.height:
	report.error(
	f"pit has {pit.height} events for {identifiers.height} identifier spans"
	)
	for column in ("entity_id", "event_date", "knowledge_date"):
	if pit[column].null_count():
	report.error(f"pit.{column}: {pit[column].null_count()} nulls")

	bounds = observations.select(
	pl.col("observed_on").min().alias("first"), pl.col("observed_on").max().alias("last")
	).row(0)
	report.metric("coverage_first_observation", str(bounds[0]))
	report.metric("coverage_last_observation", str(bounds[1]))
	report.metric(
	"observations_by_source",
	{
	row["source"]: row["n"]
	for row in observations.group_by("source").agg(pl.len().alias("n")).iter_rows(named=True)
	},
	)
	return report


	__all__ = ["QualityReport", "validate"]