$70bn Or $50bn? The OpenAI Revenue Confusion Was A Data Problem: Extracting Financial Metrics With Their Basis, Period And Source So Your Models Never Compare Gross With Net Again

from enum import Enum
from typing import Optional
from pydantic import BaseModel, Field

class Basis(str, Enum):
    gross = "gross"            # includes amounts passed through to partners (principal accounting)
    net = "net"                # only the company's share (agent accounting)
    unknown = "unknown"

class Annualisation(str, Enum):
    reported_period = "reported_period"       # actual figure for a stated period
    run_rate_month = "run_rate_month"         # one month x 12
    run_rate_quarter = "run_rate_quarter"     # one quarter x 4
    company_forecast = "company_forecast"
    unknown = "unknown"

class SourceType(str, Enum):
    filing = "filing"; company_statement = "company_statement"; earnings_call = "earnings_call"
    press_named = "press_named_source"; press_unnamed = "press_unnamed_source"; analyst = "analyst_estimate"

class FinancialMetric(BaseModel):
    entity: str
    metric: str = Field(description="e.g. revenue, annualised_revenue, arr, operating_loss")
    value: float
    currency: str = Field(min_length=3, max_length=3)
    unit: str = Field(description="units, thousands, millions, billions")
    basis: Basis
    period_end: Optional[str] = Field(description="ISO date the figure relates to")
    annualisation: Annualisation
    source_type: SourceType
    source_doc: str = Field(description="document id")
    source_span: str = Field(description="verbatim sentence the figure came from")
    attributed_to: Optional[str] = Field(description="who stated it: the company, an investor, an analyst")

import json

SYSTEM = (
    "Extract financial figures from the document. For every figure you MUST fill basis, annualisation, "
    "source_type and source_span. Use 'unknown' when the document does not state the basis or annualisation; "
    "never infer it from another company's convention. source_span must be copied verbatim from the document. "
    "If a figure is attributed to people familiar with the matter or investors, use press_unnamed_source."
)

def extract(doc_id: str, text: str, llm) -> list:
    tool = {
        "name": "emit_metrics",
        "description": "Return every financial figure with its basis and source.",
        "input_schema": {"type": "object", "properties": {"metrics": {"type": "array", "items": FinancialMetric.model_json_schema()}}, "required": ["metrics"]},
        "strict": True,
    }
    res = llm.call(system=SYSTEM, messages=[{"role": "user", "content": "DOC " + doc_id + ":\n\n" + text}], tools=[tool])
    raw = res.tool_input["metrics"]
    return [FinancialMetric(**m) for m in raw]

def validate(m: FinancialMetric, doc_text: str) -> list:
    problems = []
    if m.source_span not in doc_text:
        problems.append("source_span is not verbatim in the document - possible fabrication")
    span = m.source_span.replace(",", "")
    if not any(tok in span for tok in {str(int(m.value)), str(m.value), f"{m.value:g}"}):
        problems.append("value does not appear in the quoted source sentence")
    if m.metric in ("annualised_revenue", "arr") and m.annualisation == "reported_period":
        problems.append("annualised metric labelled as a reported-period figure")
    if m.source_type in ("press_unnamed_source", "analyst_estimate"):
        problems.append("secondary source - not eligible for signals until confirmed by filing or company statement")
    return problems

# Figures with problems go to a review queue, not into the feature store.

from datetime import date

class NotComparable(Exception): ...

def days_between(a: str, b: str) -> int:
    return (date.fromisoformat(a) - date.fromisoformat(b)).days

def comparable(a: FinancialMetric, b: FinancialMetric, max_period_gap_days=45) -> None:
    if "unknown" in (a.basis, b.basis):
        raise NotComparable(f"basis unknown for {a.entity if a.basis == 'unknown' else b.entity}")
    if a.basis != b.basis:
        raise NotComparable(f"{a.entity} is {a.basis}, {b.entity} is {b.basis} - normalise explicitly first")
    if a.annualisation != b.annualisation:
        raise NotComparable(f"annualisation differs: {a.annualisation} vs {b.annualisation}")
    if a.period_end and b.period_end and abs(days_between(a.period_end, b.period_end)) > max_period_gap_days:
        raise NotComparable("periods too far apart")

def normalise_gross_to_net(m: FinancialMetric, partner_share: float, approved_by: str) -> FinancialMetric:
    """Explicit, labelled estimate - never silent."""
    est = m.model_copy(update={"value": m.value * (1 - partner_share), "basis": "net",
                               "source_type": "analyst_estimate",
                               "attributed_to": "normalised by " + approved_by + f" at partner share {partner_share:.0%}"})
    return est

# compare(openai_net_50bn, anthropic_gross_65bn) -> NotComparable: 'OpenAI is net, Anthropic is gross'