prefect-fxmacrodata 0.1.0__py3-none-any.whl

prefect_fxmacrodata/__init__.py

@@ -0,0 +1,19 @@
+"""FXMacroData credentials, tasks and research flows for Prefect."""
+
+from .credentials import FXMacroDataCredentials
+from .flows import macro_snapshot
+from .models import FXMacroDataResult, MacroSnapshot, OperationSchema
+from .tasks import OPERATION_TASKS, complete_history, discover_operations, operation_schemas
+
+__version__ = "0.1.0"
+__all__ = [
+    "FXMacroDataCredentials",
+    "FXMacroDataResult",
+    "MacroSnapshot",
+    "OperationSchema",
+    "OPERATION_TASKS",
+    "complete_history",
+    "discover_operations",
+    "macro_snapshot",
+    "operation_schemas",
+]

prefect_fxmacrodata/credentials.py

@@ -0,0 +1,30 @@
+"""Reusable FXMacroData connection configuration for Prefect."""
+
+from fxmacrodata_public import FXMacroDataClient
+from prefect.blocks.core import Block
+from pydantic import Field, SecretStr
+
+
+class FXMacroDataCredentials(Block):
+    """Store a subscriber's API key using Prefect's encrypted secret field.
+
+    Tasks take the saved Block name and load this configuration inside the run.
+    An empty key explicitly selects public evaluation access.
+    """
+
+    _block_type_name = "FXMacroData Credentials"
+    _documentation_url = (
+        "https://fxmacrodata.com/documentation/reference?utm_source=github"
+        "&utm_medium=referral&utm_campaign=prefect&utm_content=docs"
+    )
+
+    api_key: SecretStr = Field(
+        default_factory=lambda: SecretStr(""),
+        description="Your FXMacroData subscription API key; leave empty for USD evaluation.",
+        repr=False,
+    )
+    timeout: float = Field(default=30, ge=1, le=120, allow_inf_nan=False)
+
+    def get_client(self) -> FXMacroDataClient:
+        """Create a bounded client; use it as a context manager."""
+        return FXMacroDataClient(api_key=self.api_key.get_secret_value(), timeout=self.timeout)

prefect_fxmacrodata/flows.py

@@ -0,0 +1,42 @@
+"""Research workflows composed from ordinary Prefect tasks."""
+
+import asyncio
+
+from prefect import flow
+
+from .models import MacroSnapshot
+from .tasks import OPERATION_TASKS, complete_history
+
+
+@flow(name="fxmacrodata-macro-snapshot", persist_result=False, log_prints=False)
+async def macro_snapshot(
+    currency: str,
+    indicator: str,
+    credentials_block: str | None = None,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    max_pages: int = 10000,
+) -> MacroSnapshot:
+    """Fetch complete available indicator history and the release calendar.
+
+    The caller chooses the currency and history range; calendar dates use the
+    API's current release-calendar window independently of the history range.
+    Original source fields,
+    values, publication timestamps and unavailable states are retained.
+    """
+    arguments = {"currency": currency, "indicator": indicator}
+    if start_date is not None:
+        arguments["start_date"] = start_date
+    if end_date is not None:
+        arguments["end_date"] = end_date
+    history, calendar = await asyncio.gather(
+        complete_history("indicator_history", arguments, credentials_block, max_pages),
+        OPERATION_TASKS["release_calendar"]({"currency": currency}, credentials_block),
+    )
+    return MacroSnapshot(
+        currency=currency,
+        indicator=indicator,
+        history=history,
+        calendar=calendar,
+        source_urls=list(dict.fromkeys([history.source_url, calendar.source_url])),
+    )

prefect_fxmacrodata/models.py

@@ -0,0 +1,51 @@
+"""Typed envelopes that retain FXMacroData's original responses."""
+
+from copy import deepcopy
+from typing import Any
+
+from fxmacrodata_public import Result
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FXMacroDataResult(BaseModel):
+    """Original payload and provenance plus an additive row-oriented view."""
+
+    model_config = ConfigDict(frozen=True)
+
+    operation: str
+    payload: Any = Field(repr=False)
+    source_url: str
+
+    @classmethod
+    def from_result(cls, result: Result) -> "FXMacroDataResult":
+        """Copy a client result without changing values or metadata."""
+        return cls(
+            operation=result.operation,
+            payload=deepcopy(result.payload),
+            source_url=result.source_url,
+        )
+
+    def records(self) -> list[dict[str, Any]]:
+        """Return the public client's additive record view."""
+        return Result(self.operation, self.payload, self.source_url).records()
+
+
+class OperationSchema(BaseModel):
+    """Discover a native task and its unchanged API argument schema."""
+
+    name: str
+    description: str
+    method: str
+    path: str
+    input_schema: dict[str, Any]
+    supports_complete_history: bool
+
+
+class MacroSnapshot(BaseModel):
+    """History and scheduled releases for a research flow's next task."""
+
+    currency: str
+    indicator: str
+    history: FXMacroDataResult
+    calendar: FXMacroDataResult
+    source_urls: list[str] = Field(default_factory=list)

prefect_fxmacrodata/tasks.py

@@ -0,0 +1,197 @@
+"""Named Prefect tasks for every published FXMacroData client operation."""
+
+from __future__ import annotations
+
+import asyncio
+from copy import deepcopy
+from threading import Event
+from typing import Any, Callable
+
+from fxmacrodata_public import FXMacroDataError, Result, list_operations
+from fxmacrodata_public.pagination import IncompleteHistoryError, collect_history
+from prefect import task
+from prefect.cache_policies import NO_CACHE
+
+from .credentials import FXMacroDataCredentials
+from .models import FXMacroDataResult, OperationSchema
+
+_OPERATIONS = {operation.name: operation for operation in list_operations()}
+
+
+class FXMacroDataTaskError(RuntimeError):
+    """A task failed without retaining the underlying request or credentials."""
+
+
+def operation_schemas() -> tuple[OperationSchema, ...]:
+    """Return the exact schemas used by the installed public client."""
+    return tuple(
+        OperationSchema(
+            name=op.name,
+            description=op.description,
+            method=op.method,
+            path=op.path,
+            input_schema=deepcopy(op.input_schema),
+            supports_complete_history=(
+                op.method == "GET" and any(p["name"] == "offset" for p in op.parameters)
+            ),
+        )
+        for op in _OPERATIONS.values()
+    )
+
+
+async def _credentials(block_name: str | None) -> FXMacroDataCredentials:
+    if block_name is None:
+        return FXMacroDataCredentials()
+    if not isinstance(block_name, str) or not block_name:
+        raise FXMacroDataTaskError("Supply a saved FXMacroData Credentials Block name.")
+    try:
+        return await FXMacroDataCredentials.aload(block_name)
+    except Exception:
+        raise FXMacroDataTaskError("Unable to load the FXMacroData Credentials Block.") from None
+
+
+async def _run_blocking(work: Callable[[Event], FXMacroDataResult]) -> FXMacroDataResult:
+    """Drain one bounded request on cancellation and stop before the next page."""
+    cancelled = Event()
+    future = asyncio.create_task(asyncio.to_thread(work, cancelled))
+    try:
+        return await asyncio.shield(future)
+    except asyncio.CancelledError:
+        cancelled.set()
+        try:
+            await asyncio.shield(future)
+        except Exception:
+            pass
+        raise
+
+
+def _check_cancelled(cancelled: Event) -> None:
+    if cancelled.is_set():
+        raise FXMacroDataTaskError("FXMacroData request cancelled.")
+
+
+async def _execute(
+    operation: str,
+    arguments: dict[str, Any] | None,
+    credentials_block: str | None,
+    *,
+    complete: bool = False,
+    max_pages: int = 10000,
+) -> FXMacroDataResult:
+    connection = await _credentials(credentials_block)
+    if operation not in _OPERATIONS:
+        raise FXMacroDataTaskError("Unknown operation. Use operation_schemas for discovery.")
+    op = _OPERATIONS[operation]
+    if complete and not (op.method == "GET" and any(p["name"] == "offset" for p in op.parameters)):
+        raise FXMacroDataTaskError("Complete history requires an offset-paginated REST operation.")
+    if type(max_pages) is not int or not 1 <= max_pages <= 10000:
+        raise FXMacroDataTaskError("max_pages must be an integer between 1 and 10000.")
+
+    def work(cancelled: Event) -> FXMacroDataResult:
+        try:
+            with connection.get_client() as client:
+                _check_cancelled(cancelled)
+                if complete:
+                    source_url = "https://fxmacrodata.com"
+
+                    def fetch(page: dict[str, Any]) -> Any:
+                        nonlocal source_url
+                        _check_cancelled(cancelled)
+                        response = client.execute(operation, page)
+                        source_url = response.source_url
+                        return response.payload
+
+                    payload = collect_history(
+                        fetch,
+                        arguments,
+                        max_pages=max_pages,
+                        request_id=operation,
+                        require_pagination=True,
+                    )
+                    result = Result(operation, payload, source_url)
+                else:
+                    result = client.execute(operation, arguments)
+                return FXMacroDataResult.from_result(result)
+        except IncompleteHistoryError:
+            raise FXMacroDataTaskError(
+                "History is incomplete or changed during download; restart with a larger "
+                "page budget if needed. No partial history was returned."
+            ) from None
+        except FXMacroDataError:
+            raise FXMacroDataTaskError(
+                "FXMacroData could not complete this operation. Check its input schema, "
+                "your subscription access and service availability."
+            ) from None
+        except FXMacroDataTaskError:
+            raise
+        except Exception:
+            raise FXMacroDataTaskError(
+                "FXMacroData request failed; retry after checking access."
+            ) from None
+
+    return await _run_blocking(work)
+
+
+def _operation_task(name: str):
+    async def run(
+        arguments: dict[str, Any] | None = None,
+        credentials_block: str | None = None,
+    ) -> FXMacroDataResult:
+        return await _execute(name, arguments, credentials_block)
+
+    run.__name__ = name
+    run.__qualname__ = name
+    run.__doc__ = _OPERATIONS[name].description
+    return task(
+        name=f"fxmacrodata-{name.replace('_', '-')}",
+        tags={"fxmacrodata"},
+        cache_policy=NO_CACHE,
+        persist_result=False,
+        log_prints=False,
+        retries=0,
+    )(run)
+
+
+OPERATION_TASKS = {name: _operation_task(name) for name in _OPERATIONS}
+globals().update(OPERATION_TASKS)
+
+
+@task(
+    name="fxmacrodata-complete-history",
+    cache_policy=NO_CACHE,
+    persist_result=False,
+    log_prints=False,
+    retries=0,
+    tags={"fxmacrodata"},
+)
+async def complete_history(
+    operation: str,
+    arguments: dict[str, Any] | None = None,
+    credentials_block: str | None = None,
+    max_pages: int = 10000,
+) -> FXMacroDataResult:
+    """Collect and verify every history page, retaining per-page metadata.
+
+    This downloads the available history for the supplied filters, starting at
+    offset zero. It fails instead of returning a partial dataset. Single-page
+    operation tasks remain available for applications managing their own pages.
+    """
+    if arguments and arguments.get("offset", 0) != 0:
+        raise FXMacroDataTaskError("Complete history starts at offset zero.")
+    return await _execute(
+        operation, arguments, credentials_block, complete=True, max_pages=max_pages
+    )
+
+
+@task(name="fxmacrodata-discover-operations", cache_policy=NO_CACHE, persist_result=False)
+async def discover_operations() -> tuple[OperationSchema, ...]:
+    """List every installed operation and its unchanged argument schema."""
+    return operation_schemas()
+
+
+__all__ = [
+    "OPERATION_TASKS",
+    "complete_history",
+    "discover_operations",
+    "operation_schemas",
+] + list(OPERATION_TASKS)

prefect_fxmacrodata/tasks.pyi

@@ -0,0 +1,93 @@
+from typing import Any, Coroutine
+
+from prefect import Task
+
+from .models import FXMacroDataResult, OperationSchema
+
+class FXMacroDataTaskError(RuntimeError): ...
+
+def operation_schemas() -> tuple[OperationSchema, ...]: ...
+
+complete_history: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+discover_operations: Task[..., Coroutine[Any, Any, tuple[OperationSchema, ...]]]
+OPERATION_TASKS: dict[str, Task[..., Coroutine[Any, Any, FXMacroDataResult]]]
+
+health: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+ping: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+forex: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+intraday_reference_rates: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+fx_sources: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+fx_source_universe: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+data_catalogue: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+release_calendar: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+market_sessions: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+rate_differentials: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+curves: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+financial_prices: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+press_releases: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+risk_sentiment: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+factors: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+event_predictions: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+latest_announcements: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+indicator_history: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+cot: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+latest_commodities: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+commodities: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+announcement_changes: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+stream_events: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+reference_rates: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+session_rates: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+prediction_coverage: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+currency_prediction_coverage: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+currency_predictions: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+research_panel: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_ping: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_mcp_capabilities: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_mcp_auth_guide: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_subscribe_for_mcp_access: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_data_catalogue: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_risk_sentiment: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_macro_news: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_release_calendar: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_release_calendar_visual_artifact: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_event_predictions: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_latest_announcements: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_announcement_changes: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_press_releases: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_macro_factor: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_fx_reference_sources: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_fx_reference_universe: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_fx_intraday_reference_rates: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_rate_curve: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_rate_differentials: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_latest_commodities: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_forex: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_seasonality: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_indicator_query: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_plot_visual_artifact: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_indicator_visual_artifact: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_forex_visual_artifact: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_commodities_visual_artifact: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_cot_visual_artifact: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_policy_rate_differential_visual_artifact: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_macro_briefing_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_indicator_intel_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_pair_intel_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_macro_heatmap_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_policy_scenario_modeler_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_macro_war_room_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_event_impact_replay_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_quant_scenario_lab_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_known_at_time_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_macro_regime_classifier_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_release_risk_score_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_portfolio_risk_engine_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_fx_trade_setup_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_fx_backtest_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_macro_research_pack_task: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_prediction_coverage: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_market_sessions: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_cot_data: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_commodities: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_financial_prices: Task[..., Coroutine[Any, Any, FXMacroDataResult]]
+mcp_official_dataset_family: Task[..., Coroutine[Any, Any, FXMacroDataResult]]

prefect_fxmacrodata-0.1.0.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: prefect-fxmacrodata
+Version: 0.1.0
+Summary: FXMacroData subscription data in Prefect tasks and research flows
+License-Expression: MIT
+Project-URL: Homepage, https://fxmacrodata.com/?utm_source=github&utm_medium=referral&utm_campaign=prefect&utm_content=readme
+Project-URL: Subscribe, https://fxmacrodata.com/subscribe?utm_source=github&utm_medium=referral&utm_campaign=prefect&utm_content=subscribe
+Project-URL: Documentation, https://fxmacrodata.com/documentation/reference?utm_source=github&utm_medium=referral&utm_campaign=prefect&utm_content=docs
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: prefect<4,>=3.9.1
+Requires-Dist: fxmacrodata-public-client==0.1.1
+Dynamic: license-file
+
+# FXMacroData for Prefect
+
+Bring your FXMacroData subscription into scheduled Prefect research workflows:
+cross-currency indicators, complete available histories, FX reference rates,
+commodities, positioning and release analysis. Store your API key in a Prefect
+Credentials Block and pass its name to native tasks.
+
+**[Subscribe to FXMacroData](https://fxmacrodata.com/subscribe?utm_source=github&utm_medium=referral&utm_campaign=prefect&utm_content=subscribe)**
+for subscriber coverage and deeper available history. Public USD catalogue,
+recent indicator history and calendar access let you evaluate the workflow
+before subscribing without an API key. Availability varies by dataset.
+
+## Install and connect
+
+Use Python 3.10–3.14 and Prefect 3.9.1 or later within version 3. From the release artifacts directory,
+install the adapter wheel into the environment that runs your flows. Its pinned
+FXMacroData public client is available on PyPI and resolves automatically:
+
+```bash
+python -m pip install ./prefect_fxmacrodata-0.1.0-py3-none-any.whl
+prefect block register -m prefect_fxmacrodata
+```
+
+The adapter uses the supplied release artifact; its public-client dependency
+comes from PyPI. Configure your Prefect server or Cloud workspace through Prefect's
+normal setup. In **Blocks**, create an **FXMacroData Credentials** block, enter
+your subscription API key and save it as `fxmacrodata-research`. The key uses
+Prefect's secret-field storage. The timeout controls each HTTP request, in seconds.
+
+To create the same block interactively without putting a key in source code:
+
+```python
+from getpass import getpass
+from pydantic import SecretStr
+from prefect_fxmacrodata import FXMacroDataCredentials
+
+FXMacroDataCredentials(
+    api_key=SecretStr(getpass("FXMacroData API key: ")),
+).save("fxmacrodata-research")
+```
+
+Create the block during setup, outside a flow. Flows and tasks take only its name;
+do not put keys in flow parameters, operation arguments or logs. Omitting
+`credentials_block` explicitly uses public evaluation access, even if an API-key
+environment variable is set.
+
+## Build a research flow
+
+`macro_snapshot` is a Prefect subflow that collects every available history page
+for the selected series and retrieves its release calendar. Pass the typed
+snapshot to your own downstream task:
+
+```python
+import asyncio
+from prefect import flow, task
+from prefect_fxmacrodata import MacroSnapshot, macro_snapshot
+
+
+@task(persist_result=False)
+def count_observations(snapshot: MacroSnapshot) -> int:
+    return len(snapshot.history.records())
+
+
+@flow(persist_result=False)
+async def research_run():
+    snapshot = await macro_snapshot(
+        "EUR",
+        "policy_rate",
+        credentials_block="fxmacrodata-research",
+        start_date="2020-01-01",
+        end_date="2026-01-01",
+    )
+    return count_observations(snapshot)
+
+
+if __name__ == "__main__":
+    asyncio.run(research_run())
+```
+
+To evaluate with USD, omit the credentials and historical date range:
+
+```python
+snapshot = await macro_snapshot("USD", "policy_rate")
+```
+
+Subscriber history can extend beyond the public evaluation window where the
+series supports it.
+Deploy or schedule this flow with your normal Prefect work pool and deployment process.
+The date filters select indicator history. The calendar uses the API's current
+release-calendar window for the currency; it is not filtered to the historical
+range or one indicator. Use the `release_calendar` task directly for different
+calendar filters.
+
+## Use individual operations
+
+Every packaged operation is a named Prefect task, with normal task states,
+dependencies, `with_options`, retries and scheduling through its enclosing flow.
+Both REST and hosted MCP operations are available:
+
+```python
+from prefect_fxmacrodata import operation_schemas
+from prefect_fxmacrodata.tasks import indicator_history, mcp_macro_briefing_task
+
+
+async def inspect_series():
+    page = await indicator_history(
+        {"currency": "GBP", "indicator": "inflation", "limit": 100},
+        credentials_block="fxmacrodata-research",
+    )
+    briefing = await mcp_macro_briefing_task(
+        {"currency": "GBP"},
+        credentials_block="fxmacrodata-research",
+    )
+    return page, briefing
+
+
+schemas = {operation.name: operation.input_schema for operation in operation_schemas()}
+```
+
+See [CAPABILITIES.md](CAPABILITIES.md) for the exact operation inventory. The
+original input schemas are available through `operation_schemas()` or the native
+`discover_operations` task. `OPERATION_TASKS[name]` supports configuration-driven
+flows without losing operation-specific task names.
+
+Results are `FXMacroDataResult` models. `payload` retains the entire service
+response, including original units, provenance, unavailable values and MCP
+content; `source_url` records the source endpoint. `records()` adds a convenient
+row view without replacing the payload. No publication timestamps or missing
+observations are inferred.
+
+## History and failure behavior
+
+Individual operation tasks return a single response using the API's pagination
+rules. Use `complete_history("indicator_history", arguments, credentials_block)`
+for a complete available dataset within the requested filters. It starts at
+offset zero, verifies contiguous pages and dataset versions when supplied, and
+fails if completion cannot be established. Its payload retains every page's
+metadata and returns rows in chronological order. `max_pages` is an explicit
+safety budget; an error never passes an incomplete history off as complete.
+Applications that need resumable storage can persist individual page responses
+and control `offset` and `dataset_version` through the named operation tasks.
+
+Event streaming is a bounded capture using `max_events` and `max_seconds`.
+The response retains the original completion flag and reason. Cancellation
+finishes the current bounded HTTP request, closes the client, and stops before
+the next history page. MCP sessions are closed after each task.
+
+Tasks disable result persistence and caching by default. Opt in only when the
+destination and access controls suit your data licence. Task errors omit raw
+responses, authenticated URLs and credentials. Transient retries are opt-in with
+Prefect's `with_options(retries=..., retry_delay_seconds=...)`.
+
+[FXMacroData API reference](https://fxmacrodata.com/documentation/reference?utm_source=github&utm_medium=referral&utm_campaign=prefect&utm_content=docs)
+describes access requirements and supported arguments for each dataset.

prefect_fxmacrodata-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+prefect_fxmacrodata/__init__.py,sha256=LLUeTNhnUbaqBbtcEtGWWzN0kaRCujYUrnQJ_17AOYk,591
+prefect_fxmacrodata/credentials.py,sha256=-GXhRmlaCAWRMGTb9SXiSsmj1NRkjZNUBoqfebHUss4,1201
+prefect_fxmacrodata/flows.py,sha256=YoBoUCaJRUqefKACZYO7P85FXVGBrrxRRNw8CjJ5bGw,1543
+prefect_fxmacrodata/models.py,sha256=qR_yHfRrquwhu3a31xVpDSuY_T1Mhqp0q0E3rsGiwaQ,1507
+prefect_fxmacrodata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prefect_fxmacrodata/tasks.py,sha256=YiGQfzl_XeXTttDTMAq4Rx9cXOJA6H2Q_JTXhJRAEMk,7234
+prefect_fxmacrodata/tasks.pyi,sha256=uTk-2XMNN9TlubBPAuKh7Oa7D3vGgm7ATP0ilPfuZtw,6205
+prefect_fxmacrodata-0.1.0.dist-info/licenses/LICENSE,sha256=rklK7Fl8aL1eWGubsrozZ7rCNTsN-MATw4M6LQIMv10,1092
+prefect_fxmacrodata-0.1.0.dist-info/METADATA,sha256=aILHtAzR5xMQhI_-Lw4mARuP1K9oMCu_JKmRLMcJBig,7448
+prefect_fxmacrodata-0.1.0.dist-info/WHEEL,sha256=16fc_9Rp854SLcdhaDEjr0u65p0e3FhZxihNgcnCE98,91
+prefect_fxmacrodata-0.1.0.dist-info/entry_points.txt,sha256=eC7MV_AR-BG1wfdU3NTJKb0Fha9W70pjVqPwKT1Y2Ro,64
+prefect_fxmacrodata-0.1.0.dist-info/top_level.txt,sha256=nHUn4WUIwHIoRhR8fwgU4wWSCyKbWQeKvFVHJoTSYaY,20
+prefect_fxmacrodata-0.1.0.dist-info/RECORD,,

prefect_fxmacrodata-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

prefect_fxmacrodata-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[prefect.collections]
+prefect_fxmacrodata = prefect_fxmacrodata

prefect_fxmacrodata-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Tidball
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

prefect_fxmacrodata-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+prefect_fxmacrodata