parsimony-eodhd 0.0.1__py3-none-any.whl

parsimony_eodhd/__init__.py

@@ -0,0 +1,662 @@
+"""EODHD source: end-of-day, intraday, fundamentals, news, calendars, macro.
+
+API docs: https://eodhd.com/financial-apis/
+Authentication: ``api_token`` query parameter (in the transport sensitive-param
+  set, so it is redacted from every log line and never reaches a surfaced URL).
+Base URL: https://eodhd.com/api
+
+Provides 17 plain ``@connector`` verbs over the EODHD REST surface:
+  - Market data: EOD prices, live quotes, intraday, bulk EOD
+  - Corporate actions: dividends, splits
+  - Reference: search, exchanges, exchange symbol lists
+  - Fundamentals (raw nested dict)
+  - Calendars: earnings, IPO, trends, splits
+  - News
+  - Macro indicators (single + bulk)
+  - Technical indicators
+  - Insider transactions
+  - Screener
+
+The API key is declared as a secret (stripped from provenance) and supplied
+either by binding (``load(api_key=...)`` / ``Connector.bind``) or, as a dev
+fallback, from the ``EODHD_API_KEY`` environment variable. A missing key fails
+fast with :class:`UnauthorizedError` naming the env var.
+
+Status semantics (verified live 2026-06-04): an invalid key returns 401
+(→ :class:`UnauthorizedError`); a plan-restricted endpoint returns 403, and a
+bulk plan-restriction returns 423 Locked — both surfaced as
+:class:`PaymentRequiredError`. Many verbs require a paid EODHD plan; their
+docstrings tag the minimum plan as ``[Free+]``, ``[EOD+Intraday+]``, or
+``[Fundamentals+]`` and they return :class:`PaymentRequiredError` on a free key.
+
+Internal layout (not part of the public contract):
+
+* :mod:`parsimony_eodhd._http` — keyed client builder and error mapping.
+* :mod:`parsimony_eodhd.outputs` — declarative :class:`OutputConfig` schemas.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Annotated, Any, Literal
+
+import pandas as pd
+from parsimony import Namespace
+from parsimony.connector import Connectors, connector
+from parsimony.errors import EmptyDataError, InvalidParameterError, ParseError
+
+from parsimony_eodhd._http import _client, eodhd_get
+from parsimony_eodhd.outputs import BULK_EOD_OUTPUT as _BULK_EOD_OUTPUT
+from parsimony_eodhd.outputs import CALENDAR_OUTPUT as _CALENDAR_OUTPUT
+from parsimony_eodhd.outputs import DIVIDENDS_OUTPUT as _DIVIDENDS_OUTPUT
+from parsimony_eodhd.outputs import EOD_OUTPUT as _EOD_OUTPUT
+from parsimony_eodhd.outputs import EXCHANGE_SYMBOLS_OUTPUT as _EXCHANGE_SYMBOLS_OUTPUT
+from parsimony_eodhd.outputs import EXCHANGES_OUTPUT as _EXCHANGES_OUTPUT
+from parsimony_eodhd.outputs import INSIDER_OUTPUT as _INSIDER_OUTPUT
+from parsimony_eodhd.outputs import INTRADAY_OUTPUT as _INTRADAY_OUTPUT
+from parsimony_eodhd.outputs import LIVE_OUTPUT as _LIVE_OUTPUT
+from parsimony_eodhd.outputs import MACRO_OUTPUT as _MACRO_OUTPUT
+from parsimony_eodhd.outputs import NEWS_OUTPUT as _NEWS_OUTPUT
+from parsimony_eodhd.outputs import SCREENER_OUTPUT as _SCREENER_OUTPUT
+from parsimony_eodhd.outputs import SEARCH_OUTPUT as _SEARCH_OUTPUT
+from parsimony_eodhd.outputs import SPLITS_OUTPUT as _SPLITS_OUTPUT
+from parsimony_eodhd.outputs import TECHNICAL_OUTPUT as _TECHNICAL_OUTPUT
+
+__all__ = ["CONNECTORS", "load"]
+
+_PROVIDER = "eodhd"
+
+_LATENCY_TIMEOUT: float = 10.0
+_BULK_TIMEOUT: float = 60.0
+
+# Technical-indicator function names accepted by eodhd_technical.
+_TechnicalFunction = Literal[
+    "sma",
+    "ema",
+    "wma",
+    "volatility",
+    "stochastic",
+    "rsi",
+    "stddev",
+    "stochrsi",
+    "slope",
+    "dmi",
+    "adx",
+    "macd",
+    "atr",
+    "cci",
+    "sar",
+    "bbands",
+    "splitadjusted",
+    "avgvol",
+    "avgvolacave",
+    "williams_r",
+]
+
+# Guard for values interpolated directly into request paths
+# (``/eod/<ticker>``, ``/exchange-symbol-list/<exchange>`` etc.).
+_PATH_TOKEN_RE = re.compile(r"^[A-Za-z0-9._\-]+$")
+
+
+def _safe_path_token(value: str, name: str) -> str:
+    """Validate and return a value that is interpolated into a request path."""
+    cleaned = value.strip()
+    if not cleaned:
+        raise InvalidParameterError(_PROVIDER, f"{name} must be non-empty")
+    if not _PATH_TOKEN_RE.match(cleaned):
+        raise InvalidParameterError(_PROVIDER, f"{name} contains unsafe characters for a URL path: {value!r}")
+    return cleaned
+
+
+def _select_declared(df: pd.DataFrame, output: Any) -> pd.DataFrame:
+    """Project a frame to the columns the schema declares, in declared order.
+
+    Drops provider extras not in the schema. Missing declared columns are filled
+    with ``NA`` so :class:`~parsimony.result.OutputConfig` can shape sparse
+    payloads (calendar types, dividend-adjusted prices, etc.) without folding
+    extras in as stray DATA columns. Wildcard (``"*"``) schemas keep unmapped
+    columns after the fixed prefix.
+    """
+    names = [c.name for c in output.columns]
+    fixed = [n for n in names if n != "*"]
+    out = df.copy()
+    for n in fixed:
+        if n not in out.columns:
+            out[n] = pd.NA
+    if "*" in names:
+        extra = [c for c in out.columns if c not in fixed]
+        return out[fixed + extra]
+    return out[fixed]
+
+
+def _rows_to_frame(data: Any, op_name: str, query_params: dict[str, Any]) -> pd.DataFrame:
+    """Build a DataFrame from a JSON list of records; guard empty/parse failures."""
+    if not isinstance(data, list):
+        raise ParseError(_PROVIDER, f"{op_name} response was not a JSON array")
+    if not data:
+        raise EmptyDataError(_PROVIDER, query_params=query_params)
+    df = pd.DataFrame(data)
+    if df.empty:
+        raise EmptyDataError(_PROVIDER, query_params=query_params)
+    return df
+
+
+# ---------------------------------------------------------------------------
+# Reference Data — search / exchanges / exchange symbols
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_SEARCH_OUTPUT, tags=["eodhd", "tool"], secrets=("api_key",))
+def eodhd_search(
+    query: str,
+    limit: int = 50,
+    type: Literal["stock", "etf", "fund", "bond", "index"] | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Free+] Search EODHD for instruments by company name or partial ticker.
+    Resolves names to EODHD ticker codes (format TICKER.EXCHANGE, e.g. AAPL.US).
+    Returns Code, Name, Exchange, Type, Country, Currency, ISIN. Optionally
+    filter by type: stock, etf, fund, bond, index.
+    """
+    q = query.strip()
+    if not q:
+        raise InvalidParameterError(_PROVIDER, "query must be non-empty")
+    if limit < 1 or limit > 500:
+        raise InvalidParameterError(_PROVIDER, "limit must be between 1 and 500")
+
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path=f"search/{q}",
+        params={"limit": limit, "type": type},
+        op_name="eodhd_search",
+    )
+    df = _rows_to_frame(data, "eodhd_search", {"query": q})
+    return _select_declared(df, _SEARCH_OUTPUT)
+
+
+@connector(output=_EXCHANGES_OUTPUT, tags=["eodhd", "tool"], secrets=("api_key",))
+def eodhd_exchanges(api_key: str = "") -> pd.DataFrame:
+    """[Free+] List all exchanges supported by EODHD. Returns Code, Name, country,
+    currency and operating MIC. Use the Code with eodhd_bulk_eod and
+    eodhd_exchange_symbols.
+    """
+    http = _client(api_key)
+    data = eodhd_get(http, path="exchanges-list", op_name="eodhd_exchanges")
+    df = _rows_to_frame(data, "eodhd_exchanges", {})
+    return _select_declared(df, _EXCHANGES_OUTPUT)
+
+
+@connector(output=_EXCHANGE_SYMBOLS_OUTPUT, tags=["eodhd"], secrets=("api_key",))
+def eodhd_exchange_symbols(
+    exchange: str,
+    type: Literal["common_stock", "preferred_stock", "stock", "etf", "fund"] | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Free+] List all symbols traded on an exchange (returns Code, Name, country,
+    exchange, currency, type, ISIN). Large response for major exchanges (US has
+    50 000+ symbols) — use the type filter to narrow. Empty result may indicate
+    an invalid exchange code.
+    """
+    ex = _safe_path_token(exchange, "exchange")
+    http = _client(api_key, timeout=_BULK_TIMEOUT)
+    data = eodhd_get(
+        http,
+        path=f"exchange-symbol-list/{ex}",
+        params={"type": type},
+        op_name="eodhd_exchange_symbols",
+    )
+    df = _rows_to_frame(data, "eodhd_exchange_symbols", {"exchange": ex})
+    return _select_declared(df, _EXCHANGE_SYMBOLS_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# Market Data — EOD / live / intraday / bulk
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_EOD_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_eod(
+    ticker: Annotated[str, Namespace("eodhd_symbols")],
+    from_date: str | None = None,
+    to_date: str | None = None,
+    period: Literal["d", "w", "m"] | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Free+] Fetch end-of-day OHLCV prices for a ticker. Supports daily, weekly,
+    and monthly aggregation via period. Use from_date/to_date (ISO 8601) to limit
+    the range. Empty result may indicate an invalid ticker or exchange code —
+    verify with eodhd_search first. Free tier is limited to ~1 year of history.
+    """
+    t = _safe_path_token(ticker, "ticker")
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path=f"eod/{t}",
+        params={"from": from_date, "to": to_date, "period": period},
+        op_name="eodhd_eod",
+    )
+    df = _rows_to_frame(data, "eodhd_eod", {"ticker": t})
+    return _select_declared(df, _EOD_OUTPUT)
+
+
+@connector(output=_LIVE_OUTPUT, tags=["eodhd", "equity", "tool"], secrets=("api_key",))
+def eodhd_live(ticker: Annotated[str, Namespace("eodhd_symbols")], api_key: str = "") -> pd.DataFrame:
+    """[Free+] Fetch the live (real-time or 15-min delayed) quote for a ticker:
+    code, timestamp, OHLC, volume, previous close, and change. Use eodhd_search
+    to resolve a company name to its EODHD ticker (e.g. AAPL.US).
+    """
+    t = _safe_path_token(ticker, "ticker")
+    http = _client(api_key, timeout=_LATENCY_TIMEOUT)
+    data = eodhd_get(http, path=f"real-time/{t}", op_name="eodhd_live")
+    if not isinstance(data, dict) or not data.get("code"):
+        raise EmptyDataError(_PROVIDER, query_params={"ticker": t})
+    df = pd.DataFrame([data])
+    return _select_declared(df, _LIVE_OUTPUT)
+
+
+@connector(output=_INTRADAY_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_intraday(
+    ticker: Annotated[str, Namespace("eodhd_symbols")],
+    interval: Literal["1m", "5m", "1h"],
+    from_unix: int | None = None,
+    to_unix: int | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[EOD+Intraday+] Fetch intraday OHLCV data for a ticker at 1m, 5m, or 1h
+    intervals. Provide from_unix / to_unix (Unix timestamps in seconds) to bound
+    the range; otherwise the most recent points are returned. Requires a paid
+    EOD+Intraday plan — a free key returns PaymentRequiredError.
+    """
+    t = _safe_path_token(ticker, "ticker")
+    http = _client(api_key, timeout=_LATENCY_TIMEOUT)
+    data = eodhd_get(
+        http,
+        path=f"intraday/{t}",
+        params={"interval": interval, "from": from_unix, "to": to_unix},
+        op_name="eodhd_intraday",
+    )
+    df = _rows_to_frame(data, "eodhd_intraday", {"ticker": t})
+    return _select_declared(df, _INTRADAY_OUTPUT)
+
+
+@connector(output=_BULK_EOD_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_bulk_eod(exchange: str, date: str | None = None, api_key: str = "") -> pd.DataFrame:
+    """[EOD Historical+] Fetch end-of-day prices for every symbol on an exchange
+    in one request (returns code, name, date, OHLCV). Defaults to the last
+    trading day; pass date to fetch a specific day. Large response — use for
+    batch ingestion, not per-ticker lookups. Requires a paid plan; a free key
+    returns PaymentRequiredError.
+    """
+    ex = _safe_path_token(exchange, "exchange")
+    http = _client(api_key, timeout=_BULK_TIMEOUT)
+    data = eodhd_get(
+        http,
+        path=f"eod-bulk-last-day/{ex}",
+        params={"date": date},
+        op_name="eodhd_bulk_eod",
+    )
+    df = _rows_to_frame(data, "eodhd_bulk_eod", {"exchange": ex})
+    return _select_declared(df, _BULK_EOD_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# Corporate Actions — dividends / splits
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_DIVIDENDS_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_dividends(
+    ticker: Annotated[str, Namespace("eodhd_symbols")],
+    from_date: str | None = None,
+    to_date: str | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Free+] Fetch dividend history for a ticker: ex-date, declaration/record/
+    payment dates, period, value, unadjusted value, and currency. Use from_date/
+    to_date (ISO 8601) to limit the range.
+    """
+    t = _safe_path_token(ticker, "ticker")
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path=f"div/{t}",
+        params={"from": from_date, "to": to_date},
+        op_name="eodhd_dividends",
+    )
+    df = _rows_to_frame(data, "eodhd_dividends", {"ticker": t})
+    return _select_declared(df, _DIVIDENDS_OUTPUT)
+
+
+@connector(output=_SPLITS_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_splits(
+    ticker: Annotated[str, Namespace("eodhd_symbols")],
+    from_date: str | None = None,
+    to_date: str | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Free+] Fetch stock split history for a ticker. The split column carries the
+    ratio string as returned by the API (e.g. "2.000000/1.000000" for a 2-for-1
+    split). Use from_date/to_date (ISO 8601) to limit the range.
+    """
+    t = _safe_path_token(ticker, "ticker")
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path=f"splits/{t}",
+        params={"from": from_date, "to": to_date},
+        op_name="eodhd_splits",
+    )
+    df = _rows_to_frame(data, "eodhd_splits", {"ticker": t})
+    return _select_declared(df, _SPLITS_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# Fundamentals — raw nested dict (no output schema)
+# ---------------------------------------------------------------------------
+
+
+@connector(tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_fundamentals(ticker: Annotated[str, Namespace("eodhd_symbols")], api_key: str = "") -> dict[str, Any]:
+    """[Fundamentals+] Fetch full fundamentals for a stock or ETF as a large nested
+    dict (not a DataFrame). Typical equity top-level keys: General, Highlights,
+    Valuation, SharesStats, Technicals, SplitsDividends, AnalystRatings, Holders,
+    InsiderTransactions, Financials, Earnings. ETFs differ (General, Technicals,
+    ETF_Data). Navigate via result.data, e.g.
+    result.data['Highlights']['MarketCapitalization']. Requires a paid plan; a
+    free key returns PaymentRequiredError.
+    """
+    t = _safe_path_token(ticker, "ticker")
+    http = _client(api_key, timeout=_BULK_TIMEOUT)
+    data = eodhd_get(http, path=f"fundamentals/{t}", op_name="eodhd_fundamentals")
+    if not isinstance(data, dict) or not data:
+        raise EmptyDataError(_PROVIDER, query_params={"ticker": t})
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Calendars — earnings / ipos / trends / splits
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_CALENDAR_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_calendar(
+    type: Literal["earnings", "ipos", "trends", "splits"],
+    from_date: str | None = None,
+    to_date: str | None = None,
+    symbols: str | None = None,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Fundamentals+] Fetch market calendar data. Types: earnings (upcoming EPS
+    announcements with estimates/actuals), ipos (upcoming and recent IPO
+    listings), trends (analyst recommendation trends), splits (upcoming splits).
+    Use from_date/to_date to narrow the window and symbols to filter. Requires a
+    paid plan; a free key returns PaymentRequiredError.
+    """
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path=f"calendar/{type}",
+        params={"from": from_date, "to": to_date, "symbols": symbols},
+        op_name="eodhd_calendar",
+    )
+    # The calendar endpoints wrap rows under a type-specific key.
+    if isinstance(data, dict):
+        for key in ("earnings", "ipos", "trends", "splits", "data"):
+            rows = data.get(key)
+            if isinstance(rows, list):
+                data = rows
+                break
+    df = _rows_to_frame(data, "eodhd_calendar", {"type": type})
+    return _select_declared(df, _CALENDAR_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# News
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_NEWS_OUTPUT, tags=["eodhd", "tool"], secrets=("api_key",))
+def eodhd_news(
+    ticker: str | None = None,
+    from_date: str | None = None,
+    to_date: str | None = None,
+    limit: int = 50,
+    offset: int = 0,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Free+] Fetch financial news articles (date, title, content, link, related
+    symbols, tags). Filter by ticker (e.g. AAPL.US) or omit for broad market
+    news. Use from_date/to_date for date filtering and limit/offset to page.
+    Empty result may indicate no news in the range for the ticker.
+    """
+    if limit < 1 or limit > 1000:
+        raise InvalidParameterError(_PROVIDER, "limit must be between 1 and 1000")
+    if offset < 0:
+        raise InvalidParameterError(_PROVIDER, "offset must be non-negative")
+
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path="news",
+        params={
+            "s": ticker,  # EODHD uses ``s=`` for symbol filtering on the news endpoint
+            "from": from_date,
+            "to": to_date,
+            "limit": limit,
+            "offset": offset,
+        },
+        op_name="eodhd_news",
+    )
+    df = _rows_to_frame(data, "eodhd_news", {"ticker": ticker or ""})
+    return _select_declared(df, _NEWS_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# Macro indicators — single / bulk
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_MACRO_OUTPUT, tags=["eodhd", "macro"], secrets=("api_key",))
+def eodhd_macro(country: str, indicator: str, api_key: str = "") -> pd.DataFrame:
+    """[Fundamentals+] Fetch a macro indicator time series for a country (returns
+    Date, Value, Period). Country must be an ISO 3-letter code (e.g. USA, DEU).
+    Common indicators: gdp_current_usd, unemployment_total_percent,
+    inflation_consumer_prices_annual, real_interest_rate, population_total.
+    Requires a paid plan; a free key returns PaymentRequiredError.
+    """
+    c = _safe_path_token(country, "country")
+    ind = indicator.strip()
+    if not ind:
+        raise InvalidParameterError(_PROVIDER, "indicator must be non-empty")
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path=f"macro-indicator/{c}",
+        params={"indicator": ind},
+        op_name="eodhd_macro",
+    )
+    df = _rows_to_frame(data, "eodhd_macro", {"country": c, "indicator": ind})
+    return _select_declared(df, _MACRO_OUTPUT)
+
+
+@connector(output=_MACRO_OUTPUT, tags=["eodhd", "macro"], secrets=("api_key",))
+def eodhd_macro_bulk(country: str, indicator: str | None = None, api_key: str = "") -> pd.DataFrame:
+    """[Fundamentals+] Fetch macro indicator data for a country. The EODHD
+    macro-indicator endpoint requires an indicator; pass one explicitly or rely
+    on the default. Returns Date, Value, Period. Country must be an ISO 3-letter
+    code (e.g. USA). Requires a paid plan; a free key returns
+    PaymentRequiredError.
+    """
+    c = _safe_path_token(country, "country")
+    http = _client(api_key, timeout=_BULK_TIMEOUT)
+    data = eodhd_get(
+        http,
+        path=f"macro-indicator/{c}",
+        params={"indicator": indicator},
+        op_name="eodhd_macro_bulk",
+    )
+    df = _rows_to_frame(data, "eodhd_macro_bulk", {"country": c})
+    return _select_declared(df, _MACRO_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# Technical indicators
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_TECHNICAL_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_technical(
+    ticker: Annotated[str, Namespace("eodhd_symbols")],
+    function: _TechnicalFunction,
+    period: int = 50,
+    from_date: str | None = None,
+    to_date: str | None = None,
+    order: Literal["a", "d"] = "d",
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[EOD+Intraday+] Fetch technical indicator values for a ticker. The output
+    columns vary by function: sma/ema/wma → the indicator column; macd → macd,
+    macd_signal, macd_hist; bbands → uband, mband, lband; stochastic → k/d;
+    adx/dmi → adx, plusDI, minusDI. Use period for the lookback window (default
+    50). Requires a paid plan; a free key returns PaymentRequiredError.
+    """
+    t = _safe_path_token(ticker, "ticker")
+    if period < 1:
+        raise InvalidParameterError(_PROVIDER, "period must be a positive integer")
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path=f"technical/{t}",
+        params={
+            "function": function,
+            "period": period,
+            "order": order,
+            "from": from_date,
+            "to": to_date,
+        },
+        op_name="eodhd_technical",
+    )
+    df = _rows_to_frame(data, "eodhd_technical", {"ticker": t, "function": function})
+    return _select_declared(df, _TECHNICAL_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# Insider transactions
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_INSIDER_OUTPUT, tags=["eodhd", "equity"], secrets=("api_key",))
+def eodhd_insider(
+    ticker: Annotated[str, Namespace("eodhd_symbols")] | None = None,
+    limit: int = 100,
+    offset: int = 0,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[Fundamentals+] Fetch insider (executive and director) transactions. Filter
+    by ticker (e.g. AAPL.US) or omit for recent cross-market transactions. Use
+    limit/offset to page. Requires a paid plan; a free key returns
+    PaymentRequiredError.
+    """
+    if limit < 1 or limit > 1000:
+        raise InvalidParameterError(_PROVIDER, "limit must be between 1 and 1000")
+    if offset < 0:
+        raise InvalidParameterError(_PROVIDER, "offset must be non-negative")
+    code = ticker.strip() if ticker else None
+    http = _client(api_key)
+    data = eodhd_get(
+        http,
+        path="insider-transactions",
+        params={"code": code, "limit": limit, "offset": offset},
+        op_name="eodhd_insider",
+    )
+    df = _rows_to_frame(data, "eodhd_insider", {"ticker": code or ""})
+    return _select_declared(df, _INSIDER_OUTPUT)
+
+
+# ---------------------------------------------------------------------------
+# Screener
+# ---------------------------------------------------------------------------
+
+
+@connector(output=_SCREENER_OUTPUT, tags=["eodhd", "equity", "tool"], secrets=("api_key",))
+def eodhd_screener(
+    filters: list[tuple[str, str, str]] | None = None,
+    signals: str | None = None,
+    sort: str | None = None,
+    order: Literal["asc", "desc"] = "desc",
+    limit: int = 50,
+    offset: int = 0,
+    api_key: str = "",
+) -> pd.DataFrame:
+    """[EOD+Intraday+] Screen stocks by fundamental, price, and exchange criteria.
+    filters is a list of [field, operator, value] triples, e.g.
+    [["market_capitalization", ">", "1000000000"], ["exchange", "=", "us"]].
+    Operators: >, <, =, >=, <=. Common fields: market_capitalization,
+    earnings_share, dividend_yield, refund_1d_p, sector, exchange. Requires a
+    paid plan; a free key returns PaymentRequiredError.
+    """
+    if limit < 1 or limit > 100:
+        raise InvalidParameterError(_PROVIDER, "limit must be between 1 and 100")
+    if offset < 0:
+        raise InvalidParameterError(_PROVIDER, "offset must be non-negative")
+
+    params: dict[str, Any] = {"limit": limit, "offset": offset, "sort": sort, "signals": signals}
+    if filters:
+        params["filters"] = json.dumps([[f[0], f[1], f[2]] for f in filters])
+    if sort and order:
+        # EODHD sort syntax is ``field.direction`` (e.g. market_capitalization.desc).
+        params["sort"] = f"{sort}.{order}"
+
+    http = _client(api_key)
+    data = eodhd_get(http, path="screener", params=params, op_name="eodhd_screener")
+    # The screener wraps rows under a top-level ``data`` key.
+    if isinstance(data, dict):
+        rows = data.get("data")
+        if isinstance(rows, list):
+            data = rows
+    df = _rows_to_frame(data, "eodhd_screener", {"limit": limit})
+    return df
+
+
+# ---------------------------------------------------------------------------
+# Connector collection
+# ---------------------------------------------------------------------------
+
+CONNECTORS = Connectors(
+    [
+        # Reference / discovery
+        eodhd_search,
+        eodhd_exchanges,
+        eodhd_exchange_symbols,
+        # Market data
+        eodhd_eod,
+        eodhd_live,
+        eodhd_intraday,
+        eodhd_bulk_eod,
+        # Corporate actions
+        eodhd_dividends,
+        eodhd_splits,
+        # Fundamentals
+        eodhd_fundamentals,
+        # Calendars
+        eodhd_calendar,
+        # News
+        eodhd_news,
+        # Macro
+        eodhd_macro,
+        eodhd_macro_bulk,
+        # Technical
+        eodhd_technical,
+        # Transactions
+        eodhd_insider,
+        # Screener
+        eodhd_screener,
+    ]
+)
+
+
+def load(*, api_key: str) -> Connectors:
+    """Return :data:`CONNECTORS` with ``api_key`` bound on every connector that accepts it."""
+    return CONNECTORS.bind(api_key=api_key)

parsimony_eodhd/_http.py

@@ -0,0 +1,112 @@
+"""EODHD transport — keyed client builder and unified error mapping.
+
+Every EODHD connector resolves its client through :func:`_client` (the
+canonical §4.3 keyed template: arg → env fallback → fast-fail) and routes its
+GET through :func:`eodhd_get` (the package error-mapping chokepoint).
+
+EODHD's status semantics differ from the canonical transport table on two
+points, which is why this package drops to a raw ``HttpClient`` plus a
+hand-written mapper instead of :func:`parsimony.transport.helpers.fetch_json`
+(verified live 2026-06-04):
+
+* an **invalid / missing** key returns **401** (body ``Unauthenticated``), and
+* a **plan restriction** (an endpoint or range not in the caller's plan, e.g.
+  fundamentals / intraday / macro on a free key) returns **403** (body
+  ``Only EOD data allowed for free users``), and
+* a **bulk** plan restriction returns **423 Locked** (body
+  ``Bulk requests are prohibited for free users``).
+
+The canonical mapper folds 403 into :class:`UnauthorizedError`; for EODHD a 403
+(and a 423) means "your plan does not grant this," so both map to
+:class:`PaymentRequiredError`. Because invalid-key is unambiguously 401, this is
+a status-only disambiguation (the finnhub case), not a body-sniffing one (the
+tiingo dual-403 case). The 401 path still maps to :class:`UnauthorizedError`.
+Every other status flows through the canonical :func:`map_http_error` /
+:func:`map_timeout_error`.
+
+Auth rides as the ``api_token`` query parameter (alongside EODHD's ``fmt=json``
+convention). ``api_token`` is in the transport layer's sensitive-param set, so
+it is redacted from every log line and never appears in a request URL surfaced
+to the agent. Error bodies are ``text/html`` even on failures, so this module
+never parses an error body — it branches on the HTTP status alone.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from parsimony.errors import PaymentRequiredError
+from parsimony.transport import HttpClient, map_http_error, map_timeout_error
+from parsimony.transport.helpers import make_http_client, require_key
+
+_PROVIDER = "eodhd"
+_BASE_URL = "https://eodhd.com/api"
+_ENV_VAR = "EODHD_API_KEY"
+
+# EODHD's REST endpoints are not streaming; 15s is a conservative ceiling.
+# Bulk endpoints (bulk_eod, exchange_symbols, macro_bulk, fundamentals) override
+# this with a longer value via ``timeout=``.
+_DEFAULT_TIMEOUT_SECONDS = 15.0
+
+# HTTP statuses EODHD uses for a plan-tier restriction (not a credential
+# failure): 403 ("Only EOD data allowed for free users") and 423 Locked
+# ("Bulk requests are prohibited for free users"). Both map to
+# PaymentRequiredError. Invalid-key is 401, so this is unambiguous on status.
+_PLAN_RESTRICTION_STATUSES: frozenset[int] = frozenset({403, 423})
+
+
+def _client(api_key: str, *, timeout: float = _DEFAULT_TIMEOUT_SECONDS) -> HttpClient:
+    """Resolve the API key (arg → env fallback) and build the EODHD client.
+
+    Fast-fails with :class:`UnauthorizedError` before any network call when no
+    key is available. Auth is the ``api_token`` query parameter (redacted by the
+    transport layer), carried alongside EODHD's ``fmt=json`` convention as a
+    fixed default param — hence ``make_http_client`` with explicit
+    ``query_params`` rather than ``make_api_key_client`` (which can set only the
+    key and hardcodes ``apikey``).
+    """
+    key = require_key(api_key, env_var=_ENV_VAR, provider=_PROVIDER)
+    return make_http_client(
+        _BASE_URL,
+        query_params={"api_token": key, "fmt": "json"},
+        timeout=timeout,
+    )
+
+
+def eodhd_get(
+    http: HttpClient,
+    *,
+    path: str,
+    params: dict[str, Any] | None = None,
+    op_name: str,
+) -> Any:
+    """Shared EODHD GET with EODHD-specific error mapping; returns parsed JSON.
+
+    Drops ``None``-valued params, raises for status, then maps:
+
+    * 403 / 423 → :class:`PaymentRequiredError` (plan restriction — EODHD-specific),
+    * everything else → :func:`map_http_error` (401 → Unauthorized, 402 →
+      Payment, 429 → RateLimit, other → Provider),
+    * timeout → :func:`map_timeout_error` (→ ``ProviderError(408)``).
+
+    Error bodies are ``text/html`` and are never parsed (the EODHD API token is
+    a query param, redacted, and never reaches an exception message).
+    """
+    filtered = {k: v for k, v in (params or {}).items() if v is not None}
+    try:
+        response = http.request("GET", f"/{path.lstrip('/')}", params=filtered or None)
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        if exc.response.status_code in _PLAN_RESTRICTION_STATUSES:
+            raise PaymentRequiredError(
+                _PROVIDER,
+                message=f"eodhd plan does not grant access to '{op_name}'",
+            ) from exc
+        map_http_error(exc, provider=_PROVIDER, op_name=op_name)
+    except httpx.TimeoutException as exc:
+        map_timeout_error(exc, provider=_PROVIDER, op_name=op_name)
+    return response.json()
+
+
+__all__ = ["_client", "eodhd_get"]

parsimony_eodhd/outputs.py

@@ -0,0 +1,200 @@
+"""Declarative output schemas for the EODHD connectors.
+
+One :class:`OutputConfig` per connector that projects a shaped DataFrame
+out of EODHD's raw JSON. Columns declared here are the contract with the
+MCP tool catalog — renaming or re-ordering them is a breaking change.
+"""
+
+from __future__ import annotations
+
+from parsimony.result import Column, ColumnRole, OutputConfig
+
+EOD_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="date", role=ColumnRole.KEY, dtype="date"),
+        Column(name="open", dtype="numeric"),
+        Column(name="high", dtype="numeric"),
+        Column(name="low", dtype="numeric"),
+        Column(name="close", dtype="numeric"),
+        Column(name="adjusted_close", dtype="numeric"),
+        Column(name="volume", dtype="numeric"),
+    ]
+)
+
+LIVE_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY),
+        # EODHD returns ``timestamp`` as a raw Unix epoch int; keep it un-coerced
+        # (dtype="auto") — a "timestamp" coercion would mis-read the seconds value.
+        Column(name="timestamp", role=ColumnRole.METADATA),
+        Column(name="gmtoffset", role=ColumnRole.METADATA),
+        Column(name="open", dtype="numeric"),
+        Column(name="high", dtype="numeric"),
+        Column(name="low", dtype="numeric"),
+        Column(name="close", dtype="numeric"),
+        Column(name="volume", dtype="numeric"),
+        Column(name="previousClose", dtype="numeric"),
+        Column(name="change", dtype="numeric"),
+        Column(name="change_p", dtype="numeric"),
+    ]
+)
+
+INTRADAY_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="timestamp", role=ColumnRole.KEY, dtype="timestamp"),
+        Column(name="datetime", role=ColumnRole.METADATA),
+        Column(name="open", dtype="numeric"),
+        Column(name="high", dtype="numeric"),
+        Column(name="low", dtype="numeric"),
+        Column(name="close", dtype="numeric"),
+        Column(name="volume", dtype="numeric"),
+    ]
+)
+
+BULK_EOD_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY),
+        Column(name="name", role=ColumnRole.TITLE),
+        Column(name="exchange_short_name", role=ColumnRole.METADATA),
+        Column(name="date", dtype="date"),
+        Column(name="open", dtype="numeric"),
+        Column(name="high", dtype="numeric"),
+        Column(name="low", dtype="numeric"),
+        Column(name="close", dtype="numeric"),
+        Column(name="adjusted_close", dtype="numeric"),
+        Column(name="volume", dtype="numeric"),
+    ]
+)
+
+DIVIDENDS_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="date", role=ColumnRole.KEY, dtype="date"),
+        Column(name="declarationDate", dtype="date"),
+        Column(name="recordDate", dtype="date"),
+        Column(name="paymentDate", dtype="date"),
+        Column(name="period", role=ColumnRole.METADATA),
+        Column(name="value", dtype="numeric"),
+        Column(name="unadjustedValue", dtype="numeric"),
+        Column(name="currency", role=ColumnRole.METADATA),
+    ]
+)
+
+SPLITS_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="date", role=ColumnRole.KEY, dtype="date"),
+        Column(name="split", dtype="auto"),
+    ]
+)
+
+SEARCH_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="Code", role=ColumnRole.KEY, namespace="eodhd_symbols"),
+        Column(name="Name", role=ColumnRole.TITLE),
+        Column(name="Exchange", role=ColumnRole.METADATA),
+        Column(name="Type", role=ColumnRole.METADATA),
+        Column(name="Country", role=ColumnRole.METADATA),
+        Column(name="Currency", role=ColumnRole.METADATA),
+        Column(name="ISIN", role=ColumnRole.METADATA),
+    ]
+)
+
+EXCHANGES_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="Code", role=ColumnRole.KEY),
+        Column(name="Name", role=ColumnRole.TITLE),
+        Column(name="OperatingMIC", role=ColumnRole.METADATA),
+        Column(name="Country", role=ColumnRole.METADATA),
+        Column(name="Currency", role=ColumnRole.METADATA),
+        Column(name="CountryISO2", role=ColumnRole.METADATA),
+        Column(name="CountryISO3", role=ColumnRole.METADATA),
+    ]
+)
+
+EXCHANGE_SYMBOLS_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="Code", role=ColumnRole.KEY, namespace="eodhd_symbols"),
+        Column(name="Name", role=ColumnRole.TITLE),
+        Column(name="Country", role=ColumnRole.METADATA),
+        Column(name="Exchange", role=ColumnRole.METADATA),
+        Column(name="Currency", role=ColumnRole.METADATA),
+        Column(name="Type", role=ColumnRole.METADATA),
+        # Live payload key is ``Isin`` (not ``ISIN`` as on the search endpoint).
+        Column(name="Isin", role=ColumnRole.METADATA),
+    ]
+)
+
+CALENDAR_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY),
+        Column(name="date", dtype="date"),
+        Column(name="report_date", dtype="date"),
+        Column(name="before_after_market", role=ColumnRole.METADATA),
+        Column(name="currency", role=ColumnRole.METADATA),
+        Column(name="actual", dtype="numeric"),
+        Column(name="estimate", dtype="numeric"),
+        Column(name="difference", dtype="numeric"),
+        Column(name="percent", dtype="numeric"),
+    ]
+)
+
+NEWS_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="date", role=ColumnRole.KEY, dtype="datetime"),
+        Column(name="title", role=ColumnRole.TITLE),
+        Column(name="content"),
+        Column(name="link", role=ColumnRole.METADATA),
+        Column(name="symbols", role=ColumnRole.METADATA),
+        Column(name="tags", role=ColumnRole.METADATA),
+    ]
+)
+
+MACRO_OUTPUT = OutputConfig(
+    columns=[
+        # EODHD macro-indicator rows: CountryCode, CountryName, Indicator, Date,
+        # Period, Value. (No LastUpdated — do not declare a column the payload
+        # cannot populate.) CountryName/Indicator/CountryCode fold in as DATA.
+        Column(name="Date", role=ColumnRole.KEY, dtype="date"),
+        Column(name="Value", dtype="numeric"),
+        Column(name="Period", role=ColumnRole.METADATA),
+    ]
+)
+
+TECHNICAL_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="date", role=ColumnRole.KEY, dtype="date"),
+        Column(name="open", dtype="numeric"),
+        Column(name="high", dtype="numeric"),
+        Column(name="low", dtype="numeric"),
+        Column(name="close", dtype="numeric"),
+        Column(name="volume", dtype="numeric"),
+        Column(name="*"),  # indicator-specific columns vary by function
+    ]
+)
+
+INSIDER_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY),
+        Column(name="date", dtype="date"),
+        Column(name="ownerName", role=ColumnRole.METADATA),
+        Column(name="ownerCik", role=ColumnRole.METADATA),
+        Column(name="transactionType", role=ColumnRole.METADATA),
+        Column(name="transactionDate", dtype="date"),
+        Column(name="value", dtype="numeric"),
+        Column(name="sharesOwned", dtype="numeric"),
+        Column(name="change", dtype="numeric"),
+        Column(name="*"),
+    ]
+)
+
+SCREENER_OUTPUT = OutputConfig(
+    columns=[
+        Column(name="code", role=ColumnRole.KEY, namespace="eodhd_symbols"),
+        Column(name="name", role=ColumnRole.TITLE),
+        Column(name="exchange", role=ColumnRole.METADATA),
+        Column(name="currency", role=ColumnRole.METADATA),
+        Column(name="sector", role=ColumnRole.METADATA),
+        Column(name="industry", role=ColumnRole.METADATA),
+        Column(name="market_capitalization", dtype="numeric"),
+        Column(name="*"),
+    ]
+)

parsimony_eodhd-0.0.1.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: parsimony-eodhd
+Version: 0.0.1
+Summary: EODHD connector for the parsimony framework
+Project-URL: Homepage, https://eodhd.com
+Project-URL: Repository, https://github.com/ockham-sh/parsimony-connectors
+Project-URL: Issues, https://github.com/ockham-sh/parsimony-connectors/issues
+Author-email: "Ockham.sh" <team@ockham.sh>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: connectors,data,eodhd,finance,parsimony
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pandas<3,>=2.3.0
+Requires-Dist: parsimony-core>=0.0.1
+Requires-Dist: pydantic<3,>=2.11.1
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=9.0.3; extra == 'dev'
+Requires-Dist: respx>=0.22.0; extra == 'dev'
+Requires-Dist: ruff>=0.15.10; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# parsimony-eodhd
+
+EODHD connector — end-of-day, intraday, fundamentals, news, calendars, macro and technical indicators from the EODHD REST API.
+
+Part of the [parsimony-connectors](https://github.com/ockham-sh/parsimony-connectors) monorepo. Distributed standalone on PyPI as `parsimony-eodhd`.
+
+## Connectors
+
+17 connectors grouped by capability:
+
+| Name | Kind | Description |
+|---|---|---|
+| `eodhd_search` | fetch | Resolve company names / partial tickers to EODHD ticker codes (`AAPL.US`). |
+| `eodhd_exchanges` | fetch | List supported exchanges. |
+| `eodhd_exchange_symbols` | fetch | List all symbols on an exchange. |
+| `eodhd_eod` | fetch | End-of-day OHLCV for a ticker (daily/weekly/monthly). |
+| `eodhd_live` | fetch | Live (real-time or 15-min delayed) quote. |
+| `eodhd_intraday` | fetch | Intraday OHLCV at 1m / 5m / 1h. |
+| `eodhd_bulk_eod` | fetch | EOD prices for every symbol on an exchange in one request. |
+| `eodhd_dividends` | fetch | Dividend history for a ticker. |
+| `eodhd_splits` | fetch | Stock split history for a ticker. |
+| `eodhd_fundamentals` | fetch | Full fundamentals for a stock or ETF (raw nested dict). |
+| `eodhd_calendar` | fetch | Earnings / IPO / analyst trends / splits calendars. |
+| `eodhd_news` | fetch | Financial news, optionally filtered by ticker. |
+| `eodhd_macro` | fetch | Single macro indicator time series for a country. |
+| `eodhd_macro_bulk` | fetch | All available macro indicators for a country. |
+| `eodhd_technical` | fetch | Technical indicators (SMA, EMA, MACD, BBANDS, ADX, etc.). |
+| `eodhd_insider` | fetch | Insider (executive / director) transactions. |
+| `eodhd_screener` | fetch | Screen stocks by structured filter triples. |
+
+Several endpoints require paid EODHD plans (EOD+Intraday, Fundamentals); per-connector docstrings tag the minimum plan as `[Free+]`, `[EOD+Intraday+]`, or `[Fundamentals+]`. On a free key a plan-gated endpoint returns HTTP 403 (or 423 for bulk), surfaced as `PaymentRequiredError` — not an auth error.
+
+## Install
+
+```bash
+pip install parsimony-eodhd
+```
+
+Pulls in `parsimony-core>=0.7,<0.8` automatically. Verify discovery:
+
+```bash
+python -c "from parsimony import discover; print([p.name for p in discover.iter_providers()])"
+```
+
+## Configuration
+
+Set the following environment variable:
+
+```bash
+export EODHD_API_KEY="<your-key>"
+```
+
+Get a key at https://eodhd.com/register.
+
+## Quick start
+
+```python
+import os
+from parsimony_eodhd import load
+
+# load() binds the API key off the call surface (and out of provenance).
+connectors = load(api_key=os.environ["EODHD_API_KEY"])
+result = connectors["eodhd_eod"](ticker="AAPL.US")
+print(result.data.head())
+```
+
+For multi-plugin composition:
+
+```python
+from parsimony import discover
+connectors = discover.load_all()
+```
+
+## Provider
+
+- Homepage: https://eodhd.com
+- API docs: https://eodhd.com/financial-apis/
+
+## License
+
+See [LICENSE](./LICENSE).

parsimony_eodhd-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+parsimony_eodhd/__init__.py,sha256=VBy1BqF_gRiR_bJnM-9Ac90ve0vCAXCJeVKvBWt6PJU,26000
+parsimony_eodhd/_http.py,sha256=cp0_Rqussav7SAVPujMO28WJbUaunBcir7A0th0NaRs,5010
+parsimony_eodhd/outputs.py,sha256=pBC5rXbGdQujWSGKRHyv5Vc0KLurPNbOYQ6vl88pNjM,7526
+parsimony_eodhd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parsimony_eodhd-0.0.1.dist-info/METADATA,sha256=_SIciiZ78MGlKEQFuW3Uv75mXMeUgdvM7Rr7LsrCYiY,4339
+parsimony_eodhd-0.0.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+parsimony_eodhd-0.0.1.dist-info/entry_points.txt,sha256=FKkSMd44tFkRnvcAbuEnWR0V0pC1PM81CQtuIeKaBtU,46
+parsimony_eodhd-0.0.1.dist-info/licenses/LICENSE,sha256=PtHUFTCSwal_QX2Ijk2cx_bpsPV6ooZUMCYAxKBHNu0,10760
+parsimony_eodhd-0.0.1.dist-info/RECORD,,

parsimony_eodhd-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

parsimony_eodhd-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[parsimony.providers]
+eodhd = parsimony_eodhd

parsimony_eodhd-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Ockham.sh
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.