Cara Membangun Dashboard Makro di Python dengan panda & Plotly

Sebuah dasbor makro menempatkan indikator bank sentral dan ekonomi yang paling penting di satu tempat, sehingga Anda dapat memindai kondisi pasar dalam hitungan detik alih-alih memantul antara terminal data. panduan ini berjalan Anda melalui membangun penuh interaktif, multi-panel dasbor di Python mengambil data indikator hidup dari FXMacroData API, membentuk kembali dengan panda, dan membuatnya dengan Dengan sengajaSetiap panel diperbarui dari satu kunci API dan beberapa panggilan fungsi.

Persyaratan

Sebelum memulai, Anda perlu hal berikut:

• Python 3.9+
• Kunci API FXMacroData daftar di /langganan dan menyalin kunci Anda dari dasbor
• Paket PythonAku tidak tahu. requestsAku akan pergi. pandasAku akan pergi. plotly

Instal ketergantungan dalam satu perintah:

pip install requests pandas plotly

Simpan kunci API Anda sebagai variabel lingkungan tidak pernah hard-code kredensial dalam skrip:

export FXMD_API_KEY="YOUR_API_KEY"

Langkah 1 Memahami Bentuk Endpoint Indikator

Setiap indikator FXMacroData mengikuti pola REST yang sama, yang membuatnya sepele untuk menggeneralisasi ke dalam fungsi pengambilan tunggal.

GET https://fxmacrodata.com/api/v1/announcements/usd/policy_rate?api_key=YOUR_API_KEY&start=2020-01-01

Tanggapan JSON adalah objek datar dengan data array:

{
  "data": [
    { "date": "2025-03-19", "val": 4.25, "announcement_datetime": "2025-03-19T18:00:00Z" },
    { "date": "2025-01-29", "val": 4.25, "announcement_datetime": "2025-01-29T19:00:00Z" },
    { "date": "2024-12-18", "val": 4.25, "announcement_datetime": "2024-12-18T19:00:00Z" }
  ]
}

Setiap rekaman membawa date (YYY-MM-DD), sebuah angka val, dan jika tersedia UTC tingkat dua announcement_datetimeBentuk yang konsisten di semua indikator adalah apa yang memungkinkan satu fungsi melayani setiap panel di dasbor.

Langkah 2 Tuliskan fungsi fetch yang dapat digunakan kembali

Buat modul bernama macro_fetch.pyFungsi di bawah ini meminta indikator untuk mata uang apa pun, mengkonversi tanggapan ke seri panda, dan mengembalikannya diindeks oleh tanggal siap untuk langsung ke dalam DataFrame.

import os
import requests
import pandas as pd

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY = os.environ["FXMD_API_KEY"]


def fetch_indicator(currency: str, indicator: str, start: str = "2020-01-01") -> pd.Series:
    """
    Fetch a single indicator series from FXMacroData and return it as a
    pandas Series with a DatetimeIndex, named '{currency.upper()}_{indicator}'.
    """
    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params={"api_key": API_KEY, "start": start}, timeout=15)
    resp.raise_for_status()

    records = resp.json().get("data", [])
    if not records:
        return pd.Series(name=f"{currency.upper()}_{indicator}", dtype=float)

    series = (
        pd.DataFrame(records)
        .assign(date=lambda df: pd.to_datetime(df["date"]))
        .set_index("date")["val"]
        .sort_index()
        .rename(f"{currency.upper()}_{indicator}")
    )
    return series

Langkah 3 Ambil Semua Indikator untuk Dashboard

Dengan bantuan mengambil di tempat, menarik empat indikator untuk empat mata uang adalah loop ringkas.

import time

CURRENCIES = ["usd", "eur", "gbp", "aud"]
INDICATORS = {
    "policy_rate": "Policy Rate (%)",
    "inflation": "CPI Inflation (% YoY)",
    "unemployment": "Unemployment Rate (%)",
    "pmi": "Manufacturing PMI",
}


def fetch_all(start: str = "2020-01-01", retries: int = 3) -> dict[str, pd.DataFrame]:
    """
    Return a dict mapping each indicator slug to a wide DataFrame where
    each column is one currency (e.g. USD_policy_rate, EUR_policy_rate).
    """
    frames: dict[str, list[pd.Series]] = {ind: [] for ind in INDICATORS}

    for currency in CURRENCIES:
        for indicator in INDICATORS:
            for attempt in range(retries):
                try:
                    s = fetch_indicator(currency, indicator, start=start)
                    frames[indicator].append(s)
                    break
                except requests.HTTPError as exc:
                    if attempt == retries - 1:
                        print(f"Warning: could not fetch {currency}/{indicator}: {exc}")
                    else:
                        time.sleep(1.5 ** attempt)

    return {ind: pd.concat(series, axis=1) for ind, series in frames.items() if series}

Anda dapat memeriksa DataFrame secara interaktif untuk memverifikasi tampilan data sebelum render:

data = fetch_all(start="2021-01-01")
print(data["policy_rate"].tail())
# Output (example):
#             USD_policy_rate  EUR_policy_rate  GBP_policy_rate  AUD_policy_rate
# date
# 2025-01-29             4.25              NaN              NaN              NaN
# 2025-02-06              NaN              NaN             4.50              NaN
# 2025-02-18              NaN              NaN              NaN             4.10
# 2025-03-06              NaN             2.50              NaN              NaN
# 2025-03-19             4.25              NaN              NaN              NaN

Langkah 4 Bentuk data untuk grafik

Plot bekerja dengan baik. diisi ke depan seri untuk grafik garis, sehingga nilai yang paling baru diketahui diteruskan sampai rilis berikutnya.

def prepare_for_chart(df: pd.DataFrame) -> pd.DataFrame:
    """
    Forward-fill each column so lines in the chart step at each release date
    rather than showing gaps between announcements.
    Resample to a monthly frequency for a cleaner visual.
    """
    return (
        df
        .ffill()
        .resample("ME")      # month-end
        .last()
        .dropna(how="all")
    )

Untuk PMI, yang merupakan indikator bulanan, pengisian ke depan kurang relevan tetapi fungsi menangani dengan elegan dengan hanya melewati data bulanan yang tidak berubah.

Langkah 5 Buatlah Dashboard Plotly

Plotly's make_subplots Utilitas ini memungkinkan Anda mengatur beberapa grafik dalam objek gambar tunggal, yang dapat Anda tampilkan di browser, ekspor sebagai HTML, atau menyematkan dalam buku catatan Jupyter.

import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Palette aligned with FXMacroData brand colours
COLORS = {
    "usd": "#3B82F6",   # finance blue
    "eur": "#D97706",   # gold
    "gbp": "#16A34A",   # green
    "aud": "#7C3AED",   # purple
}

SUBPLOT_TITLES = list(INDICATORS.values())


def build_dashboard(data: dict[str, pd.DataFrame]) -> go.Figure:
    fig = make_subplots(
        rows=2, cols=2,
        subplot_titles=SUBPLOT_TITLES,
        shared_xaxes=False,
        vertical_spacing=0.12,
        horizontal_spacing=0.08,
    )

    positions = [(1, 1), (1, 2), (2, 1), (2, 2)]

    for (indicator, label), (row, col) in zip(INDICATORS.items(), positions):
        df = prepare_for_chart(data[indicator])
        for col_name in df.columns:
            currency = col_name.split("_")[0].lower()
            fig.add_trace(
                go.Scatter(
                    x=df.index,
                    y=df[col_name],
                    mode="lines",
                    name=currency.upper(),
                    line=dict(color=COLORS[currency], width=2),
                    legendgroup=currency,
                    showlegend=(indicator == "policy_rate"),  # one legend entry per currency
                    hovertemplate=f"%{{x|%b %Y}}: %{{y:.2f}}{mata uang.atas()}",
                ),
                row=row, col=col,
            )

    fig.update_layout(
        title=dict(
            text="G4 Central Bank Macro Dashboard",
            font=dict(size=22, color="#1e3a5f"),
            x=0.5,
        ),
        paper_bgcolor="#f8fafc",
        plot_bgcolor="#f1f5f9",
        font=dict(family="Inter, system-ui, sans-serif", size=12, color="#334155"),
        legend=dict(
            orientation="h",
            yanchor="bottom",
            y=1.04,
            xanchor="center",
            x=0.5,
        ),
        height=700,
        margin=dict(t=100, b=50, l=60, r=40),
    )

    fig.update_xaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)
    fig.update_yaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)

    return fig

Langkah 6 Jalankan Dashboard

Kabel semuanya bersama-sama dalam dashboard.py Aksara entry point. fig.show() membuka dashboard di browser default Anda. fig.write_html() menyimpan file HTML mandiri yang dapat Anda bagikan atau masukan di mana saja.

if __name__ == "__main__":
    print("Fetching macro data …")
    data = fetch_all(start="2021-01-01")

    print("Building dashboard …")
    fig = build_dashboard(data)

    # Option A: open in browser
    fig.show()

    # Option B: save as portable HTML file
    fig.write_html("macro_dashboard.html", include_plotlyjs="cdn")
    print("Saved macro_dashboard.html")

Jalankan dari terminal:

python dashboard.py

Plotly akan membuka jendela browser yang menampilkan dua baris, dua kolom dashboard dengan empat panel hidup satu untuk setiap indikator kode warna oleh mata uang.

Langkah 7 Tambahkan Anotasi Rilis-Tanggal (Opssional)

Salah satu peningkatan dasbor yang paling berguna adalah overlaying Penanda pelepasan garis vertikal atau titik yang menunjukkan persis kapan setiap pengumuman dibuat. announcement_datetime time stamp, jadi Anda dapat menambahkannya tanpa menebak:

def fetch_release_datetimes(currency: str, indicator: str, start: str) -> pd.Series:
    """Return a Series of UTC announcement datetimes for a given indicator."""
    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params={"api_key": API_KEY, "start": start}, timeout=15)
    resp.raise_for_status()
    records = resp.json().get("data", [])
    if not records:
        return pd.Series(dtype="datetime64[ns, UTC]")
    df = pd.DataFrame(records)
    if "announcement_datetime" not in df.columns:
        return pd.Series(dtype="datetime64[ns, UTC]")
    return pd.to_datetime(df["announcement_datetime"], utc=True)


def add_release_markers(fig: go.Figure, currency: str, indicator: str,
                         start: str, row: int, col: int) -> None:
    """Overlay vertical dashed lines on a subplot at each release datetime."""
    datetimes = fetch_release_datetimes(currency, indicator, start)
    for dt in datetimes:
        fig.add_vline(
            x=dt.timestamp() * 1000,  # Plotly uses ms since epoch for datetime axes
            line_width=1,
            line_dash="dot",
            line_color=COLORS[currency],
            opacity=0.35,
            row=row, col=col,
        )

Hubungi. add_release_markers Setelah build_dashboard dan sebelumnya. fig.show() Untuk mengomentari panel mana yang paling relevan dengan analisis Anda, penanda rilis sangat berguna pada panel suku bunga kebijakan, di mana tanggal keputusan jarang tetapi berdampak tinggi.

Langkah 8 Ekspor Panel sebagai Gambar Individu

Jika Anda ingin memasukkan grafik individu dalam laporan atau slide deck, Plotly dapat mengekspor setiap subplot sebagai PNG melalui KaleidoAku tidak tahu.

pip install kaleido

fig.write_image("macro_dashboard.png", width=1400, height=700, scale=2)

Untuk ekspor per panel, bangun setiap indikator sebagai independen go.Figure menggunakan yang sama. go.Scatter jejak dan panggilan write_image Fungsi mengambil dan bentuk yang dikembangkan pada langkah-langkah sebelumnya bekerja tidak berubah untuk tokoh panel tunggal.

Referensi Skripsi Lengkap

Di bawah ini adalah skrip lengkap, mandiri menggabungkan semua langkah di atas. dashboard.py, diatur FXMD_API_KEY, dan menjalankannya.

"""
macro_dashboard.py — G4 Central Bank Macro Dashboard
Requires: requests, pandas, plotly
Usage:    FXMD_API_KEY=your_key python macro_dashboard.py
"""
import os
import time
import requests
import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY = os.environ["FXMD_API_KEY"]

CURRENCIES = ["usd", "eur", "gbp", "aud"]
INDICATORS = {
    "policy_rate": "Policy Rate (%)",
    "inflation": "CPI Inflation (% YoY)",
    "unemployment": "Unemployment Rate (%)",
    "pmi": "Manufacturing PMI",
}
COLORS = {"usd": "#3B82F6", "eur": "#D97706", "gbp": "#16A34A", "aud": "#7C3AED"}


def fetch_indicator(currency: str, indicator: str, start: str = "2020-01-01") -> pd.Series:
    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params={"api_key": API_KEY, "start": start}, timeout=15)
    resp.raise_for_status()
    records = resp.json().get("data", [])
    if not records:
        return pd.Series(name=f"{currency.upper()}_{indicator}", dtype=float)
    return (
        pd.DataFrame(records)
        .assign(date=lambda df: pd.to_datetime(df["date"]))
        .set_index("date")["val"]
        .sort_index()
        .rename(f"{currency.upper()}_{indicator}")
    )


def fetch_all(start: str = "2020-01-01", retries: int = 3) -> dict[str, pd.DataFrame]:
    frames: dict[str, list[pd.Series]] = {ind: [] for ind in INDICATORS}
    for currency in CURRENCIES:
        for indicator in INDICATORS:
            for attempt in range(retries):
                try:
                    frames[indicator].append(fetch_indicator(currency, indicator, start))
                    break
                except requests.HTTPError as exc:
                    if attempt == retries - 1:
                        print(f"Warning: {currency}/{indicator}: {exc}")
                    else:
                        time.sleep(1.5 ** attempt)
    return {ind: pd.concat(series, axis=1) for ind, series in frames.items() if series}


def prepare_for_chart(df: pd.DataFrame) -> pd.DataFrame:
    return df.ffill().resample("ME").last().dropna(how="all")


def build_dashboard(data: dict[str, pd.DataFrame]) -> go.Figure:
    fig = make_subplots(
        rows=2, cols=2,
        subplot_titles=list(INDICATORS.values()),
        vertical_spacing=0.12,
        horizontal_spacing=0.08,
    )
    for (indicator, _), (row, col) in zip(INDICATORS.items(), [(1,1),(1,2),(2,1),(2,2)]):
        df = prepare_for_chart(data[indicator])
        for col_name in df.columns:
            currency = col_name.split("_")[0].lower()
            fig.add_trace(
                go.Scatter(
                    x=df.index, y=df[col_name], mode="lines",
                    name=currency.upper(),
                    line=dict(color=COLORS[currency], width=2),
                    legendgroup=currency,
                    showlegend=(indicator == "policy_rate"),
                    hovertemplate=f"%{{x|%b %Y}}: %{{y:.2f}}{mata uang.atas()}",
                ),
                row=row, col=col,
            )
    fig.update_layout(
        title=dict(text="G4 Central Bank Macro Dashboard", font=dict(size=22, color="#1e3a5f"), x=0.5),
        paper_bgcolor="#f8fafc", plot_bgcolor="#f1f5f9",
        font=dict(family="Inter, system-ui, sans-serif", size=12),
        legend=dict(orientation="h", yanchor="bottom", y=1.04, xanchor="center", x=0.5),
        height=700, margin=dict(t=100, b=50, l=60, r=40),
    )
    fig.update_xaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)
    fig.update_yaxes(showgrid=True, gridcolor="#e2e8f0", zeroline=False)
    return fig


if __name__ == "__main__":
    print("Fetching macro data …")
    data = fetch_all(start="2021-01-01")
    print("Building dashboard …")
    fig = build_dashboard(data)
    fig.show()
    fig.write_html("macro_dashboard.html", include_plotlyjs="cdn")
    print("Saved macro_dashboard.html")

Ringkasan

Anda sekarang memiliki dashboard makro yang berfungsi:

• Mengambil suku bunga kebijakan, inflasi, pengangguran, dan PMI untuk USD, EUR, GBP, dan AUD dari FXMacroData pengumuman titik akhir
• Mengubah bentuk data menjadi panda yang sejajar, yang diisi ke depan DataFrames
• Membuat empat panel interaktif Dashboard Plotly dengan garis mata uang yang dikodekan warna
• Ekspor file HTML mandiri yang dapat Anda bagikan atau masang

Dari sini Anda dapat memperluas dasbor dalam beberapa arah: menambahkan lebih banyak mata uang, overlay pengangguran Dengan menggunakan data yang terdaftar di database, Anda dapat melihat data yang dicatat di database yang tercatat di indeks indeks indeks perdagangan, atau mengkonversi data ke dalam jadwal yang diperbarui setiap pagi. api-data-docs.