rabbitmq-fxmacrodata 0.1.0__tar.gz

rabbitmq_fxmacrodata-0.1.0/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.

rabbitmq_fxmacrodata-0.1.0/MANIFEST.in

@@ -0,0 +1,11 @@
+include LICENSE
+include README.md
+include pyproject.toml
+include PUBLIC_FILES.json
+include MANIFEST.in
+include src/fxmacrodata_rabbitmq/__init__.py
+include src/fxmacrodata_rabbitmq/py.typed
+include tests/test_publisher.py
+include examples/consumer_dedupe.py
+global-exclude *.pyc *.pyo
+global-exclude __pycache__/*

rabbitmq_fxmacrodata-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: rabbitmq-fxmacrodata
+Version: 0.1.0
+Summary: Publish public FXMacroData responses to RabbitMQ
+License-Expression: MIT
+Project-URL: Documentation, https://fxmacrodata.com/documentation/reference?utm_source=pypi&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=package
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fxmacrodata-platform-core==0.1.0
+Requires-Dist: pika<2,>=1.4.4
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+Dynamic: license-file
+
+# FXMacroData for RabbitMQ
+
+Publish FXMacroData public responses to a RabbitMQ exchange with the official
+`pika` Python client. Route macro announcements to your own queues while
+retaining the source payload and revision metadata.
+
+[FXMacroData documentation](https://fxmacrodata.com/documentation/reference?utm_source=github&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=readme)
+
+## Install and connect
+
+Requires Python 3.10 or later. Install this package and its adjacent public
+client dependencies from the distribution supplied to you:
+
+```sh
+python -m pip install /path/to/fxmacrodata-public-client /path/to/fxmacrodata-platform-core /path/to/rabbitmq-fxmacrodata
+```
+
+Configure `RABBITMQ_URL` (an `amqps://` URL with the credentials your
+administrator provides) in your runtime secret store. Then publish to a
+customer-owned exchange:
+
+```python
+import os
+import pika
+from fxmacrodata_platform_core import read
+from fxmacrodata_rabbitmq import publish
+
+connection = pika.BlockingConnection(pika.URLParameters(os.environ["RABBITMQ_URL"]))
+try:
+    channel = connection.channel()
+    batch = read("indicator_history", {"currency": "usd", "indicator": "policy_rate"})
+    result = publish(batch, channel, ("fxmacrodata", "usd.policy_rate"), confirm=True)
+    print(result.messages, "messages in", result.batches, "blocks")
+finally:
+    connection.close()
+```
+
+The exchange and any bound queues must already exist. The destination is an
+`(exchange, routing_key)` tuple; names accept letters, digits, `_`, `.`, `:`
+and `-` up to 255 characters. Use `("", "queue-name")` for the default
+exchange and `("exchange-name", "")` for a fanout exchange. Wildcards, URLs
+and other values are rejected before any publish.
+
+Every operation exposed by `fxmacrodata_platform_core.operations()` is
+available, including REST and MCP operations. `publish_operation` reads one
+operation and publishes it in a single call:
+
+```python
+from fxmacrodata_rabbitmq import publish_operation
+
+publish_operation("release_calendar", {"currency": "usd"}, channel, ("fxmacrodata", "usd.calendar"),
+                  api_key_env="FXMD_API_KEY")
+```
+
+## Message format
+
+Each envelope row becomes one persistent message (`delivery_mode=2`). The
+body is canonical UTF-8 JSON with the keys `operation`, `source_url`,
+`record_id`, `currency`, `indicator`, `date`, `announcement_datetime`,
+`value`, `value_text`, `record_json`, `response_json` and the publisher's
+`content_hash` (SHA-256 of the ten source columns). Only `value` is numeric.
+Dates and announcement times remain source strings. No publication time is
+inferred, and no missing value is filled. `record_json` retains the original
+record; `response_json` retains the complete response, including pagination
+and metadata. An empty response produces one message with `record_json`
+equal to `"null"`, so absence of data and the server's metadata remain
+inspectable. It is not an observation.
+
+`message_id` is `operation:record_id:content_hash`; the same source record
+with the same content always produces the same id, and changed data or
+metadata produces a different one. `content_type` is `application/json` and
+the headers `operation`, `record_id`, `content_hash` and `source_url` are set
+on every message. No timestamp property is derived from the data.
+
+## Delivery guarantee
+
+Delivery is at-least-once. Messages are published in blocks of `batch_size`
+rows (1 to 10,000, 1,000 by default). With `confirm=True` the channel enters
+publisher-confirm mode before the first publish, so a message the broker
+rejects or cannot route fails its block; without confirms, a broker-side
+failure surfaces only when the channel closes. A failed block raises
+`PublishError` without the broker's own diagnostic text and is not retried;
+earlier blocks may already be delivered. Consumers should deduplicate on
+`message_id`, or on the `operation`, `record_id` and `content_hash` headers.
+
+`max_message_bytes` (16 MiB by default) rejects an individual envelope larger
+than the budget before anything is published; keep it within the broker's
+`max_message_size`, and narrow the source date range to reduce the response
+size. The source response is materialized before publishing; choose a source
+date range suitable for memory.
+
+`publish_operation` accepts `api_key_env`, `complete_history`, `max_pages`
+and `client_factory` for the public source reader. Supply source credentials
+through your runtime secret store, exposing only the environment variable
+name; omit `api_key_env` for anonymous USD access. Destination authentication
+belongs to the connection you open with the official client. The adapter
+neither saves nor prints credentials and never places one in a message or
+header.
+
+The package licence covers this adapter code. FXMacroData data access and
+onward redistribution remain subject to your subscription and applicable
+licence. Publishing data to a broker does not grant permission to publish or
+resell it.
+
+## Development
+
+Tests run offline against an in-memory fake channel:
+
+```sh
+python -m pytest tests -q
+```
+
+Official SDK reference:
+[pika BlockingChannel.basic_publish](https://pika.readthedocs.io/en/stable/modules/adapters/blocking.html?utm_source=pypi&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=upstream-reference#pika.adapters.blocking_connection.BlockingChannel.basic_publish).

rabbitmq_fxmacrodata-0.1.0/PUBLIC_FILES.json

@@ -0,0 +1,11 @@
+[
+  "LICENSE",
+  "README.md",
+  "pyproject.toml",
+  "PUBLIC_FILES.json",
+  "MANIFEST.in",
+  "src/fxmacrodata_rabbitmq/__init__.py",
+  "src/fxmacrodata_rabbitmq/py.typed",
+  "tests/test_publisher.py",
+  "examples/consumer_dedupe.py"
+]

rabbitmq_fxmacrodata-0.1.0/README.md

@@ -0,0 +1,114 @@
+# FXMacroData for RabbitMQ
+
+Publish FXMacroData public responses to a RabbitMQ exchange with the official
+`pika` Python client. Route macro announcements to your own queues while
+retaining the source payload and revision metadata.
+
+[FXMacroData documentation](https://fxmacrodata.com/documentation/reference?utm_source=github&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=readme)
+
+## Install and connect
+
+Requires Python 3.10 or later. Install this package and its adjacent public
+client dependencies from the distribution supplied to you:
+
+```sh
+python -m pip install /path/to/fxmacrodata-public-client /path/to/fxmacrodata-platform-core /path/to/rabbitmq-fxmacrodata
+```
+
+Configure `RABBITMQ_URL` (an `amqps://` URL with the credentials your
+administrator provides) in your runtime secret store. Then publish to a
+customer-owned exchange:
+
+```python
+import os
+import pika
+from fxmacrodata_platform_core import read
+from fxmacrodata_rabbitmq import publish
+
+connection = pika.BlockingConnection(pika.URLParameters(os.environ["RABBITMQ_URL"]))
+try:
+    channel = connection.channel()
+    batch = read("indicator_history", {"currency": "usd", "indicator": "policy_rate"})
+    result = publish(batch, channel, ("fxmacrodata", "usd.policy_rate"), confirm=True)
+    print(result.messages, "messages in", result.batches, "blocks")
+finally:
+    connection.close()
+```
+
+The exchange and any bound queues must already exist. The destination is an
+`(exchange, routing_key)` tuple; names accept letters, digits, `_`, `.`, `:`
+and `-` up to 255 characters. Use `("", "queue-name")` for the default
+exchange and `("exchange-name", "")` for a fanout exchange. Wildcards, URLs
+and other values are rejected before any publish.
+
+Every operation exposed by `fxmacrodata_platform_core.operations()` is
+available, including REST and MCP operations. `publish_operation` reads one
+operation and publishes it in a single call:
+
+```python
+from fxmacrodata_rabbitmq import publish_operation
+
+publish_operation("release_calendar", {"currency": "usd"}, channel, ("fxmacrodata", "usd.calendar"),
+                  api_key_env="FXMD_API_KEY")
+```
+
+## Message format
+
+Each envelope row becomes one persistent message (`delivery_mode=2`). The
+body is canonical UTF-8 JSON with the keys `operation`, `source_url`,
+`record_id`, `currency`, `indicator`, `date`, `announcement_datetime`,
+`value`, `value_text`, `record_json`, `response_json` and the publisher's
+`content_hash` (SHA-256 of the ten source columns). Only `value` is numeric.
+Dates and announcement times remain source strings. No publication time is
+inferred, and no missing value is filled. `record_json` retains the original
+record; `response_json` retains the complete response, including pagination
+and metadata. An empty response produces one message with `record_json`
+equal to `"null"`, so absence of data and the server's metadata remain
+inspectable. It is not an observation.
+
+`message_id` is `operation:record_id:content_hash`; the same source record
+with the same content always produces the same id, and changed data or
+metadata produces a different one. `content_type` is `application/json` and
+the headers `operation`, `record_id`, `content_hash` and `source_url` are set
+on every message. No timestamp property is derived from the data.
+
+## Delivery guarantee
+
+Delivery is at-least-once. Messages are published in blocks of `batch_size`
+rows (1 to 10,000, 1,000 by default). With `confirm=True` the channel enters
+publisher-confirm mode before the first publish, so a message the broker
+rejects or cannot route fails its block; without confirms, a broker-side
+failure surfaces only when the channel closes. A failed block raises
+`PublishError` without the broker's own diagnostic text and is not retried;
+earlier blocks may already be delivered. Consumers should deduplicate on
+`message_id`, or on the `operation`, `record_id` and `content_hash` headers.
+
+`max_message_bytes` (16 MiB by default) rejects an individual envelope larger
+than the budget before anything is published; keep it within the broker's
+`max_message_size`, and narrow the source date range to reduce the response
+size. The source response is materialized before publishing; choose a source
+date range suitable for memory.
+
+`publish_operation` accepts `api_key_env`, `complete_history`, `max_pages`
+and `client_factory` for the public source reader. Supply source credentials
+through your runtime secret store, exposing only the environment variable
+name; omit `api_key_env` for anonymous USD access. Destination authentication
+belongs to the connection you open with the official client. The adapter
+neither saves nor prints credentials and never places one in a message or
+header.
+
+The package licence covers this adapter code. FXMacroData data access and
+onward redistribution remain subject to your subscription and applicable
+licence. Publishing data to a broker does not grant permission to publish or
+resell it.
+
+## Development
+
+Tests run offline against an in-memory fake channel:
+
+```sh
+python -m pytest tests -q
+```
+
+Official SDK reference:
+[pika BlockingChannel.basic_publish](https://pika.readthedocs.io/en/stable/modules/adapters/blocking.html?utm_source=pypi&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=upstream-reference#pika.adapters.blocking_connection.BlockingChannel.basic_publish).

rabbitmq_fxmacrodata-0.1.0/examples/consumer_dedupe.py

@@ -0,0 +1,29 @@
+"""Consume FXMacroData envelopes from a RabbitMQ queue, dropping redeliveries by message_id."""
+import json
+import os
+
+import pika
+
+seen: set[str] = set()
+
+
+def on_message(channel, method, properties, body):
+    key = properties.message_id or ":".join(
+        str((properties.headers or {}).get(name, "")) for name in ("operation", "record_id", "content_hash")
+    )
+    if key not in seen:
+        seen.add(key)
+        row = json.loads(body.decode("utf-8"))
+        if row["record_json"] != "null":
+            print(row["operation"], row["currency"], row["indicator"], row["date"], row["value"])
+    channel.basic_ack(method.delivery_tag)
+
+
+connection = pika.BlockingConnection(pika.URLParameters(os.environ["RABBITMQ_URL"]))
+try:
+    channel = connection.channel()
+    channel.basic_qos(prefetch_count=100)
+    channel.basic_consume("fxmacrodata-queue", on_message)
+    channel.start_consuming()
+finally:
+    connection.close()

rabbitmq_fxmacrodata-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rabbitmq-fxmacrodata"
+version = "0.1.0"
+description = "Publish public FXMacroData responses to RabbitMQ"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = ["fxmacrodata-platform-core==0.1.0", "pika>=1.4.4,<2"]
+
+[project.urls]
+Documentation = "https://fxmacrodata.com/documentation/reference?utm_source=pypi&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=package"
+
+[project.optional-dependencies]
+test = ["pytest>=8,<9"]
+
+[tool.setuptools]
+packages = ["fxmacrodata_rabbitmq"]
+package-dir = {"" = "src"}
+include-package-data = false
+
+[tool.setuptools.package-data]
+fxmacrodata_rabbitmq = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"

rabbitmq_fxmacrodata-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rabbitmq_fxmacrodata-0.1.0/src/fxmacrodata_rabbitmq/__init__.py

@@ -0,0 +1,168 @@
+"""Publish public FXMacroData responses to a customer-owned RabbitMQ exchange."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import json
+import math
+import re
+from typing import Any
+
+import pika
+from fxmacrodata_platform_core import read
+
+__version__ = "0.1.0"
+
+COLUMNS = (
+    "operation", "source_url", "record_id", "currency", "indicator", "date",
+    "announcement_datetime", "value", "value_text", "record_json", "response_json",
+    "content_hash",
+)
+HEADERS = ("operation", "record_id", "content_hash", "source_url")
+MAX_MESSAGE_BYTES = 16 * 1024 * 1024
+_NAME = re.compile(r"[A-Za-z0-9_.:-]{0,255}\Z")
+
+
+class PublishError(RuntimeError):
+    """A destination publish failed; inspect the destination before retrying."""
+
+
+@dataclass(frozen=True)
+class PublishResult:
+    destination: str
+    messages: int
+    batches: int
+
+
+def _destination(destination: Any) -> tuple[str, str]:
+    if not isinstance(destination, tuple) or len(destination) != 2:
+        raise ValueError("destination must be an (exchange, routing_key) tuple")
+    exchange, routing_key = destination
+    if not isinstance(exchange, str) or not isinstance(routing_key, str):
+        raise ValueError("exchange and routing_key must be strings")
+    if not _NAME.fullmatch(exchange) or not _NAME.fullmatch(routing_key):
+        raise ValueError("exchange and routing_key accept letters, digits, '_', '.', ':' and '-' only")
+    if not exchange and not routing_key:
+        raise ValueError("the default exchange requires a routing_key naming the queue")
+    return exchange, routing_key
+
+
+def _bounds(batch_size: int, max_message_bytes: int, confirm: bool) -> None:
+    if isinstance(batch_size, bool) or not isinstance(batch_size, int) or not 1 <= batch_size <= 10000:
+        raise ValueError("batch_size must be an integer between 1 and 10000")
+    if isinstance(max_message_bytes, bool) or not isinstance(max_message_bytes, int) or not 1 <= max_message_bytes <= MAX_MESSAGE_BYTES:
+        raise ValueError(f"max_message_bytes must be an integer between 1 and {MAX_MESSAGE_BYTES}")
+    if not isinstance(confirm, bool):
+        raise ValueError("confirm must be a boolean")
+
+
+def _rows(batch: Any) -> list[dict[str, Any]]:
+    rows = []
+    for source in batch.rows():
+        row = {name: source.get(name) for name in COLUMNS[:-1]}
+        if not isinstance(row["operation"], str) or not isinstance(row["record_id"], str):
+            raise ValueError("every row requires string operation and record_id")
+        for name, value in row.items():
+            if name == "value":
+                if value is not None and (
+                    isinstance(value, bool) or not isinstance(value, (int, float)) or
+                    not math.isfinite(value)
+                ):
+                    raise ValueError("value must be a finite number or null")
+            elif value is not None and not isinstance(value, str):
+                raise ValueError(f"{name} must be a string or null")
+        encoded = json.dumps(row, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+        row["content_hash"] = hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+        rows.append(row)
+    return rows
+
+
+def message_key(row: dict[str, Any]) -> str:
+    """Return the idempotency key used as the AMQP message_id."""
+    return f"{row['operation']}:{row['record_id']}:{row['content_hash']}"
+
+
+def encode_message(row: dict[str, Any]) -> bytes:
+    """Return the canonical UTF-8 JSON body for one envelope row."""
+    return json.dumps(row, sort_keys=True, separators=(",", ":"), ensure_ascii=False,
+                      allow_nan=False).encode("utf-8")
+
+
+def _properties(row: dict[str, Any]) -> pika.BasicProperties:
+    return pika.BasicProperties(
+        delivery_mode=2, content_type="application/json", content_encoding="utf-8",
+        message_id=message_key(row),
+        headers={name: row[name] for name in HEADERS if row.get(name) is not None},
+    )
+
+
+def _blocks(rows: list[dict[str, Any]], batch_size: int,
+            max_message_bytes: int) -> list[list[tuple[bytes, pika.BasicProperties]]]:
+    output: list[list[tuple[bytes, pika.BasicProperties]]] = []
+    block: list[tuple[bytes, pika.BasicProperties]] = []
+    for row in rows:
+        body = encode_message(row)
+        if len(body) > max_message_bytes:
+            raise ValueError("one envelope exceeds max_message_bytes; narrow the source date range")
+        if len(block) >= batch_size:
+            output.append(block)
+            block = []
+        block.append((body, _properties(row)))
+    if block:
+        output.append(block)
+    return output
+
+
+def publish(batch: Any, channel: Any, destination: tuple[str, str], *, batch_size: int = 1000,
+            max_message_bytes: int = MAX_MESSAGE_BYTES, confirm: bool = False) -> PublishResult:
+    """Publish one persistent message per envelope row through BlockingChannel.basic_publish.
+
+    Messages carry the canonical JSON body, `message_id` equal to
+    `operation:record_id:content_hash`, `content_type` application/json and
+    the headers `operation`, `record_id`, `content_hash` and `source_url`.
+    With `confirm=True` the channel enters publisher-confirm mode before the
+    first publish, so an unroutable or rejected message fails the block.
+    Delivery is at-least-once; a failed block raises PublishError and is not
+    retried.
+    """
+    exchange, routing_key = _destination(destination)
+    _bounds(batch_size, max_message_bytes, confirm)
+    blocks = _blocks(_rows(batch), batch_size, max_message_bytes)
+    if confirm:
+        try:
+            channel.confirm_delivery()
+        except Exception:
+            raise PublishError("RabbitMQ publisher confirms could not be enabled; inspect the channel.") from None
+    count, messages = 0, 0
+    for block in blocks:
+        try:
+            for body, properties in block:
+                channel.basic_publish(exchange, routing_key, body, properties=properties)
+        except Exception:
+            raise PublishError(
+                f"RabbitMQ publish block {count + 1} failed; earlier blocks may be delivered. "
+                "Inspect the destination and deduplicate by message_id on retry."
+            ) from None
+        count += 1
+        messages += len(block)
+    return PublishResult(f"{exchange}/{routing_key}", messages, count)
+
+
+def publish_operation(operation: str, args: dict[str, Any] | None, channel: Any,
+                      destination: tuple[str, str], *, api_key_env: str | None = None,
+                      complete_history: bool = True, max_pages: int = 10000,
+                      client_factory: Any = None, batch_size: int = 1000,
+                      max_message_bytes: int = MAX_MESSAGE_BYTES, confirm: bool = False) -> PublishResult:
+    """Read one public operation and publish its complete response envelope."""
+    _destination(destination)
+    _bounds(batch_size, max_message_bytes, confirm)
+    batch = read(operation, args, api_key_env=api_key_env,
+                 complete_history=complete_history, max_pages=max_pages,
+                 client_factory=client_factory)
+    return publish(batch, channel, destination, batch_size=batch_size,
+                   max_message_bytes=max_message_bytes, confirm=confirm)
+
+
+__all__ = ["COLUMNS", "HEADERS", "MAX_MESSAGE_BYTES", "PublishError", "PublishResult",
+           "encode_message", "message_key", "publish", "publish_operation"]

rabbitmq_fxmacrodata-0.1.0/src/rabbitmq_fxmacrodata.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: rabbitmq-fxmacrodata
+Version: 0.1.0
+Summary: Publish public FXMacroData responses to RabbitMQ
+License-Expression: MIT
+Project-URL: Documentation, https://fxmacrodata.com/documentation/reference?utm_source=pypi&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=package
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fxmacrodata-platform-core==0.1.0
+Requires-Dist: pika<2,>=1.4.4
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == "test"
+Dynamic: license-file
+
+# FXMacroData for RabbitMQ
+
+Publish FXMacroData public responses to a RabbitMQ exchange with the official
+`pika` Python client. Route macro announcements to your own queues while
+retaining the source payload and revision metadata.
+
+[FXMacroData documentation](https://fxmacrodata.com/documentation/reference?utm_source=github&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=readme)
+
+## Install and connect
+
+Requires Python 3.10 or later. Install this package and its adjacent public
+client dependencies from the distribution supplied to you:
+
+```sh
+python -m pip install /path/to/fxmacrodata-public-client /path/to/fxmacrodata-platform-core /path/to/rabbitmq-fxmacrodata
+```
+
+Configure `RABBITMQ_URL` (an `amqps://` URL with the credentials your
+administrator provides) in your runtime secret store. Then publish to a
+customer-owned exchange:
+
+```python
+import os
+import pika
+from fxmacrodata_platform_core import read
+from fxmacrodata_rabbitmq import publish
+
+connection = pika.BlockingConnection(pika.URLParameters(os.environ["RABBITMQ_URL"]))
+try:
+    channel = connection.channel()
+    batch = read("indicator_history", {"currency": "usd", "indicator": "policy_rate"})
+    result = publish(batch, channel, ("fxmacrodata", "usd.policy_rate"), confirm=True)
+    print(result.messages, "messages in", result.batches, "blocks")
+finally:
+    connection.close()
+```
+
+The exchange and any bound queues must already exist. The destination is an
+`(exchange, routing_key)` tuple; names accept letters, digits, `_`, `.`, `:`
+and `-` up to 255 characters. Use `("", "queue-name")` for the default
+exchange and `("exchange-name", "")` for a fanout exchange. Wildcards, URLs
+and other values are rejected before any publish.
+
+Every operation exposed by `fxmacrodata_platform_core.operations()` is
+available, including REST and MCP operations. `publish_operation` reads one
+operation and publishes it in a single call:
+
+```python
+from fxmacrodata_rabbitmq import publish_operation
+
+publish_operation("release_calendar", {"currency": "usd"}, channel, ("fxmacrodata", "usd.calendar"),
+                  api_key_env="FXMD_API_KEY")
+```
+
+## Message format
+
+Each envelope row becomes one persistent message (`delivery_mode=2`). The
+body is canonical UTF-8 JSON with the keys `operation`, `source_url`,
+`record_id`, `currency`, `indicator`, `date`, `announcement_datetime`,
+`value`, `value_text`, `record_json`, `response_json` and the publisher's
+`content_hash` (SHA-256 of the ten source columns). Only `value` is numeric.
+Dates and announcement times remain source strings. No publication time is
+inferred, and no missing value is filled. `record_json` retains the original
+record; `response_json` retains the complete response, including pagination
+and metadata. An empty response produces one message with `record_json`
+equal to `"null"`, so absence of data and the server's metadata remain
+inspectable. It is not an observation.
+
+`message_id` is `operation:record_id:content_hash`; the same source record
+with the same content always produces the same id, and changed data or
+metadata produces a different one. `content_type` is `application/json` and
+the headers `operation`, `record_id`, `content_hash` and `source_url` are set
+on every message. No timestamp property is derived from the data.
+
+## Delivery guarantee
+
+Delivery is at-least-once. Messages are published in blocks of `batch_size`
+rows (1 to 10,000, 1,000 by default). With `confirm=True` the channel enters
+publisher-confirm mode before the first publish, so a message the broker
+rejects or cannot route fails its block; without confirms, a broker-side
+failure surfaces only when the channel closes. A failed block raises
+`PublishError` without the broker's own diagnostic text and is not retried;
+earlier blocks may already be delivered. Consumers should deduplicate on
+`message_id`, or on the `operation`, `record_id` and `content_hash` headers.
+
+`max_message_bytes` (16 MiB by default) rejects an individual envelope larger
+than the budget before anything is published; keep it within the broker's
+`max_message_size`, and narrow the source date range to reduce the response
+size. The source response is materialized before publishing; choose a source
+date range suitable for memory.
+
+`publish_operation` accepts `api_key_env`, `complete_history`, `max_pages`
+and `client_factory` for the public source reader. Supply source credentials
+through your runtime secret store, exposing only the environment variable
+name; omit `api_key_env` for anonymous USD access. Destination authentication
+belongs to the connection you open with the official client. The adapter
+neither saves nor prints credentials and never places one in a message or
+header.
+
+The package licence covers this adapter code. FXMacroData data access and
+onward redistribution remain subject to your subscription and applicable
+licence. Publishing data to a broker does not grant permission to publish or
+resell it.
+
+## Development
+
+Tests run offline against an in-memory fake channel:
+
+```sh
+python -m pytest tests -q
+```
+
+Official SDK reference:
+[pika BlockingChannel.basic_publish](https://pika.readthedocs.io/en/stable/modules/adapters/blocking.html?utm_source=pypi&utm_medium=referral&utm_campaign=rabbitmq-fxmacrodata&utm_content=upstream-reference#pika.adapters.blocking_connection.BlockingChannel.basic_publish).

rabbitmq_fxmacrodata-0.1.0/src/rabbitmq_fxmacrodata.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+PUBLIC_FILES.json
+README.md
+pyproject.toml
+examples/consumer_dedupe.py
+src/fxmacrodata_rabbitmq/__init__.py
+src/fxmacrodata_rabbitmq/py.typed
+src/rabbitmq_fxmacrodata.egg-info/PKG-INFO
+src/rabbitmq_fxmacrodata.egg-info/SOURCES.txt
+src/rabbitmq_fxmacrodata.egg-info/dependency_links.txt
+src/rabbitmq_fxmacrodata.egg-info/requires.txt
+src/rabbitmq_fxmacrodata.egg-info/top_level.txt
+tests/test_publisher.py

rabbitmq_fxmacrodata-0.1.0/src/rabbitmq_fxmacrodata.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rabbitmq_fxmacrodata-0.1.0/src/rabbitmq_fxmacrodata.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fxmacrodata-platform-core==0.1.0
+pika<2,>=1.4.4
+
+[test]
+pytest<9,>=8

rabbitmq_fxmacrodata-0.1.0/src/rabbitmq_fxmacrodata.egg-info/top_level.txt

@@ -0,0 +1 @@
+fxmacrodata_rabbitmq

rabbitmq_fxmacrodata-0.1.0/tests/test_publisher.py

@@ -0,0 +1,169 @@
+import json
+
+import pika
+import pytest
+
+from fxmacrodata_platform_core import Batch, IntegrationError
+import fxmacrodata_rabbitmq as adapter
+
+
+class Channel:
+    def __init__(self, fail_message=None, fail_confirm=False):
+        self.published = []
+        self.confirms = 0
+        self.fail_message = fail_message
+        self.fail_confirm = fail_confirm
+
+    def confirm_delivery(self):
+        if self.fail_confirm:
+            raise RuntimeError("private destination diagnostic")
+        self.confirms += 1
+
+    def basic_publish(self, exchange, routing_key, body, properties=None, mandatory=False):
+        self.published.append((exchange, routing_key, body, properties))
+        if len(self.published) == self.fail_message:
+            raise RuntimeError("private destination diagnostic")
+
+
+DESTINATION = ("fxmacrodata", "usd.policy_rate")
+
+
+def batch(count=3, metadata=None):
+    return Batch("indicator_history", {
+        "data": [{"currency": "USD", "indicator": "policy_rate", "value": str(i),
+                  "date": "2026-10-01", "publication_time_status": "unknown"}
+                 for i in range(count)],
+        "metadata": metadata or {"revision": 1},
+    })
+
+
+def test_messages_preserve_full_payload_and_carry_dedup_properties():
+    source, channel = batch(), Channel()
+    result = adapter.publish(source, channel, DESTINATION, batch_size=2)
+    assert result == adapter.PublishResult("fxmacrodata/usd.policy_rate", 3, 2)
+    exchange, routing_key, body, properties = channel.published[0]
+    row = json.loads(body.decode("utf-8"))
+    assert (exchange, routing_key) == DESTINATION
+    assert set(row) == set(adapter.COLUMNS)
+    assert row["date"] == "2026-10-01" and row["announcement_datetime"] is None
+    assert row["value"] == 0.0 and row["value_text"] == "0"
+    assert json.loads(row["record_json"])["publication_time_status"] == "unknown"
+    assert json.loads(row["response_json"]) == source.payload
+    assert isinstance(properties, pika.BasicProperties)
+    assert properties.delivery_mode == 2 and properties.content_type == "application/json"
+    assert properties.message_id == f"indicator_history:{row['record_id']}:{row['content_hash']}"
+    assert properties.headers == {"operation": "indicator_history", "record_id": row["record_id"],
+                                  "content_hash": row["content_hash"], "source_url": "https://fxmacrodata.com"}
+    assert body == json.dumps(row, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+    assert channel.confirms == 0
+
+
+def test_empty_response_is_a_metadata_envelope_not_an_observation():
+    source, channel = batch(0), Channel()
+    result = adapter.publish(source, channel, DESTINATION)
+    row = json.loads(channel.published[0][2])
+    assert result.messages == 1 and row["record_json"] == "null"
+    assert row["value"] is None and row["date"] is None
+    assert json.loads(row["response_json"]) == source.payload
+
+
+def test_retries_have_stable_keys_and_changed_metadata_is_distinct():
+    first, retry, changed = Channel(), Channel(), Channel()
+    adapter.publish(batch(1), first, DESTINATION)
+    adapter.publish(batch(1), retry, DESTINATION)
+    adapter.publish(batch(1, {"revision": 2}), changed, DESTINATION)
+    assert first.published[0][2] == retry.published[0][2]
+    assert first.published[0][3].message_id == retry.published[0][3].message_id
+    assert first.published[0][3].headers["record_id"] == changed.published[0][3].headers["record_id"]
+    assert first.published[0][3].message_id != changed.published[0][3].message_id
+
+
+@pytest.mark.parametrize("destination", [
+    "fxmacrodata", ("fxmacrodata",), ("", ""), ("amq.topic", "usd.*"), ("ex change", "k"),
+    ("amqp://host/ex", "k"), ("ex", "x" * 256), (None, "k"), ("ex", 7),
+])
+def test_bad_destinations_never_publish(destination):
+    channel = Channel()
+    with pytest.raises(ValueError):
+        adapter.publish(batch(), channel, destination)
+    assert channel.published == [] and channel.confirms == 0
+
+
+def test_default_exchange_and_fanout_routing_are_accepted():
+    channel = Channel()
+    adapter.publish(batch(1), channel, ("", "fxmacrodata-queue"))
+    adapter.publish(batch(1), channel, ("fxmacrodata-fanout", ""))
+    assert [(e, k) for e, k, _, _ in channel.published] == [("", "fxmacrodata-queue"), ("fxmacrodata-fanout", "")]
+
+
+@pytest.mark.parametrize("options", [
+    {"batch_size": 0}, {"batch_size": -1}, {"batch_size": 10001}, {"batch_size": True},
+    {"batch_size": 2.5}, {"max_message_bytes": 0}, {"max_message_bytes": 16 * 1024 * 1024 + 1},
+    {"confirm": "yes"},
+])
+def test_batch_bounds(options):
+    channel = Channel()
+    with pytest.raises(ValueError):
+        adapter.publish(batch(), channel, DESTINATION, **options)
+    assert channel.published == [] and channel.confirms == 0
+
+
+def test_failed_block_is_not_retried_or_exposed():
+    channel = Channel(fail_message=2)
+    with pytest.raises(adapter.PublishError) as error:
+        adapter.publish(batch(), channel, DESTINATION, batch_size=1)
+    assert "block 2" in str(error.value)
+    assert "private destination diagnostic" not in str(error.value)
+    assert len(channel.published) == 2
+
+
+def test_oversized_envelope_fails_before_any_publish():
+    channel = Channel()
+    with pytest.raises(ValueError, match="narrow the source date range"):
+        adapter.publish(batch(), channel, DESTINATION, max_message_bytes=1, confirm=True)
+    assert channel.published == [] and channel.confirms == 0
+
+
+def test_confirm_enables_publisher_confirms_before_the_first_publish():
+    channel = Channel()
+    adapter.publish(batch(2), channel, DESTINATION, confirm=True)
+    assert channel.confirms == 1 and len(channel.published) == 2
+    failing = Channel(fail_confirm=True)
+    with pytest.raises(adapter.PublishError) as error:
+        adapter.publish(batch(2), failing, DESTINATION, confirm=True)
+    assert "private destination diagnostic" not in str(error.value)
+    assert failing.published == []
+
+
+def test_operation_forwards_public_reader_options(monkeypatch):
+    calls = []
+    monkeypatch.setattr(adapter, "read", lambda *args, **kw: calls.append((args, kw)) or batch(1))
+    factory = object()
+    adapter.publish_operation("indicator_history", {"currency": "usd", "indicator": "policy_rate"},
+                              Channel(), DESTINATION, api_key_env="FXMD_API_KEY", max_pages=12,
+                              complete_history=False, client_factory=factory)
+    assert calls[0][0] == ("indicator_history", {"currency": "usd", "indicator": "policy_rate"})
+    assert calls[0][1] == dict(api_key_env="FXMD_API_KEY", complete_history=False,
+                                max_pages=12, client_factory=factory)
+
+
+def test_invalid_configuration_never_reads_source(monkeypatch):
+    def unexpected(*args, **kwargs):
+        pytest.fail("source must not be called for invalid publisher configuration")
+    monkeypatch.setattr(adapter, "read", unexpected)
+    for options in ({"batch_size": 0}, {"max_message_bytes": 0}, {"confirm": 1}):
+        with pytest.raises(ValueError):
+            adapter.publish_operation("release_calendar", {"currency": "usd"}, Channel(), DESTINATION, **options)
+    with pytest.raises(ValueError):
+        adapter.publish_operation("release_calendar", {"currency": "usd"}, Channel(), ("", ""))
+
+
+def test_credential_arguments_are_rejected_before_publishing():
+    channel = Channel()
+    with pytest.raises(IntegrationError):
+        adapter.publish_operation("indicator_history", {"currency": "usd", "indicator": "policy_rate",
+                                                        "api_key": "secret"}, channel, DESTINATION)
+    with pytest.raises(IntegrationError):
+        adapter.publish_operation("release_calendar", {"currency": "usd"}, channel, DESTINATION,
+                                  api_key_env="not-an-env-name")
+    assert channel.published == []