import os
import requests

from dotenv import load_dotenv


load_dotenv()  # load environment variables from .env file


API_AUTH_HEADERS = {"Content-Type": "application/x-www-form-urlencoded"}
API_HOST = "https://api.empiricalmarkets.com"

def get_request_headers() -> dict:
    api_key = os.getenv("EM_API_KEY")
    if api_key is None:
        raise ValueError("API key not found. Please set the EM_API_KEY environment variable.")
    r = requests.post(
        f"{API_HOST}/v1/token",
        data={"api_key": api_key},
        headers={"Content-Type": "application/x-www-form-urlencoded"}
    )
    r.raise_for_status()
    token = r.json().get("access_token")
    request_headers = {"Authorization": "Bearer {}".format(token)}
    return request_headers

request_headers = get_request_headers()
print(str(request_headers)[:50] + "...}")

def get_me(request_headers: dict) -> dict:
    r = requests.get(f"{API_HOST}/v1/me", headers=request_headers)
    r.raise_for_status()
    return r.json()

get_me(request_headers)

import time

me_info = get_me(request_headers)

# Use the rate limit from the /me endpoint; fall back to 1 req/s (free tier)
_rate_limit_per_second = me_info.get("api_rate_limit_per_second") or 1
_min_interval = 1.0 / _rate_limit_per_second  # e.g. 1.0s for free, 0.33s for 3 req/s

def rate_limited_get(url: str, **kwargs) -> requests.Response:
    """Drop-in replacement for requests.get that respects the tier rate limit."""
    response = requests.get(url, **kwargs)
    time.sleep(_min_interval)
    return response

print(f"Built rate limit utility with allowed rate limit: {_rate_limit_per_second} req/s. The program will sleep {_min_interval:.2f}s between API calls.")

import pandas as pd

def get_asset_class_symbols(asset_class: str, request_headers: dict) -> list:
    if asset_class not in ["equities", "etfs"]:
        raise ValueError("Invalid asset class. Must be 'equities' or 'etfs'.")
    r = rate_limited_get(f"{API_HOST}/v1/catalog/assets/{asset_class}/tickers", headers=request_headers)
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["tickers"])
    df["asset_class"] = asset_class
    return df

get_asset_class_symbols(asset_class="equities", request_headers=request_headers)

def get_exchange_symbols(exchange: str, request_headers: dict) -> list:
    _allowed_exchanges = ["CBOE", "NASDAQ", "NYSE", "OTC"]
    if exchange not in _allowed_exchanges:
        raise ValueError(f"Invalid exchange. Must be one of {_allowed_exchanges}.")
    r = rate_limited_get(f"{API_HOST}/v1/catalog/exchanges/{exchange}/tickers", headers=request_headers)
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["tickers"], columns=["ticker"])
    df["exchange"] = exchange
    return df

get_exchange_symbols(exchange="NYSE", request_headers=request_headers)

def get_industry_codes(request_headers: dict):
    r = rate_limited_get(f"{API_HOST}/v1/catalog/sic", headers=request_headers)
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["sic_codes"])
    return df

get_industry_codes(request_headers=request_headers)

def get_industry_code_symbols(sic_code: str, request_headers: dict):
    r = rate_limited_get(f"{API_HOST}/v1/catalog/sic/{sic_code}/tickers", headers=request_headers)
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["tickers"], columns=["ticker"])
    df["sic_code"] = sic_code
    return df

get_industry_code_symbols(sic_code="3571", request_headers=request_headers)

def get_ticker_info(ticker: str, request_headers: dict) -> dict:
    r = rate_limited_get(f"{API_HOST}/v1/catalog/tickers/{ticker}", headers=request_headers)
    r.raise_for_status()
    return pd.Series(r.json())

get_ticker_info(ticker="AAPL", request_headers=request_headers)

def get_ticker_sec_filings(ticker: str, request_headers: dict) -> pd.DataFrame:
    r = rate_limited_get(f"{API_HOST}/v1/company/{ticker}/filings", headers=request_headers, params={"order": "desc", "limit": 500})
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["filings"])
    df["ticker"] = ticker
    return df

get_ticker_sec_filings(ticker="AAPL", request_headers=request_headers)

import matplotlib.pyplot as plt

plt.style.use("dark_background")


def get_ticker_ohlc_prices(ticker: str, start_date: str = "2023-01-01"):
    r = rate_limited_get(
        f"{API_HOST}/v1/ohlc/tickers/{ticker}",
        headers=request_headers,
        params={"limit": 1000, "start_date": start_date}
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["data"])

def plot_ticker_ohlc_prices(tickers: list[str], start_date: str = "2023-01-01"):
    plt.figure(figsize=(12, 6))
    for ticker in tickers:
        price_df = get_ticker_ohlc_prices(ticker, start_date=start_date)
        price_df["date"] = pd.to_datetime(price_df["date"])
        price_df = price_df.set_index("date").sort_index()
        display(price_df.head(3))
        price_df["close_pct"] = price_df["close"].pct_change().cumsum()
        plt.plot(price_df["close_pct"], label=ticker)
    plt.title(f"Cumulative Returns")
    plt.xlabel("Date")
    plt.ylabel("Price")
    plt.legend()
    plt.grid()
    plt.show()

plot_ticker_ohlc_prices(tickers=["AAPL", "TSLA", "NVDA"], start_date="2023-01-01")

def get_ticker_ta_indicator(ticker: str, indicator: str, start_date: str = "2024-01-01"):
    r = rate_limited_get(
        f"{API_HOST}/v1/technicals/{indicator}/tickers/{ticker}",
        headers=request_headers,
        params={"start_date": "2024-01-01", "limit": 1000}
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["data"])


def plot_ticker_bollinger_bands(ticker: str, start_date: str = "2023-01-01"):
    price_df = get_ticker_ohlc_prices(ticker, start_date=start_date)
    price_df["date"] = pd.to_datetime(price_df["date"])
    price_df = price_df.set_index("date").sort_index()

    ta_df = get_ticker_ta_indicator(ticker, indicator="bollinger-bands", start_date=start_date)
    display(ta_df)
    ta_df["date"] = pd.to_datetime(ta_df["date"])
    ta_df = ta_df.set_index("date").sort_index()

    plot_df = ta_df[["lower", "upper"]].merge(price_df[["close"]], how="inner", left_index=True, right_index=True)

    fig, ax = plt.subplots(figsize=(12, 6))

    plot_df["close"].plot(ax=ax, label=f"{ticker} Price")
    plot_df[["lower", "upper"]].plot(ax=ax, label="Bollinger Bands")
    ax.legend()
    plt.title(f"{ticker} Price with Bollinger Bands")
    plt.show()

plot_ticker_bollinger_bands(ticker="AAPL", start_date="2023-01-01")

def plot_ticker_rsi(ticker: str, start_date: str = "2023-01-01"):
    price_df = get_ticker_ohlc_prices(ticker, start_date=start_date)
    price_df["date"] = pd.to_datetime(price_df["date"])
    price_df = price_df.set_index("date").sort_index()

    ta_df = get_ticker_ta_indicator(ticker, indicator="relative-strength-index", start_date=start_date)
    display(ta_df)
    ta_df["date"] = pd.to_datetime(ta_df["date"])
    ta_df = ta_df.set_index("date").sort_index()

    plot_df = ta_df[["value"]].merge(price_df[["close"]], how="inner", left_index=True, right_index=True)

    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 6), sharex=True, gridspec_kw={"height_ratios": [3, 1]})
    plot_df["close"].plot(ax=ax1, label=f"{ticker} Price")
    ax1.legend(loc="upper left")

    plot_df["value"].plot(ax=ax2, label="RSI")
    ax2.axhline(70, linestyle="--", alpha=0.5)
    ax2.axhline(30, linestyle="--", alpha=0.5)
    ax2.legend(loc="upper left")
    plt.suptitle(f"{ticker} Price vs RSI")
    plt.show()

plot_ticker_rsi(ticker="AAPL")

def get_available_quant_signals():
    r = rate_limited_get(f"{API_HOST}/v1/quant/signals", headers=request_headers)
    r.raise_for_status()
    return r.json()["signals"]

def get_ticker_quant_signal(ticker: str, signal: str, start_date: str = "2024-01-01"):
    r = rate_limited_get(
        f"{API_HOST}/v1/quant/signals/{signal}/tickers/{ticker}",
        headers=request_headers,
        params={"start_date": start_date, "limit": 1000}
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["data"])

def plot_ticker_quant_signal(ticker: str, signal: str, start_date: str = "2024-01-01"):
    quant_signal = get_ticker_quant_signal(ticker, signal, start_date=start_date)
    quant_signal["date"] = pd.to_datetime(quant_signal["date"])
    quant_signal = quant_signal.set_index("date").sort_index()
    display(quant_signal)

    price_df = get_ticker_ohlc_prices(ticker, start_date=start_date)
    price_df["date"] = pd.to_datetime(price_df["date"])
    price_df = price_df.set_index("date").sort_index()

    fig, ax = plt.subplots(figsize=(12, 6))
    price_df["close"].plot(ax=ax, label=f"{ticker} Price")
    ax2 = ax.twinx()
    quant_signal["value"].plot(ax=ax2, label=signal, color="orange", alpha=0.7)
    ax.legend(loc="upper left")
    ax2.legend(loc="upper right")
    plt.title(f"{ticker} Price vs {signal}")
    plt.show()

plot_ticker_quant_signal(ticker="NVDA", signal="flow-ratio")

def get_ticker_quant_anomalies(ticker: str, signal: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/quant/signals/{signal}/tickers/{ticker}/anomalies",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["anomalies"])  # is ordered by value (desc)


def plot_ticker_flow_ratio_anomalies(ticker: str, signal: str, label: str):
    anomaly_df = get_ticker_quant_anomalies(ticker=ticker, signal=signal)
    if anomaly_df.empty:
        print(f"No {signal} anomalies found for {ticker}")
        return
    anomaly_df["date"] = pd.to_datetime(anomaly_df["date"])
    anomaly_df = anomaly_df.set_index("date").sort_index()
    display(anomaly_df.head(5))

    price_df = get_ticker_ohlc_prices(ticker=ticker, start_date="2023-01-01")
    price_df["date"] = pd.to_datetime(price_df["date"])
    price_df = price_df.set_index("date").sort_index()

    plot_df = price_df[["close"]].merge(anomaly_df[["value"]], how="left", left_index=True, right_index=True)
    anomaly_points = plot_df[plot_df["value"].notna()]
    # anomaly_points = plot_df[plot_df["value"] > 2.]

    fig, ax = plt.subplots(figsize=(12, 6))
    ax.plot(plot_df.index, plot_df["close"], label=f"{ticker} Price")
    ax.scatter(
        anomaly_points.index,
        anomaly_points["close"],
        label=label,
        color="magenta",
        s=80,
        zorder=5
    )

    ax.legend()
    ax.set_title(f"{ticker} {label}")
    plt.show()


plot_ticker_flow_ratio_anomalies(ticker="TSLA", signal="relative-volatility", label="Relative Volatility Anomalies")
plot_ticker_flow_ratio_anomalies(ticker="GLD", signal="flow-ratio", label="Flow Ratio Anomalies")
# plot_ticker_flow_ratio_anomalies(ticker="JNJ", signal="drift-strength", label="Drift Strength Anomalies")

def get_ticker_capm(ticker: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/quant/capm/tickers/{ticker}",
        headers=request_headers,
        params={"start_date": "2024-01-01", "limit": 1000}
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["data"])

get_ticker_capm(ticker="AAPL")

def get_ticker_pairwise_correlation(ticker: str, other_ticker: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/quant/correlation/tickers/{ticker}/pairwise/{other_ticker}",
        headers=request_headers,
        params={"start_date": "2024-01-01", "limit": 1000}
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["data"])

def plot_ticker_pairwise_correlation(ticker: str, other_ticker: str):
    corr_df = get_ticker_pairwise_correlation(ticker, other_ticker)
    corr_df["date"] = pd.to_datetime(corr_df["date"])
    corr_df = corr_df.set_index("date").sort_index()
    display(corr_df.head(3))

    price_df_1 = get_ticker_ohlc_prices(ticker, start_date="2025-01-01")
    price_df_1["date"] = pd.to_datetime(price_df_1["date"])
    price_df_1 = price_df_1.set_index("date").sort_index()
    price_df_1 = price_df_1[price_df_1.index.isin(corr_df.index)]
    price_df_1["close_pct"] = price_df_1["close"].pct_change().cumsum()

    price_df_2 = get_ticker_ohlc_prices(other_ticker, start_date="2025-01-01")
    price_df_2["date"] = pd.to_datetime(price_df_2["date"])
    price_df_2 = price_df_2.set_index("date").sort_index()
    price_df_2 = price_df_2[price_df_2.index.isin(corr_df.index)]
    price_df_2["close_pct"] = price_df_2["close"].pct_change().cumsum()


    fig, ax1 = plt.subplots(figsize=(12, 6))
    ax1.plot(price_df_1.index, price_df_1["close_pct"], label=f"{ticker} Cumulative Returns")
    ax1.plot(price_df_2.index, price_df_2["close_pct"], label=f"{other_ticker} Cumulative Returns")
    ax1.legend(loc="upper left")

    ax2 = ax1.twinx()
    ax2.plot(corr_df.index, corr_df["value"], label="Pairwise Correlation", color="orange")
    ax2.legend(loc="upper right")

    plt.title(f"Pairwise Correlation between {ticker} and {other_ticker}")
    plt.show()

# get_ticker_pairwise_correlation(ticker="AAPL", other_ticker="MSFT")
plot_ticker_pairwise_correlation(ticker="AAPL", other_ticker="MSFT")

def plot_ticker_ai_prediction_events(ticker: str, event: str, color: str = "green"):
    r = rate_limited_get(
        f"{API_HOST}/v1/ai/events/{event}/tickers/{ticker}",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    subtitle = f"{r['event']}: {r['event_description']}"
    event_df = pd.DataFrame(r["data"])
    if event_df.empty:
        print(f"No {event} events found for {ticker}")
        return
    event_df["date"] = pd.to_datetime(event_df["date"])
    event_df = event_df.set_index("date").sort_index()
    display(event_df.head(4))

    price_df = get_ticker_ohlc_prices(ticker=ticker, start_date="2025-01-01")
    price_df["date"] = pd.to_datetime(price_df["date"])
    price_df = price_df.set_index("date").sort_index()

    plot_df = price_df[["close"]].merge(event_df[["value"]], how="left", left_index=True, right_index=True)
    event_points = plot_df[plot_df["value"].notna()]

    fig, ax = plt.subplots(figsize=(12, 6))
    ax.plot(plot_df.index, plot_df["close"], label=f"{ticker} Price")
    ax.scatter(
        event_points.index,
        event_points["close"],
        label=event,
        color=color,
        s=80,
        zorder=5
    )

    ax.legend()
    plt.suptitle(f"{ticker} AI Prediction Events")
    ax.set_title(subtitle)
    plt.show()

plot_ticker_ai_prediction_events(ticker="AAPL", event="upside-risk-elevated", color="green")

plot_ticker_ai_prediction_events(ticker="TSLA", event="downside-risk-elevated", color="red")

plot_ticker_ai_prediction_events(ticker="AAPL", event="high-reclaimed", color="green")

plot_ticker_ai_prediction_events(ticker="AAPL", event="low-reclaimed", color="red")

def get_ai_event_models(event: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/ai/events/{event}/models",
        headers=request_headers,
    )
    r.raise_for_status()
    return r.json()

def get_latest_ai_model_version_metrics(event: str):
    models = get_ai_event_models(event=event)
    latest_model = models["models"][0]
    latest_model_id = latest_model["model_id"]
    r = rate_limited_get(
        f"{API_HOST}/v1/ai/events/{event}/models/{latest_model_id}/metrics",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    r["metrics"] = pd.DataFrame(r["metrics"])
    return r

for k, v in get_latest_ai_model_version_metrics(event="upside-risk-elevated").items():
    print(f"{k}:\n{v}" if isinstance(v, pd.DataFrame) else f"{k}: {v}")
print("*"*20)
for k, v in get_latest_ai_model_version_metrics(event="downside-risk-elevated").items():
    print(f"{k}:\n{v}" if isinstance(v, pd.DataFrame) else f"{k}: {v}")
print("*"*20)

def get_sector_sentiment_info():
    r = rate_limited_get(
        f"{API_HOST}/v1/ai/sentiment/fed-market-sectors",
        headers=request_headers,
    )
    r.raise_for_status()
    return r.json()

get_sector_sentiment_info()

def get_sector_sentiment(sector: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/ai/sentiment/fed-market-sectors/dimensions/{sector}",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["sentiment"])
    df["score_name"] = df["score"].astype(str).map(r["value_map"])
    df["date"] = pd.to_datetime(df["date"])
    return df

get_sector_sentiment(sector="energy")

def get_ticker_instant_tags(ticker: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/fundamentals/tickers/{ticker}/instant/tags",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["tags"])

get_ticker_instant_tags(ticker="AAPL")

def get_ticker_latest_fundamentals(ticker: str, context: str = "instant"):
    if context not in ["instant", "duration"]:
        raise ValueError("Invalid context. Must be 'instant' or 'duration'.")

    r = rate_limited_get(
        f"{API_HOST}/v1/fundamentals/tickers/{ticker}/{context}/latest",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["data"])

get_ticker_latest_fundamentals(ticker="AAPL", context="instant").head(5)

def get_ticker_fundamental_tag(ticker: str, tag: str, context: str = "instant"):
    if context not in ["instant", "duration"]:
        raise ValueError("Invalid context. Must be 'instant' or 'duration'.")

    r = rate_limited_get(
        f"{API_HOST}/v1/fundamentals/tickers/{ticker}/{context}/tags/{tag}",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["data"])

def plot_ticker_fundamental_tag(ticker: str, tag: str, context: str = "instant"):
    tag_df = get_ticker_fundamental_tag(ticker=ticker, tag=tag, context=context)
    if tag_df.empty:
        print(f"No data found for {ticker} {tag} {context}")
        return
    tag_df["end_date"] = pd.to_datetime(tag_df["end_date"])
    tag_df = tag_df.set_index("end_date").sort_index()
    display(tag_df.head(3))

    plt.figure(figsize=(10, 6))
    tag_df["value"] = pd.to_numeric(tag_df["value"], errors="coerce")
    tag_df["value"].plot(title=f"{ticker} {tag} ({context})")
    plt.xlabel("Reporting End Date")
    plt.ylabel(tag)
    plt.grid()
    plt.show()

plot_ticker_fundamental_tag(ticker="AAPL", tag="AccountsReceivableNetCurrent", context="instant")

def plot_ticker_asset_liabilities(ticker: str):
    asset_tag = "AssetsCurrent"
    liabilities_tag = "LiabilitiesCurrent"
    assets_df = get_ticker_fundamental_tag(ticker=ticker, tag=asset_tag, context="instant")
    assets_df["end_date"] = pd.to_datetime(assets_df["end_date"])
    assets_df = assets_df.set_index("end_date").sort_index()
    
    liabilities_df = get_ticker_fundamental_tag(ticker=ticker, tag=liabilities_tag, context="instant")
    liabilities_df["end_date"] = pd.to_datetime(liabilities_df["end_date"])
    liabilities_df = liabilities_df.set_index("end_date").sort_index()

    combined_df = pd.DataFrame({
        "Assets": pd.to_numeric(assets_df["value"], errors="coerce"),
        "Liabilities": pd.to_numeric(liabilities_df["value"], errors="coerce")
    })

    combined_df.plot(title=f"{ticker} {asset_tag} vs {liabilities_tag}", figsize=(10, 6))
    plt.xlabel("Reporting End Date")
    plt.ylabel("Value")
    plt.grid()
    plt.show()

plot_ticker_asset_liabilities(ticker="AAPL")

def get_macro_collections():
    r = rate_limited_get(
        f"{API_HOST}/v1/macro/collections",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["collection_ids"])

get_macro_collections()

def get_collection_series(collection_id: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/macro/collections/{collection_id}/series",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["series_ids"])

get_collection_series(collection_id="cpi-u")

def get_collection_series_data(collection_id: str, series_id: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/macro/collections/{collection_id}/series/{series_id}",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["data"]).dropna(subset=["value"]).reset_index(drop=True)
    return df

def plot_macro_series_data(collection_id: str, series_id: str):
    df = get_collection_series_data(collection_id=collection_id, series_id=series_id)
    
    df["period_end"] = pd.to_datetime(df["period_end"])
    df = df.set_index("period_end").sort_index()
    display(df.head(3))
    
    plt.figure(figsize=(12, 6))
    df["value"].plot(title=f"{collection_id} - {series_id}")
    plt.xlabel("Date")
    plt.ylabel("Value")
    plt.grid()
    plt.show()

plot_macro_series_data(collection_id="cpi-u", series_id="CUSR0000SA0")

def get_macro_release_schedule(year: int):
    r = rate_limited_get(
        f"{API_HOST}/v1/macro/schedule/{year}",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["events"])

get_macro_release_schedule(year=2026)

def get_yield_curve_latest():
    r = rate_limited_get(
        f"{API_HOST}/v1/treasury/latest",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["data"])
    df["date"] = pd.to_datetime(df["date"])
    return df

def plot_yield_curve_latest():
    df = get_yield_curve_latest()
    df = df.set_index("maturity")
    display(df["rate"])

    plt.figure(figsize=(12, 6))
    df["rate"].plot(title="Latest U.S. Treasury Yield Curve", kind="bar")
    plt.xlabel("Date")
    plt.ylabel("Yield")
    plt.grid()
    plt.show()

plot_yield_curve_latest()

def get_yield_curve_spread(m1: str, m2: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/treasury/spread/{m1}/{m2}",
        headers=request_headers,
        params={"start_date": "2024-01-01", "limit": 1000}
    )
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["data"])
    df["date"] = pd.to_datetime(df["date"])
    return df

def plot_yield_curve_spread(m1: str, m2: str):
    df = get_yield_curve_spread(m1=m1, m2=m2)
    df = df.set_index("date").sort_index()
    display(df.head(3))

    plt.figure(figsize=(12, 6))
    df["spread"].plot(title=f"Yield Spread: {m1} - {m2}")
    plt.xlabel("Date")
    plt.ylabel("Yield Spread")
    plt.grid()
    plt.show()

plot_yield_curve_spread(m1="10yr", m2="2yr")

def get_ticker_insider_reports(ticker: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/insiders/tickers/{ticker}/reports",
        headers=request_headers,
        params={"limit": 300, "start_date": "2024-01-01"}
    )
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["reports"])
    return df

get_ticker_insider_reports(ticker="TSLA")

def get_ticker_insider_reporters(ticker: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/insiders/tickers/{ticker}/reporters",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["reporters"])
    return df

get_ticker_insider_reporters(ticker="TSLA")

def get_ticker_insiders_tx_codes(ticker: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/insiders/tickers/{ticker}/transactions/codes",
        headers=request_headers,
    )
    r.raise_for_status()
    r = r.json()
    return pd.DataFrame(r["codes"])

get_ticker_insiders_tx_codes(ticker="TSLA")

def get_ticker_insiders_transactions(ticker: str, code: str):
    r = rate_limited_get(
        f"{API_HOST}/v1/insiders/tickers/{ticker}/transactions/codes/{code}",
        headers=request_headers,
        params={"limit": 300, "start_date": "2024-01-01"}
    )
    r.raise_for_status()
    r = r.json()
    df = pd.DataFrame(r["transactions"])
    return df

get_ticker_insiders_transactions(ticker="TSLA", code="S")