Jupyter नोटबुक उन विश्लेषकों और डेवलपर्स के लिए पसंद का उपकरण है जो कोड, डेटा और टिप्पणी को एक एकल, साझा करने योग्य दस्तावेज़ में जोड़ना चाहते हैं। यह गाइड आपको एक पूर्ण एंड-टू-एंड वर्कफ़्लो के माध्यम से चलता हैः FXMacroData पायथन एसडीके स्थापित करना, अपनी एपीआई कुंजी सेट करना, मैक्रो संकेतक श्रृंखला प्राप्त करना, विश्लेषण करना और प्रकाशन के लिए तैयार चार्ट सभी एक एकल नोटबુક के अंदर उत्पन्न करना। अंत तक आपके पास एक कामकाजी, पुनः प्रयोज्य नोटबੁੱਕ होगी जिसे आप FXMacrodata के 80+ संकेतकों में से किसी के साथ भी विस्तारित कर सकते हैं।

आप क्या बनाएंगे

एक स्वतंत्र जूपीटर नोटबुक जो FXMacroData REST API के खिलाफ प्रमाणीकरण करता है, चार G10 मुद्राओं के लिए नीति दर और मुद्रास्फीति समय श्रृंखला खींचता है, वास्तविक दर स्प्रेड की गणना करता है और इंटरैक्टिव मल्टी-सीरीज चार्ट को साझा करने या आवर्ती रिपोर्ट के रूप में शेड्यूल करने के लिए तैयार करता है।

पूर्व शर्तें

पायथन 3.9 या बाद का संस्करण
Jupyter नोटबुक या JupytersLab के साथ स्थापित करें pip install jupyterlab
निम्नलिखित पैकेजः requests, pandas, matplotlib, seaborn
एक FXMacroData एपीआई कुंजी पर साइन अप करें /अपना नाम लिखें प्राप्त करना

आप एक कमांड में सभी निर्भरताएँ स्थापित कर सकते हैंः

pip install requests pandas matplotlib seaborn jupyterlab

फिर अपने प्रोजेक्ट फ़ोल्डर से JupyterLab लॉन्च करेंः

jupyter lab

चरण 1 अपनी एपीआई कुंजी सुरक्षित करें

नोटबुक फ़ाइल में हार्ड-कोड क्रेडेंशियल्स कभी नहीं नोटबूक गलती से साझा करना आसान है, और एक लीक एपीआई कुंजी का दुरुपयोग किया जा सकता है। सबसे सुरक्षित दृष्टिकोण कुंजी को एक पर्यावरण चर में संग्रहीत करना और इसे रनटाइम पर पढ़ना है।

लिनक्स/मैकओएस पर, इस पंक्ति को अपने में जोड़ें ~/.bashrc या ~/.zshrc (तब अपने टर्मिनल को पुनरारंभ करें या चलाएँ source ~/.bashrc):

export FXMD_API_KEY="your_actual_api_key_here"

विंडोज (पावरशेल) परः

$env:FXMD_API_KEY = "your_actual_api_key_here"

फिर अपने नोटबुक के शीर्ष पर एक समर्पित सेटअप सेल में कुंजी पढ़ेंः

import os

API_KEY = os.environ.get("FXMD_API_KEY")
if not API_KEY:
    raise EnvironmentError(
        "FXMD_API_KEY environment variable is not set. "
        "See https://fxmacrodata.com/subscribe to get a key."
    )

print("API key loaded ✓")

टिप: python-dotenv परियोजना स्तर के रहस्यों के लिए

अगर आप पसंद करते हैं .env फ़ाइल प्रति परियोजना, स्थापित करें pip install python-dotenv और जोड़ें from dotenv import load_dotenv; load_dotenv() से पहले os.environ.get() फोन रखो। .env अपनी फाइल में .gitignore.

चरण 2 पुनः प्रयोज्य फ़ॉच सहायक लिखें

प्रत्येक FXMacroData सूचक अंत बिंदु एक ही URL संरचना का पालन करता हैः

GET https://fxmacrodata.com/api/v1/announcements/{currency}/{indicator}?api_key=YOUR_API_KEY

JSON प्रतिक्रिया में एक data सरणी जहां प्रत्येक वस्तु एक है date क्षेत्र, एक val क्षेत्र, और (सटीक समय के लिए) एक announcement_datetime निम्नलिखित सहायक उस प्रतिक्रिया को सीधे एक पांडा डेटाफ्रेम में परिवर्तित करता हैः

import requests
import pandas as pd

BASE_URL = "https://fxmacrodata.com/api/v1"

def fetch_indicator(currency: str, indicator: str,
                    start: str = None, end: str = None) -> pd.DataFrame:
    """Fetch a macro indicator time series from FXMacroData.

    Parameters
    ----------
    currency  : ISO currency code, e.g. 'usd', 'eur', 'gbp'
    indicator : Indicator slug, e.g. 'policy_rate', 'inflation', 'gdp'
    start     : Optional start date 'YYYY-MM-DD'
    end       : Optional end date 'YYYY-MM-DD'

    Returns
    -------
    pd.DataFrame with columns: date (datetime64), val (float64),
                                announcement_datetime (datetime64, nullable),
                                currency (str), indicator (str)
    """
    params = {"api_key": API_KEY}
    if start:
        params["start"] = start
    if end:
        params["end"] = end

    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    resp = requests.get(url, params=params, timeout=15)
    resp.raise_for_status()

    rows = resp.json().get("data", [])
    if not rows:
        return pd.DataFrame(columns=["date", "val", "announcement_datetime",
                                     "currency", "indicator"])

    df = pd.DataFrame(rows)
    df["date"] = pd.to_datetime(df["date"])
    df["val"] = pd.to_numeric(df["val"], errors="coerce")
    if "announcement_datetime" in df.columns:
        df["announcement_datetime"] = pd.to_datetime(
            df["announcement_datetime"], errors="coerce", utc=True
        )
    df["currency"] = currency.upper()
    df["indicator"] = indicator
    return df.sort_values("date").reset_index(drop=True)

सहायक एक उठाता है HTTPError 4xx/5xx उत्तरों पर, को परिवर्तित करता है date सही स्तंभ में datetime64 जो डाउनस्ट्रीम ज्वाइन को तुच्छ बनाता है।

चरण 3 अपनी पहली श्रृंखला लाओ

आइए 2022 से अमेरिकी फेडरल रिजर्व नीतिगत दर निर्णयों को प्राप्त करके सहायक की पुष्टि करेंः

usd_rate = fetch_indicator("usd", "policy_rate", start="2022-01-01")
usd_rate.head(10)

आपको ऐसे स्तंभों के साथ एक डेटाफ्रेम देखना चाहिएः

         date   val       announcement_datetime currency    indicator
0  2022-03-16  0.25  2022-03-16T18:00:00+00:00      USD  policy_rate
1  2022-05-04  0.75  2022-05-04T18:00:00+00:00      USD  policy_rate
2  2022-06-15  1.50  2022-06-15T18:00:00+00:00      USD  policy_rate
3  2022-07-27  2.25  2022-07-27T18:00:00+00:00      USD  policy_rate
...

ध्यान दें announcement_datetime स्तंभ यह आपको घटना-संचालित रणनीतियों या बैकटेस्ट के लिए दूसरे स्तर की रिलीज सटीकता देता है जो सटीक घोषणा समय पर निर्भर करते हैं। उपलब्ध संकेतकों की पूरी सूची का पता लगाएं। /api-data-docs/usd/policy_rate.

चरण 4 कई मुद्राएँ प्राप्त करें

सबसे शक्तिशाली पैटर्न में से एक है एक ही संकेतक को एक साथ कई मुद्राओं के लिए खींचना और परिणामों को ढेर करना। नीचे दिया गया लूप एक बार में USD, EUR, GBP और AUD के लिए नीति दरों को प्राप्त करता हैः

currencies = ["usd", "eur", "gbp", "aud"]
START = "2022-01-01"

policy_rates = pd.concat(
    [fetch_indicator(ccy, "policy_rate", start=START) for ccy in currencies],
    ignore_index=True
)

print(f"Fetched {len(policy_rates)} rows across {policy_rates['currency'].nunique()} currencies")
policy_rates.groupby("currency").tail(2)

उपलब्ध सूचक स्लग

सूचक का पूरा कैटलॉग fxmacrodata.com/api-data-docsविदेशी मुद्रा विश्लेषण के लिए प्रमुख श्रृंखलाओं में शामिल हैं policy_rate, inflation, gdp, unemployment, pmi, और trade_balanceप्रत्येक श्रृंखला में एक ही फ़ेच पैटर्न स्वैप मुद्रा कोड और सूचक स्लग का उपयोग किया जाता है।

चरण 5 कई संकेतकों को मिलाएं

वास्तविक ब्याज दरों की गणना करने के लिए आपको प्रत्येक मुद्रा के लिए नीति दर और कुल मुद्रास्फीति दोनों की आवश्यकता होती है। नीति दरों के साथ मुद्रास्फ़ीति को प्राप्त करें, फिर एक एकल व्यवस्थित डेटा फ्रेम में संयोजन करेंः

inflation = pd.concat(
    [fetch_indicator(ccy, "inflation", start=START) for ccy in currencies],
    ignore_index=True
)

# Stack all observations into one long-form DataFrame
macro = pd.concat([policy_rates, inflation], ignore_index=True)
print(macro.groupby(["currency", "indicator"]).size().to_string())

चरण 6 पुनः आकार और आगे भरना

केंद्रीय बैंक के निर्णय दुर्लभ होते हैं वे वर्ष में 612 बार होते हैं। उन्हें अन्य मासिक श्रृंखलाओं के साथ संरेखित करने के लिए, एक मासिक तिथि रीढ़ का निर्माण करें और अंतिम ज्ञात मान को आगे भरेंः

import numpy as np

# Floor each observation to month start for alignment
macro["month"] = macro["date"].dt.to_period("M").dt.to_timestamp()

# Pivot to wide: one column per currency+indicator combination
wide = (
    macro
    .groupby(["month", "currency", "indicator"])["val"]
    .last()                          # latest reading within the month
    .unstack(["currency", "indicator"])
)

# Build a complete monthly date spine and forward-fill
date_spine = pd.date_range(START, pd.Timestamp.today(), freq="MS")
wide = wide.reindex(date_spine).ffill()

wide.tail(3)

चरण 7 वास्तविक दर के स्प्रेड की गणना करें

वास्तविक दर मुद्रास्फीति को घटाकर नाममात्र नीतिगत दर है। एक सकारात्मक स्प्रेड प्रतिबंधात्मक मौद्रिक नीति का संकेत देता है; एक नकारात्मक स्प्रेડ का अर्थ है कि केंद्रीय बैंक उपभोक्ता मूल्य वृद्धि के सापेक्ष अभी भी अनुकूल है। EURUSD वास्तविक दर अंतर EUR/USD के सबसे मजबूत मध्यम अवधि के ड्राइवरों में से एक हैंः

for ccy in [c.upper() for c in currencies]:
    try:
        wide[(ccy, "real_rate")] = (
            wide[(ccy, "policy_rate")] - wide[(ccy, "inflation")]
        )
    except KeyError:
        pass  # skip if either series is missing

# EUR minus USD real rate differential
wide[("spread", "eur_usd")] = (
    wide[("EUR", "real_rate")] - wide[("USD", "real_rate")]
)

wide[[("USD", "real_rate"), ("EUR", "real_rate"), ("spread", "eur_usd")]].tail(6)

चरण 8 मैटप्लोटलिब के साथ कल्पना करें

डेटाफ्रेम तैयार होने के बाद, एक बहु-पैनल चार्ट में केवल कुछ पंक्तियां होती हैं। नीति दरों के लिए चरण चार्ट का उपयोग करें वे असतत सीढ़ी निर्णय हैं, निरंतर श्रृंखला नहीं हैंः

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

fig, axes = plt.subplots(3, 1, figsize=(13, 11), sharex=True)
fig.patch.set_facecolor("#F8FAFC")

COLORS = {"USD": "#2563EB", "EUR": "#16A34A", "GBP": "#7C3AED", "AUD": "#F97316"}

# Panel 1: Policy rates
ax1 = axes[0]
for ccy in [c.upper() for c in currencies]:
    try:
        series = wide[(ccy, "policy_rate")].dropna()
        ax1.step(series.index, series.values, where="post",
                 label=ccy, color=COLORS[ccy], linewidth=1.8)
    except KeyError:
        pass
ax1.set_ylabel("Policy rate (%)")
ax1.set_title("Central Bank Policy Rates — G4", fontweight="bold")
ax1.legend(loc="upper left", fontsize=9)
ax1.grid(axis="y", alpha=0.3)

# Panel 2: Real rates
ax2 = axes[1]
for ccy in [c.upper() for c in currencies]:
    try:
        series = wide[(ccy, "real_rate")].dropna()
        ax2.plot(series.index, series.values,
                 label=ccy, color=COLORS[ccy], linewidth=1.8)
    except KeyError:
        pass
ax2.axhline(0, color="#94A3B8", linewidth=0.8, linestyle="--")
ax2.set_ylabel("Real rate (%)")
ax2.set_title("Real Interest Rates (Policy Rate − Inflation)", fontweight="bold")
ax2.legend(loc="upper left", fontsize=9)
ax2.grid(axis="y", alpha=0.3)

# Panel 3: EUR–USD spread
ax3 = axes[2]
spread = wide[("spread", "eur_usd")].dropna()
ax3.fill_between(spread.index, spread.values, 0,
                  where=spread.values >= 0,
                  color="#16A34A", alpha=0.30, label="EUR favoured")
ax3.fill_between(spread.index, spread.values, 0,
                  where=spread.values < 0,
                  color="#2563EB", alpha=0.30, label="USD favoured")
ax3.plot(spread.index, spread.values, color="#374151", linewidth=1.6)
ax3.axhline(0, color="#94A3B8", linewidth=0.8, linestyle="--")
ax3.set_ylabel("Spread (pp)")
ax3.set_title("EUR−USD Real Rate Differential", fontweight="bold")
ax3.legend(loc="upper left", fontsize=9)
ax3.grid(axis="y", alpha=0.3)

ax3.xaxis.set_major_formatter(mdates.DateFormatter("%b %Y"))
ax3.xaxis.set_major_locator(mdates.MonthLocator(interval=4))
plt.setp(ax3.xaxis.get_majorticklabels(), rotation=30, ha="right")

fig.tight_layout(h_pad=1.6)
plt.savefig("macro_analysis.png", dpi=150, bbox_inches="tight")
plt.show()

सुझाव: पॉलिसी दरों की श्रृंखलाओं के लिए चरण चार्ट का प्रयोग करें

ax.step(..., where="post") केंद्रीय बैंक के निर्णयों को एक सुचारू अंतःनिहित रेखा के बजाय असतत सीढ़ी के रूप में सही ढंग से दर्शाता है। अन्य सभी मैक्रो श्रृंखलाओं (मुद्रास्फीति, जीडीपी, पीएमआई) के लिए एक मानक ax.plot() उचित है।

चरण 9 रिलीज कैलेंडर देखें

आवर्ती फ़ेचिंग के शेड्यूल करने से पहले, यह जानना उपयोगी है कि अगले डेटा रिलीज़ कब होने वाले हैं। रिलीज कैलेंडर अंत बिंदु किसी भी मुद्रा के लिए आगामी घोषणा की तारीखों को लौटाता है, ताकि आप एक निश्चित कार्यक्रम पर मतदान के बजाय प्रत्येक रिलीज के बाद मिनटों में चलाने के लिए अपने नोटबुक ताज़ा करने का समय कर सकेंः

def fetch_calendar(currency: str) -> pd.DataFrame:
    """Fetch upcoming release dates for a currency from the FXMacroData calendar."""
    url = f"{BASE_URL}/calendar/{currency}"
    resp = requests.get(url, params={"api_key": API_KEY}, timeout=15)
    resp.raise_for_status()
    events = resp.json().get("data", [])
    df = pd.DataFrame(events)
    if df.empty:
        return df
    df["release_date"] = pd.to_datetime(df["release_date"], errors="coerce")
    return df.sort_values("release_date").reset_index(drop=True)

# Upcoming USD releases
usd_calendar = fetch_calendar("usd")
upcoming = usd_calendar[usd_calendar["release_date"] >= pd.Timestamp.today()]
print(upcoming[["release_date", "indicator"]].head(10).to_string(index=False))

चरण 10 सहेजें और समय-सारणी बनाएं

दोहराए जाने योग्य विश्लेषण के लिए आप व्यापक डेटाफ्रेम को CSV में निर्यात कर सकते हैं और papermill, जो पैरामीटर इंजेक्शन के साथ कमांड लाइन से नोटबुक निष्पादित करता हैः

pip install papermill

# At the end of your notebook: persist the dataset
wide.to_csv("macro_data.csv")
print(f"Saved {wide.shape[0]} rows × {wide.shape[1]} columns to macro_data.csv")

# Execute the notebook from the command line (e.g. from cron or a CI job)
papermill macro_analysis.ipynb macro_analysis_output.ipynb \
  -p START "2022-01-01"

इसे रिलीज़ कैलेंडर के साथ जोड़ें ताकि आपका शेड्यूल किया हुआ कार्य केवल तब चलाया जाए जब नए संकेतक डेटा की वास्तव में उम्मीद की जाए कम गतिविधि वाले दिनों में एपीआई उपयोग को कुशल बनाए रखें.

एक ही स्थान पर पूरी नोटबुक

ऊपर सभी कोशिकाओं एक एकल आत्मनिर्भर नोटबुक बनाते हैं. उन्हें क्रम में ड्रॉप, सेट FXMD_API_KEY अपने वातावरण में, और सभी कोशिकाओं को चलाएँ आप दो मिनट से कम समय में एक पूरी तरह से इंटरैक्टिव मैक्रो विश्लेषण होगा.

सारांश

आपने एक पूर्ण Jupyter नोटबुक कार्यप्रवाह बनाया है जोः

एक पर्यावरण चर के माध्यम से सुरक्षित रूप से FXMacroData के साथ प्रमाणित करता है
पुनः प्रयोज्य लागू करता है fetch_indicator() सहायक जो पांडा डेटाफ्रेम के लिए एपीआई प्रतिक्रियाओं को परिवर्तित करता है
कई जी10 मुद्राओं के लिए नीतिगत दर और मुद्रास्फीति श्रृंखलाओं को खींचता है और ढेर करता है
पूर्व-भरण के साथ नियमित मासिक तिथि रीढ़ पर केंद्रीय बैंक के दुर्लभ डेटा को फिर से आकार देता है
वास्तविक दर के स्प्रेड और क्रॉस-मुद्रा अंतरों की गणना करता है
रिपोर्ट या साझा करने के लिए तैयार तीन पैनल Matplotlib चार्ट उत्पन्न करता है
समय के लिए रिलीज़ कैलेंडर से पूछताछ करता है बार-बार ताज़ा करता है बुद्धिमानी से
CSV और अनुसूचियों के साथ नोटबुक निष्पादन के लिए निर्यात परिणाम papermill

अगले चरण के रूप में, नोटबुक को अतिरिक्त FXMacroData श्रृंखला जैसे के साथ विस्तारित करें बेरोजगारी, व्यापार संतुलन, और एमपीआई एक पूर्ण मैक्रो स्कोरकार्ड बनाने के लिए। fetch_indicator() सहायक और रीफॉर्म वर्कफ़्लो लागू होता है केवल सूचक स्लग को अपडेट करने की आवश्यकता होती है।

एक Jupyter नोटबुक में FXMacroData का उपयोग कैसे करें (एंड-टू-एंड)