पाइन स्क्रिप्ट के माध्यम से ट्रेडिंगव्यू के साथ FXMacroData को कैसे एकीकृत करें

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

चरण 1 FXMacroData घोषणा अंत बिंदु को समझें

FXMacroData में प्रत्येक संकेतक एक ही REST आकार का पालन करता है। EUR के लिए नीति दर अनुरोध इस तरह दिखता है क्वेरी पैरामीटर के रूप में अपने एपीआई कुंजी का उपयोग करें:

curl "https://fxmacrodata.com/api/v1/announcements/eur/policy_rate?api_key=YOUR_API_KEY&start=2023-01-01"

JSON प्रतिक्रिया एक के साथ एक सपाट वस्तु है data सरणीः

{
  "currency": "eur",
  "indicator": "policy_rate",
  "data": [
    {
      "date": "2025-03-06",
      "val": 2.65,
      "announcement_datetime": "2025-03-06T13:15:00Z"
    },
    {
      "date": "2025-01-30",
      "val": 2.90,
      "announcement_datetime": "2025-01-30T13:15:00Z"
    },
    {
      "date": "2024-12-12",
      "val": 3.15,
      "announcement_datetime": "2024-12-12T13:15:00Z"
    }
  ]
}

प्रत्येक रिकॉर्ड में एक date (वर्षवर्ष-महीना-दिन) val, और दूसरे स्तर का UTC announcement_datetimeसभी मुद्राओं और संकेतकों में एक समान आकार है जो कोड जनरेटर को बनाने में आसान बनाता है। उपलब्ध संकेतकों की पूरी सूची के लिए, देखें यूरो नीतिगत दर डॉक्स और अपनी लक्ष्य मुद्रा के लिए सूचक सूची का अन्वेषण करें।

चरण 2 पायथन के साथ मैक्रो डेटा प्राप्त करें

नामक एक फ़ाइल बनाएँ generate_pine.py. यह स्क्रिप्ट एक चयनित मुद्रा और संकेतक के लिए घोषणा डेटा प्राप्त करता है, तो पाइन स्क्रिप्शन सरणी में परिणामों को सीरियल करता है कि आप संकेतन फ़ाइल में चिपकाएँ.

"""
generate_pine.py — fetch FXMacroData announcements and output Pine Script arrays.

Usage:
    python generate_pine.py --currency eur --indicator policy_rate --start 2023-01-01
"""
import argparse
import json
import os
from datetime import datetime, timezone

import requests

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY = os.environ.get("FXMD_API_KEY", "")


def fetch_announcements(currency: str, indicator: str, start: str) -> list[dict]:
    url = f"{BASE_URL}/announcements/{currency}/{indicator}"
    params: dict = {"start": start}
    if API_KEY:
        params["api_key"] = API_KEY
    resp = requests.get(url, params=params, timeout=15)
    resp.raise_for_status()
    return resp.json().get("data", [])


def ts_to_pine_timestamp(iso_str: str) -> int:
    """Convert an ISO-8601 UTC string to a Unix timestamp (milliseconds for Pine)."""
    dt = datetime.fromisoformat(iso_str.replace("Z", "+00:00"))
    return int(dt.timestamp() * 1000)


def build_pine_arrays(records: list[dict]) -> str:
    """Render the data as Pine Script array literals."""
    ts_list = []
    val_list = []
    for r in records:
        ann = r.get("announcement_datetime") or f"{r['date']}T00:00:00Z"
        ts_list.append(str(ts_to_pine_timestamp(ann)))
        val_list.append(str(r["val"]))

    ts_str = ", ".join(ts_list)
    val_str = ", ".join(val_list)
    n = len(records)

    return f"""
// ── Auto-generated by generate_pine.py — do not edit manually ──
// Currency: {records[0].get('currency', '?').upper() if records else '?'}
// Indicator: {records[0].get('indicator', '?') if records else '?'}
// Records: {n}

var int[] _ann_ts  = array.from({ts_str})
var float[] _ann_val = array.from({val_str})
"""


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--currency", required=True)
    parser.add_argument("--indicator", required=True)
    parser.add_argument("--start", default="2023-01-01")
    args = parser.parse_args()

    print(f"Fetching {args.indicator} for {args.currency.upper()} from {args.start} …")
    records = fetch_announcements(args.currency, args.indicator, args.start)
    print(f"  {len(records)} records returned.")
    pine = build_pine_arrays(records)
    print(pine)

    output_file = f"pine_data_{args.currency}_{args.indicator}.txt"
    with open(output_file, "w") as f:
        f.write(pine)
    print(f"Arrays written to {output_file}")


if __name__ == "__main__":
    main()

अपनी एपीआई कुंजी सहेजें और स्क्रिप्ट चलाएं:

export FXMD_API_KEY="YOUR_API_KEY"
python generate_pine.py --currency eur --indicator policy_rate --start 2023-01-01

आउटपुट फ़ाइल pine_data_eur_policy_rate.txt संकेतकों में ड्रॉप करने के लिए तैयार पाइन स्क्रिप्ट सरणी अक्षरों में शामिल होगा. आप CPI के लिए एक ही स्क्रिप्शन चला सकते हैं (--indicator inflation), एमपीआई (--indicator pmi), या ी किसी अन्य संकेतक से ी FXMacroData कैटलॉग. .

चरण 3 पाइन स्क्रिप्ट संकेतक का निर्माण करें

ट्रेडिंग व्यू खोलें, पाइन स्क्रिप्ट संपादक (चार्ट के नीचे "पाइन संपादक" टैब) पर नेविगेट करें, और निम्न संकेतक चिपकाएं। _ann_ts और _ann_val चरण 2 से आउटपुट के साथ शीर्ष पर सरणी।

// @version=5
// FXMacroData Overlay — policy rate event markers + value line
// Replace the arrays below with output from generate_pine.py

indicator("FXMacroData Macro Overlay", overlay=true, max_labels_count=50, max_lines_count=50)

// ── User inputs ──
i_show_labels   = input.bool(true,  "Show event labels")
i_show_line     = input.bool(true,  "Show macro value line")
i_show_table    = input.bool(true,  "Show data table")
i_label_color   = input.color(color.new(color.orange, 0), "Label colour")
i_line_color    = input.color(color.new(color.orange, 30), "Line colour")

// ── Paste generated arrays here ──
// ---- BEGIN GENERATED SECTION ----
var int[]   _ann_ts  = array.from(1672531200000, 1675209600000, 1677628800000)
var float[] _ann_val = array.from(2.50, 2.65, 3.00)
// ---- END GENERATED SECTION ----

// ── Helper: find the most recent announcement value at or before this bar ──
f_current_val() =>
    float result = na
    int bar_t = time
    for i = 0 to array.size(_ann_ts) - 1
        if array.get(_ann_ts, i) <= bar_t
            result := array.get(_ann_val, i)
            break
    result

// ── Macro overlay line ──
float macro_val = f_current_val()
plot(i_show_line ? macro_val : na, title="Macro value", color=i_line_color,
     linewidth=2, style=plot.style_stepline)

// ── Event marker labels ──
if i_show_labels
    for i = 0 to array.size(_ann_ts) - 1
        int   ts  = array.get(_ann_ts, i)
        float val = array.get(_ann_val, i)
        if ts >= chart.left_visible_bar_time and ts <= chart.right_visible_bar_time
            label.new(
                x       = ts,
                y       = high * 1.002,
                text    = str.tostring(val, "#.##"),
                style   = label.style_diamond,
                color   = i_label_color,
                textcolor = color.white,
                size    = size.small,
                xloc    = xloc.bar_time
            )

// ── Summary table (top-right corner) ──
var table t = table.new(position.top_right, 2, 6,
    bgcolor       = color.new(color.navy, 85),
    border_width  = 1,
    border_color  = color.new(color.gray, 60))

if i_show_table and barstate.islast
    table.cell(t, 0, 0, "Date",  text_color=color.silver, text_size=size.small)
    table.cell(t, 1, 0, "Value", text_color=color.silver, text_size=size.small)
    int rows = math.min(5, array.size(_ann_ts))
    for i = 0 to rows - 1
        int   ts  = array.get(_ann_ts, i)
        float val = array.get(_ann_val, i)
        string date_str = str.format("{0,date,yyyy-MM-dd}", ts)
        table.cell(t, 0, i + 1, date_str, text_color=color.white, text_size=size.tiny)
        table.cell(t, 1, i + 1, str.tostring(val, "#.##"), text_color=color.orange, text_size=size.tiny)

क्लिक करें चार्ट में जोड़ें. सूचक मैक्रो मूल्य प्रगति से मेल खाने वाली एक चरण रेखा को ओवरले करेगा और प्रत्येक घोषणा तिथि पर एक लेबल किया गया हीरा मार्कर छोड़ देगा। यह देखने के लिए इतिहास के माध्यम से स्क्रॉल करें कि प्रत्येक नीति दर प्रिंट आपके चुने हुए मुद्रा जोड़े पर मूल्य कार्रवाई के साथ कैसे संरेखित हुई।

चरण 4 कई संकेतकों में परत

एक एकल संकेतक कहानी का हिस्सा बताता है। वास्तविक किनारा नीति दर, सीपीआई और पीएमआई को एक साथ लेयर करने से आता है। प्रत्येक संकेतिक के लिए चरण 2 दोहराएं और पाइन स्क्रिप्ट में एक अतिरिक्त अनुभाग जोड़ें, या तीन अलग-अलग संकेतन बनाएं और उन्हें एक ही चार्ट पैनल पर ढेर करें।

एक बार में तीन संकेतक लेने के लिए, पायथन स्क्रिप्ट का विस्तार करेंः

INDICATORS = ["policy_rate", "inflation", "pmi"]
CURRENCY   = "eur"
START      = "2023-01-01"

for ind in INDICATORS:
    records = fetch_announcements(CURRENCY, ind, START)
    pine    = build_pine_arrays(records)
    with open(f"pine_data_{CURRENCY}_{ind}.txt", "w") as f:
        f.write(pine)
    print(f"Written pine_data_{CURRENCY}_{ind}.txt  ({len(records)} records)")

प्रत्येक आउटपुट फ़ाइल आपको एक अलग पाइन स्क्रिप्ट संकेतक के लिए एक ड्रॉप-इन अनुभाग देती है। प्रत्येक को अपने चार्ट में जोड़ें और प्रत्येक संकेतिक के लिए अलग रंग असाइन करें उदाहरण के लिए, नीति दर के लिए नारंगी, सीपीआई के लिए नीला और पीएमआई के लिये हरा ताकि आप एक नज़र में देख सकें कि कौन सा मैक्रो शासन लागू है। आप यूरो के लिए उपलब्ध सभी संकेतन का पता लगा सकते हैं। EUR PMI डॉक्स और व्यापक सूचक सूची।

चरण 5 रिलीज कैलेंडर की जाँच के साथ अद्यतन स्वचालित करें

पाइन स्क्रिप्ट सरणी में मैक्रो डेटा एक नई घोषणा प्रिंट के क्षण में पुराना हो जाता है. यदि ऐसा है, तो जनरेटर को फिर से चलाएं और अपने पाइन लिपि को अपडेट करें.

"""
check_and_refresh.py — Re-generate Pine arrays if new announcements have printed.
Run this before each session, e.g. via cron or GitHub Actions.
"""
import subprocess
import requests
import os
from datetime import date, timedelta

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY  = os.environ.get("FXMD_API_KEY", "")
PAIRS    = [
    ("eur", "policy_rate"),
    ("eur", "inflation"),
    ("eur", "pmi"),
]

def latest_release_date(currency: str, indicator: str) -> str | None:
    """Return the most recent announcement date for this indicator."""
    params: dict = {"start": str(date.today() - timedelta(days=7))}
    if API_KEY:
        params["api_key"] = API_KEY
    r = requests.get(
        f"{BASE_URL}/announcements/{currency}/{indicator}",
        params=params, timeout=10
    )
    r.raise_for_status()
    data = r.json().get("data", [])
    return data[0]["date"] if data else None

def refresh_all() -> None:
    for currency, indicator in PAIRS:
        latest = latest_release_date(currency, indicator)
        if latest and latest >= str(date.today() - timedelta(days=1)):
            print(f"New print detected: {currency.upper()} {indicator} on {latest}. Regenerating …")
            subprocess.run(
                ["python", "generate_pine.py",
                 "--currency", currency,
                 "--indicator", indicator,
                 "--start", "2023-01-01"],
                check=True,
            )
        else:
            print(f"{currency.upper()} {indicator}: no new prints since yesterday.")

if __name__ == "__main__":
    refresh_all()

इस स्क्रिप्ट को सोमवार-शुक्रवार को 08:00 UTC पर चलाने के लिए शेड्यूल करें, लंदन खोलने से पहले, एक क्रोन जॉब, एक GitHub क्रिया कार्यप्रवाह, या किसी भी कार्य शेड्यूलर का उपयोग करके। जब एक ताज़ा चलाता है, तो अद्यतन की प्रतिलिपि pine_data_*.txt सामग्री को ट्रेडिंगव्यू के पाइन एडिटर में डालें और क्लिक करें सहेजेंआपके चार्ट मार्कर तुरंत नवीनतम घोषणा डेटा को प्रतिबिंबित करेंगे।

चरण 6 ट्रेडिंगविव अलर्ट वापस FXMacroData संदर्भ में भेजें

कार्यप्रवाह अब तक मैक्रो डेटा को धक्का देता है में ट्रेडिंग व्यू. चरण 6 दूसरी दिशा में लूप को बंद करता हैः जब आपका पाइन स्क्रिप्ट एक ट्रेडिंग सिग्नल निकालता है (जैसे कि सीपीआई प्रिंट के बाद प्रतिरोध से ऊपर का ब्रेकआउट), ट्रेडिंग विउ की वेबहूक अलर्ट सिस्टम उस घटना को एक छोटे फ्लास्क एंडपॉइंट पर अग्रेषित करती है, जो तुरंत ताजा संदर्भ के लिए एफएक्समैक्रोडाटा से पूछताछ करती है नवीनतम सीपीआइ प्रवृत्ति, आगामी रिलीज़, और वर्तमान सीओटी पोजिशनिंग और लॉग या आपको पूर्ण मैक्रो तस्वीर के साथ सूचित करती है।

सृजन करना webhook_server.py:

"""
webhook_server.py — Receive TradingView alert webhooks and enrich with FXMacroData context.
Run with: python webhook_server.py
Expose to the internet via ngrok or deploy to a cloud function / VPS.
"""
import os
import json
from datetime import date, timedelta

import requests
from flask import Flask, request, jsonify

app = Flask(__name__)
BASE_URL  = "https://fxmacrodata.com/api/v1"
API_KEY   = os.environ.get("FXMD_API_KEY", "")

def get_macro_context(currency: str) -> dict:
    """Fetch latest policy rate + CPI for the given currency."""
    params: dict = {"start": str(date.today() - timedelta(days=90))}
    if API_KEY:
        params["api_key"] = API_KEY

    ctx: dict = {}
    for indicator in ("policy_rate", "inflation"):
        try:
            r = requests.get(
                f"{BASE_URL}/announcements/{currency}/{indicator}",
                params=params, timeout=10
            )
            r.raise_for_status()
            data = r.json().get("data", [])
            ctx[indicator] = data[0] if data else {}
        except Exception as exc:
            ctx[indicator] = {"error": str(exc)}
    return ctx

@app.route("/tradingview/alert", methods=["POST"])
def receive_alert():
    payload = request.get_json(force=True, silent=True) or {}
    currency = payload.get("currency", "usd").lower()
    signal   = payload.get("signal", "unknown")

    ctx = get_macro_context(currency)
    result = {
        "received_signal": signal,
        "currency": currency.upper(),
        "macro_context": ctx,
    }
    print(json.dumps(result, indent=2))
    return jsonify(result), 200

if __name__ == "__main__":
    app.run(port=5050, debug=False)

फ्लास्क स्थापित करें और सर्वर चलाएं:

pip install flask
python webhook_server.py

स्थानीय पोर्ट को इंटरनेट पर निग्रोक

ngrok http 5050

ट्रेडिंग व्यू में, खोलें अलर्ट → अलर्ट बनाएँ, अपनी पाइन स्क्रिप्ट स्थिति का चयन करें, सक्षम करें वेबहूक URL, और के साथ समाप्त होने वाला ngrok HTTPS URL चिपकाएँ /tradingview/alert. चेतावनी संदेश को JSON पेलोड पर सेट करें:

{
  "currency": "eur",
  "signal": "breakout_long",
  "ticker": "{{ticker}}",
  "price": {{close}}
}

जब भी पाइन स्क्रिप्ट की शर्त ट्रिगर होती है, ट्रेडिंग व्यू उस JSON को आपके एंडपॉइंट पर पोस्ट करता है। वेबहूक हैंडलर FXMacroData से नवीनतम EUR नीति दर और CPI प्राप्त करता है और सिग्नल के साथ पूर्ण मैक्रो संदर्भ लॉग करता है. आप इसे बढ़ाकर समृद्ध डेटा का उपयोग करके टेलीग्राम या स्लैक अधिसूचना भेज सकते हैं।

चरण 7 सीओटी पोजिशनिंग और एक्सचेंज स्पॉट संदर्भ के साथ विस्तार करें

मैक्रो घोषणा डेटा चित्र की एक परत है। अधिक पूर्ण संकेत के लिए, FXMacroData से CFTC Commitment of Traders पोजिशनिंग और FX स्पॉट ट्रेंड संदर्भ जोड़ें।

EUR वायदा के लिए पुट सीओटी पोजिशनिंगः

curl "https://fxmacrodata.com/api/v1/cot/eur?api_key=YOUR_API_KEY&start=2024-01-01"

{
  "currency": "eur",
  "data": [
    {
      "date": "2025-03-18",
      "net_noncommercial": 48320,
      "long_noncommercial": 182500,
      "short_noncommercial": 134180
    }
  ]
}

चरण 2 के समान पैटर्न का उपयोग करके अपने पाइन स्क्रिप्ट जनरेटर में एक सीओटी नेट-पोजिशनिंग श्रृंखला जोड़ें। एक सकारात्मक net_noncommercial मूल्य अनुमानित व्यापारियों को शुद्ध लंबी EUR वायदा संकेत देता है एक भावना पृष्ठभूमि जो कि विश्वास जोड़ता है जब एक हाकिम ईसीबी नीति संकेत के साथ संयुक्त होता है। सीओटी डैशबोर्ड इसे अपने संकेतक में एम्बेड करने से पहले।

एक सीओटी अनुभाग शामिल करने के लिए पायथन जनरेटर का विस्तार करेंः

def fetch_cot(currency: str, start: str) -> list[dict]:
    url = f"{BASE_URL}/cot/{currency}"
    params: dict = {"start": start}
    if API_KEY:
        params["api_key"] = API_KEY
    resp = requests.get(url, params=params, timeout=15)
    resp.raise_for_status()
    return resp.json().get("data", [])


def build_cot_pine_arrays(records: list[dict]) -> str:
    ts_list  = [str(int(datetime.fromisoformat(r["date"] + "T00:00:00+00:00").timestamp() * 1000)) for r in records]
    net_list = [str(r.get("net_noncommercial", 0)) for r in records]
    ts_str   = ", ".join(ts_list)
    net_str  = ", ".join(net_list)
    return f"""
var int[]   _cot_ts  = array.from({ts_str})
var float[] _cot_net = array.from({net_str})
"""

पाइन स्क्रिप्ट में, प्लॉट _cot_net एक अलग फलक में (सेट overlay=false इस सूचक के लिए) तो आप मूल्य और मैक्रो घोषणाओं के साथ सट्टा स्थिति की प्रवृत्ति देख सकते हैं।