"""From the Committee's calendar to seven tables, one meeting at a time. The shape of a run is: read the calendar, read each meeting's documents, and write a row for every public information arrival. The word *arrival* is doing the work. A meeting is not an event -- nothing is knowable because a meeting happened. The statement, the implementation note, the projections and the minutes are four separate arrivals with four separate instants, and the minutes arrive three weeks after the meeting they describe. Three rules hold everywhere in this module. **A document dates itself.** `knowledge_at` comes from the document's own embargo line where it has one, from the calendar's stated minutes release date where it does not, and otherwise from the end of the release day in Washington. Nothing is derived from the meeting date. **A meeting is known when its first document is.** The `meetings` table is indexed on the earliest `knowledge_at` of anything belonging to it, so joining it to prices cannot reveal a decision before it was announced. For a scheduled future meeting that instant is when the calendar first announced it. **A failure is a quarantine, not a gap.** A document that cannot be parsed does not silently vanish; it lands in `quarantine.parquet` with the reason, and the next run tries it again. """ from __future__ import annotations import asyncio import hashlib import logging import shutil from dataclasses import dataclass, field from datetime import UTC, date, datetime from pathlib import Path import polars as pl from .config import COUNTRY, HOST, RELEASE_TIMEZONE, Settings, validate_user_agent from .coverage import write_build_record, write_coverage from .http import Artifact, Fetcher from .pit import build_pit from .schema import ( CALENDAR_SCHEMA, DOCUMENT_SCHEMA, DOT_PLOT_SCHEMA, EVENT_SCHEMA, MEETING_SCHEMA, PARSER_VERSION, SEP_SCHEMA, VOTE_SCHEMA, align, ) from .sources.article import read as read_article from .sources.calendar import ( CALENDAR_MAX_AGE, CALENDAR_URL, HISTORICAL_YEAR_URL, MeetingLinks, parse_calendar, parse_historical_year, ) from .sources.implementation import parse_implementation_note from .sources.projections import parse_projections from .sources.statement import parse_statement from .store import write_table from .timing import end_of_day, release_instant LOGGER = logging.getLogger(__name__) SOURCE = "federalreserve.gov" PIT_DELTA_NAME = "fomc_events.delta" # A meeting that is over published what it published. Probing for a document it # does not have is a question with a permanent answer, so the miss is # remembered for a year rather than for the two days a live discovery needs. SETTLED = 365 * 24 * 3600 # The accessible version of the projections has lived at three URLs, and they # are not equivalent. `fomcprojtabl` carries both the projections and the # policy path chart as data tables; `FOMC{date}SEPcompilation`, which the # historical year pages link instead, carries the projections and each # participant's individual numbers but not the dot counts. So the first two are # tried before whatever the calendar linked, and the compilation is the last # resort rather than the first answer. PROJECTION_CANDIDATES = ( HOST + "/monetarypolicy/fomcprojtabl{date}.htm", HOST + "/monetarypolicy/fomcprojtable{date}.htm", ) PROJECTION_FALLBACK = (HOST + "/monetarypolicy/files/FOMC{date}SEPcompilation.htm",) # The historical year pages link no implementation note at all, though every # meeting since December 2015 has one. These are the two paths the Board has # served them from. IMPLEMENTATION_CANDIDATES = ( HOST + "/newsevents/pressreleases/monetary{date}a1.htm", HOST + "/newsevents/press/monetary/{date}a1.htm", ) @dataclass(slots=True) class Quarantined: meeting_id: str document_type: str url: str reason: str @dataclass(slots=True) class BuildResult: counts: dict[str, int] = field(default_factory=dict) quarantined: list[Quarantined] = field(default_factory=list) def digest(text: str) -> str: return hashlib.sha256(text.encode("utf-8")).hexdigest() def document_id(meeting_id: str, kind: str) -> str: return f"{meeting_id}_{kind.upper()}" def et_parts(instant: datetime | None) -> tuple[date | None, object | None]: """The release instant as Washington sees it, which is how a desk reads it.""" if instant is None: return None, None from zoneinfo import ZoneInfo local = instant.astimezone(ZoneInfo(RELEASE_TIMEZONE)) return local.date(), local.time() # --------------------------------------------------------------------------- # Discovery. async def discover(fetcher: Fetcher, *, from_year: int) -> list[MeetingLinks]: """Every meeting the Federal Reserve lists, newest page winning. The calendar page carries the current and next year plus a few behind it; everything older lives on one page per year. Where both describe the same meeting the calendar page is the fresher account of it -- it is the page that gains the minutes link three weeks after the meeting. """ found: dict[str, MeetingLinks] = {} this_year = datetime.now(UTC).year for year in range(from_year, this_year + 1): url = HISTORICAL_YEAR_URL.format(year=year) artifact = await fetcher.get(url, max_age_seconds=CALENDAR_MAX_AGE, allow_missing=True) if artifact is None: continue for meeting in parse_historical_year(artifact.text, year=year, source_url=url): found[meeting.meeting_id] = meeting artifact = await fetcher.get(CALENDAR_URL, max_age_seconds=CALENDAR_MAX_AGE) for meeting in parse_calendar(artifact.text, source_url=CALENDAR_URL): if meeting.end_date.year < from_year: continue held = found.get(meeting.meeting_id) if held is not None: # The historical page knows the meeting's kind; the calendar page # knows its documents. Keep both. meeting.meeting_type = held.meeting_type for name in ("statement_url", "implementation_url", "minutes_url", "projections_url", "press_conference_url", "minutes_released_on"): if getattr(meeting, name) is None: setattr(meeting, name, getattr(held, name)) found[meeting.meeting_id] = meeting return sorted(found.values(), key=lambda meeting: meeting.end_date) async def projections_document( fetcher: Fetcher, meeting: MeetingLinks ) -> Artifact | None: """The accessible projections page, from the calendar link or by probing. Some calendar entries link only the PDF of the projections even though the accessible HTML exists -- March 2015 is one. Probing the three URLs the Board has used is what recovers those; a meeting with no projections answers 404 to all three, which is the correct answer for it. """ if meeting.end_date >= datetime.now(UTC).date(): # A meeting that has not happened has published nothing. Probing for it # every run asks the Board for pages that cannot exist yet. return None found = await _probe(fetcher, PROJECTION_CANDIDATES, meeting) if found is not None: return found if meeting.projections_url: artifact = await fetcher.get(meeting.projections_url, allow_missing=True) if artifact is not None: return artifact return await _probe(fetcher, PROJECTION_FALLBACK, meeting) async def implementation_document(fetcher: Fetcher, meeting: MeetingLinks) -> Artifact | None: """The implementation note, from the calendar link or by probing.""" if meeting.implementation_url: artifact = await fetcher.get(meeting.implementation_url, allow_missing=True) if artifact is not None: return artifact if meeting.end_date >= datetime.now(UTC).date(): return None found = await _probe(fetcher, IMPLEMENTATION_CANDIDATES, meeting) if found is not None: meeting.implementation_url = found.url return found async def _probe( fetcher: Fetcher, templates: tuple[str, ...], meeting: MeetingLinks ) -> Artifact | None: for template in templates: url = template.format(date=f"{meeting.end_date:%Y%m%d}") artifact = await fetcher.get(url, allow_missing=True, missing_max_age=SETTLED) if artifact is not None: if "proj" in url.lower() or "SEP" in url: meeting.projections_url = url return artifact return None # --------------------------------------------------------------------------- # One meeting's rows. @dataclass(slots=True) class Rows: events: list[dict] = field(default_factory=list) meetings: list[dict] = field(default_factory=list) documents: list[dict] = field(default_factory=list) sep: list[dict] = field(default_factory=list) dot_plot: list[dict] = field(default_factory=list) votes: list[dict] = field(default_factory=list) calendar: list[dict] = field(default_factory=list) quarantined: list[Quarantined] = field(default_factory=list) def extend(self, other: Rows) -> None: for name in ("events", "meetings", "documents", "sep", "dot_plot", "votes", "calendar", "quarantined"): getattr(self, name).extend(getattr(other, name)) def provenance(artifact: Artifact, *, source_type: str, document: str) -> dict: return { "source": SOURCE, "source_url": artifact.url, "source_document_id": document, "source_type": source_type, "raw_sha256": artifact.sha256, "parser_version": PARSER_VERSION, "first_seen_at": artifact.downloaded_at, "ingested_at": datetime.now(UTC), } def document_row( *, meeting: MeetingLinks, event_id: str, kind: str, artifact: Artifact, title: str | None, text: str, instant: datetime | None, precision: str, suffix: str = "", ) -> dict: identifier = document_id(meeting.meeting_id, kind + ("_" + suffix if suffix else "")) return { "document_id": identifier, "meeting_id": meeting.meeting_id, "event_id": event_id, "document_type": kind, "release_at": instant, "knowledge_at": instant, "knowledge_date": instant, "knowledge_time_precision": precision, "title": title, "text": text, "word_count": len(text.split()), "html_url": artifact.url, "pdf_url": None, "language": "en", "content_hash": digest(text), **provenance(artifact, source_type="html", document=identifier), } def event_row( *, meeting: MeetingLinks, event_type: str, instant: datetime | None, precision: str, artifact: Artifact, scheduled_at: datetime | None = None, suffix: str = "", **extra, ) -> dict: release_date, release_time = et_parts(instant) event_id = f"{meeting.meeting_id}_{event_type}" if suffix: event_id = f"{event_id}_{suffix}" row = { "event_id": event_id, "meeting_id": meeting.meeting_id, "event_type": event_type, "scheduled_at": scheduled_at, "release_at": instant, "knowledge_at": instant, "knowledge_date": instant, "release_date_et": release_date, "release_time_et": release_time, "timezone": RELEASE_TIMEZONE, "knowledge_time_precision": precision, "status": "published" if instant is not None else "quarantined", **provenance(artifact, source_type="html", document=event_id), } row.update(extra) return row async def build_meeting(fetcher: Fetcher, meeting: MeetingLinks) -> Rows: """Every row one meeting produces, from whatever documents exist for it.""" rows = Rows() statement = None if meeting.statement_url: artifact = await fetcher.get(meeting.statement_url, allow_missing=True) if artifact is None: rows.quarantined.append( Quarantined(meeting.meeting_id, "statement", meeting.statement_url, "not found") ) else: statement = parse_statement(artifact.text) if statement.release_at is None: rows.quarantined.append( Quarantined( meeting.meeting_id, "statement", artifact.url, "no release instant" ) ) else: mid = ( (statement.target_rate_lower + statement.target_rate_upper) / 2 if statement.target_rate_lower is not None and statement.target_rate_upper is not None else None ) event = event_row( meeting=meeting, event_type="STATEMENT", instant=statement.release_at, precision=statement.knowledge_time_precision, artifact=artifact, target_rate_lower=statement.target_rate_lower, target_rate_upper=statement.target_rate_upper, target_rate_mid=mid, decision=statement.decision, vote_for=statement.vote_for, vote_against=statement.vote_against, ) rows.events.append(event) rows.documents.append( document_row( meeting=meeting, event_id=event["event_id"], kind="statement", artifact=artifact, title=statement.article.title, text=statement.text, instant=statement.release_at, precision=statement.knowledge_time_precision, ) ) for index, voter in enumerate(statement.voters): rows.votes.append( { "vote_id": f"{event['event_id']}_{index:02d}", "meeting_id": meeting.meeting_id, "event_id": event["event_id"], "member_name": voter.name, "vote": voter.vote, "dissent": voter.vote == "against", "preferred_action_text": ( statement.dissent_text if voter.vote == "against" else None ), "source_url": artifact.url, "knowledge_at": statement.release_at, "knowledge_date": statement.release_at, "parser_version": PARSER_VERSION, "ingested_at": datetime.now(UTC), } ) artifact = await implementation_document(fetcher, meeting) if artifact is not None: note = parse_implementation_note(artifact.text) if note.release_at is None: rows.quarantined.append( Quarantined( meeting.meeting_id, "implementation_note", artifact.url, "no release instant" ) ) else: event = event_row( meeting=meeting, event_type="IMPLEMENTATION_NOTE", instant=note.release_at, precision=note.knowledge_time_precision, artifact=artifact, iorb_rate=note.iorb_rate, on_rrp_rate=note.on_rrp_rate, primary_credit_rate=note.primary_credit_rate, ) rows.events.append(event) rows.documents.append( document_row( meeting=meeting, event_id=event["event_id"], kind="implementation_note", artifact=artifact, title=note.article.title, text=note.text, instant=note.release_at, precision=note.knowledge_time_precision, ) ) projections = await projections_document(fetcher, meeting) if projections is not None: instant = end_of_day(meeting.end_date) precision = "date" if statement is not None and statement.release_at is not None: # The projections are embargoed with the statement and carry no # line of their own. The statement's instant is the one fact about # that minute, and using it is neither early nor invented. instant, precision = statement.release_at, statement.knowledge_time_precision parsed = parse_projections(projections.text) if not parsed.projections and not parsed.dots: rows.quarantined.append( Quarantined(meeting.meeting_id, "sep", projections.url, "no projections parsed") ) else: event = event_row( meeting=meeting, event_type="SEP", instant=instant, precision=precision, artifact=projections, ) rows.events.append(event) for index, projection in enumerate(parsed.projections): rows.sep.append( { "sep_id": f"{meeting.meeting_id}_SEP_{index:03d}", "meeting_id": meeting.meeting_id, "release_at": instant, "knowledge_at": instant, "knowledge_date": instant, "variable": projection.variable, "projection_year": projection.projection_year, "central_tendency_low": projection.central_tendency_low, "central_tendency_high": projection.central_tendency_high, "range_low": projection.range_low, "range_high": projection.range_high, "median": projection.median, "unit": projection.unit, "source_url": projections.url, "extraction_method": parsed.extraction_method, "parser_version": PARSER_VERSION, "ingested_at": datetime.now(UTC), } ) for index, dot in enumerate(parsed.dots): rows.dot_plot.append( { "dot_id": f"{meeting.meeting_id}_DOT_{index:03d}", "meeting_id": meeting.meeting_id, "release_at": instant, "knowledge_at": instant, "knowledge_date": instant, "projection_year": dot.projection_year, "rate_level": dot.rate_level, "dot_count": dot.dot_count, "source_url": projections.url, "extraction_method": parsed.dot_extraction_method, "parser_version": PARSER_VERSION, "ingested_at": datetime.now(UTC), } ) for index, (url, kind, document_type) in enumerate(_side_documents(meeting)): artifact = await fetcher.get(url, allow_missing=True) if artifact is None: continue page = read_article(artifact.text) instant, precision = release_instant( "\n".join(filter(None, (page.release_line, page.text))), on=page.posted_on ) if instant is None: rows.quarantined.append( Quarantined(meeting.meeting_id, document_type, url, "no release instant") ) continue event = event_row( meeting=meeting, event_type=kind, instant=instant, precision=precision, artifact=artifact, suffix=f"{index:02d}" if kind == "OTHER_POLICY_DOCUMENT" else "", ) rows.events.append(event) rows.documents.append( document_row( meeting=meeting, event_id=event["event_id"], kind=document_type, suffix=f"{index:02d}" if kind == "OTHER_POLICY_DOCUMENT" else "", artifact=artifact, title=page.title, text=page.text, instant=instant, precision=precision, ) ) if meeting.press_conference_url: artifact = await fetcher.get(meeting.press_conference_url, allow_missing=True) if artifact is not None: # The Chair's press conference is a live broadcast, and its page # states no time. Half an hour after the statement is when it # begins, but the Board does not write that down anywhere on the # page, so the day is all that is claimed here. instant = end_of_day(meeting.end_date) rows.events.append( event_row( meeting=meeting, event_type="PRESS_CONFERENCE", instant=instant, precision="date", artifact=artifact, ) ) if meeting.minutes_url: artifact = await fetcher.get(meeting.minutes_url, allow_missing=True) if artifact is None: rows.quarantined.append( Quarantined(meeting.meeting_id, "minutes", meeting.minutes_url, "not found") ) elif meeting.minutes_released_on is None: # The minutes page states no date of its own. Without the # calendar's release date there is no honest instant for it, and # the meeting date would be three weeks early. rows.quarantined.append( Quarantined( meeting.meeting_id, "minutes", artifact.url, "no stated minutes release date" ) ) else: page = read_article(artifact.text) instant = end_of_day(meeting.minutes_released_on) event = event_row( meeting=meeting, event_type="MINUTES", instant=instant, precision="date", artifact=artifact, ) rows.events.append(event) rows.documents.append( document_row( meeting=meeting, event_id=event["event_id"], kind="minutes", artifact=artifact, title=page.title, text=page.text, instant=instant, precision="date", ) ) known = [row["knowledge_at"] for row in rows.events if row["knowledge_at"] is not None] # A meeting with no documents yet -- every scheduled future one -- is still # knowable: the calendar says it is coming. That is the only thing about it # that is knowable, and it is the instant the row is indexed on. scheduled_known, _ = schedule_known_at(meeting, now=datetime.now(UTC)) rows.meetings.append( { "meeting_id": meeting.meeting_id, "meeting_start_date": meeting.start_date, "meeting_end_date": meeting.end_date, "meeting_type": meeting.meeting_type, "scheduled": meeting.meeting_type == "scheduled", "has_statement": any(row["event_type"] == "STATEMENT" for row in rows.events), "has_implementation_note": any( row["event_type"] == "IMPLEMENTATION_NOTE" for row in rows.events ), "has_minutes": any(row["event_type"] == "MINUTES" for row in rows.events), "has_sep": any(row["event_type"] == "SEP" for row in rows.events), "has_press_conference": meeting.press_conference_url is not None, "chair": None, "knowledge_date": min(known) if known else scheduled_known, "source_url": meeting.source_url, "ingested_at": datetime.now(UTC), } ) return rows def schedule_known_at(meeting: MeetingLinks, *, now: datetime) -> tuple[datetime, str]: """When the fact *this meeting is on the calendar* was safely public. The Committee publishes each year's meeting dates well before that year begins -- the 2026 dates were announced in June 2024 -- but it does not publish, anywhere, the day on which it announced them. Rather than invent that date, the schedule is treated as knowable from the start of the meeting's own year, which is months after the announcement and never before it. `knowledge_time_precision` says `modeled_conservative` to mark that this instant is a rule rather than a reading. Two cases are not modelled. A meeting still in the future is knowable now, because this run just read it off the calendar. And an unscheduled meeting or conference call was on no calendar in advance at all, so it becomes knowable at the end of the day it was held. """ if meeting.meeting_type != "scheduled": return end_of_day(meeting.end_date), "date" year_start = end_of_day(date(meeting.end_date.year - 1, 12, 31)) return min(year_start, now), "modeled_conservative" def _side_documents(meeting: MeetingLinks) -> list[tuple[str, str, str]]: """The policy documents a meeting publishes alongside its statement. The framework statement -- *Statement on Longer-Run Goals and Monetary Policy Strategy* -- is revised most Januaries and was rewritten in 2020 and again in 2025. It is not the policy statement, it names no interest rate, and reading it as one leaves a meeting whose decision is unknown. """ found: list[tuple[str, str, str]] = [] if meeting.longer_run_url: found.append((meeting.longer_run_url, "LONGER_RUN_STRATEGY", "longer_run_strategy")) found.extend( (url, "OTHER_POLICY_DOCUMENT", "other") for url, _label in meeting.other_documents ) return found def calendar_rows(meetings: list[MeetingLinks], *, announced_at: datetime) -> list[dict]: """The schedule as a forecast of publications, dated when it was knowable. A calendar entry is a claim about the future, and the column that matters is not the meeting date but the instant the entry itself became public. Without that, joining the calendar to prices would let a backtest in 2015 see that the Committee met in 2026. """ today = announced_at.date() rows = [] for meeting in meetings: known, precision = schedule_known_at(meeting, now=announced_at) rows.append( { "calendar_id": f"{meeting.meeting_id}_CAL", "meeting_id": meeting.meeting_id, "meeting_start_date": meeting.start_date, "meeting_end_date": meeting.end_date, "scheduled_at": end_of_day(meeting.end_date), "status": "held" if meeting.end_date < today else "scheduled", "has_sep_scheduled": meeting.has_projections_marker or meeting.has_sep, "timezone": RELEASE_TIMEZONE, "knowledge_time_precision": precision, "knowledge_date": known, "source_url": meeting.source_url, "ingested_at": datetime.now(UTC), } ) return rows # --------------------------------------------------------------------------- # The run. async def build( *, settings: Settings, limit: int | None = None, refresh: bool = False ) -> tuple[dict[str, pl.DataFrame], list[Quarantined]]: user_agent = validate_user_agent(settings.user_agent) async with Fetcher( user_agent=user_agent, cache_dir=Path(settings.cache_dir), requests_per_second=settings.requests_per_second, force_revalidate=refresh, ) as fetcher: meetings = await discover(fetcher, from_year=settings.backfill_from_year) if limit: meetings = meetings[-limit:] LOGGER.info("%d meetings discovered from %d", len(meetings), settings.backfill_from_year) collected = Rows() for index, meeting in enumerate(meetings, start=1): collected.extend(await build_meeting(fetcher, meeting)) if index % 25 == 0: LOGGER.info("%d/%d meetings read", index, len(meetings)) collected.calendar.extend( calendar_rows(meetings, announced_at=datetime.now(UTC)) ) frames = { "events": align(_frame(collected.events, EVENT_SCHEMA), EVENT_SCHEMA), "meetings": align(_frame(collected.meetings, MEETING_SCHEMA), MEETING_SCHEMA), "documents": align(_frame(collected.documents, DOCUMENT_SCHEMA), DOCUMENT_SCHEMA), "sep": align(_frame(collected.sep, SEP_SCHEMA), SEP_SCHEMA), "dot_plot": align(_frame(collected.dot_plot, DOT_PLOT_SCHEMA), DOT_PLOT_SCHEMA), "votes": align(_frame(collected.votes, VOTE_SCHEMA), VOTE_SCHEMA), "calendar": align(_frame(collected.calendar, CALENDAR_SCHEMA), CALENDAR_SCHEMA), } frames["events"] = with_rate_changes(frames["events"]) frames["pit"] = build_pit(frames) return frames, collected.quarantined def with_rate_changes(events: pl.DataFrame) -> pl.DataFrame: """`rate_change_bp`: this statement's midpoint against the last one's. Computed across statements in the order they were published, not in the order the meetings were held. The two agree for every scheduled meeting and disagree for none observed so far, but an inter-meeting cut announced between two scheduled meetings would be the case where they differ, and publication order is the one a reader lived through. """ if events.is_empty(): return events statements = ( events.filter(pl.col("event_type") == "STATEMENT") .sort("knowledge_at") .with_columns( previous_mid=pl.col("target_rate_mid").forward_fill().shift(1), ) .with_columns( computed=((pl.col("target_rate_mid") - pl.col("previous_mid")) * 100).round(2) ) .select("event_id", "computed") ) return ( events.join(statements, on="event_id", how="left") .with_columns(rate_change_bp=pl.col("computed")) .drop("computed") ) def _frame(rows: list[dict], schema: dict) -> pl.DataFrame: # `infer_schema_length=None` because a column whose first hundred rows are # null is not a null column; it is a column whose values start later. if not rows: return pl.DataFrame(schema=dict(schema)) return pl.DataFrame(rows, infer_schema_length=None) def run_build( *, settings: Settings, limit: int | None = None, rebuild: bool = False ) -> BuildResult: frames, quarantined = asyncio.run(build(settings=settings, limit=limit, refresh=rebuild)) data_dir = Path(settings.data_dir) counts = {name: write_table(data_dir, name, frame) for name, frame in frames.items()} # ziplime mounts the bundle from a Delta table, not from the parquet parts. # Both are published: the parquet is what a reader browses, the Delta table # is what the engine opens. delta = data_dir / "pit" / PIT_DELTA_NAME if delta.exists(): shutil.rmtree(delta) delta.parent.mkdir(parents=True, exist_ok=True) frames["pit"].write_delta(str(delta), mode="overwrite") quarantine = pl.DataFrame( [ { "meeting_id": item.meeting_id, "document_type": item.document_type, "url": item.url, "reason": item.reason, "country": COUNTRY, "quarantined_at": datetime.now(UTC), } for item in quarantined ], schema={ "meeting_id": pl.String, "document_type": pl.String, "url": pl.String, "reason": pl.String, "country": pl.String, "quarantined_at": pl.Datetime(time_unit="us", time_zone="UTC"), }, ) metadata = data_dir.resolve().parent / "metadata" metadata.mkdir(parents=True, exist_ok=True) quarantine.write_parquet(metadata / "quarantine.parquet", compression="zstd") write_coverage(frames, metadata_dir=metadata) write_build_record(frames, metadata_dir=metadata, quarantined=len(quarantined)) return BuildResult(counts=counts, quarantined=quarantined) __all__ = [ "PIT_DELTA_NAME", "BuildResult", "Quarantined", "build", "build_meeting", "calendar_rows", "discover", "run_build", "schedule_known_at", "with_rate_changes", ]