py-ftmarkets 0.1.0__py3-none-any.whl

ftmarkets/__init__.py

@@ -0,0 +1,8 @@
+from pydantic_market_data.models import OHLCV, History, Symbol
+
+from .api import FTDataSource as FTDataSource
+from .api import history as history
+from .api import resolve_ticker as resolve_ticker
+from .api import search as search
+
+__all__ = ["OHLCV", "History", "Symbol", "FTDataSource", "history", "resolve_ticker", "search"]

ftmarkets/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

ftmarkets/api.py

@@ -0,0 +1,510 @@
+import html as html_lib
+import json
+import re
+from datetime import date, datetime
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+import pandas as pd
+from lxml import html
+from pydantic_market_data.interfaces import DataSource
+from pydantic_market_data.models import OHLCV, History, SecurityCriteria, Symbol
+
+from .client import client
+
+
+def search(query: str) -> list[Symbol]:
+    """
+    Search for a security by ISIN, symbol, or name.
+    """
+    url = "/data/search"
+    response = client.get(url, params={"query": query})
+    response.raise_for_status()
+
+    tree = html.fromstring(response.content)
+
+    # Mapping for FT tab IDs/names to standard types
+    asset_class_map = {
+        "etf-panel": "ETF",
+        "equity-panel": "Equity",
+        "fund-panel": "Fund",
+        "index-panel": "Index",
+        "ETFs": "ETF",
+        "Equities": "Equity",
+        "Funds": "Fund",
+        "Indices": "Index",
+        "Indicies": "Index",
+    }
+
+    results = []
+
+    # The search results are grouped by asset class in tab panels or sections
+    xpath_query = '//div[@role="tabpanel"] | //div[contains(@class, "mod-search-results__section")]'
+    panels = tree.xpath(xpath_query)
+    if not panels:
+        # Fallback for direct redirect or simple structure
+        if "tearsheet" in response.url:
+            # ... existing redirect logic ...
+            parsed = urlparse(response.url)
+            qs = parse_qs(parsed.query)
+            symbol_code = qs.get("s", [None])[0]
+            if symbol_code:
+                name_el = tree.xpath('//h1[@class="mod-tearsheet-overview__header__name"]')
+                name = name_el[0].text.strip() if name_el else query
+                return [Symbol(ticker=symbol_code, name=name)]
+        panels = [tree]
+
+    for panel in panels:
+        # Identify asset class from ID or header
+        panel_id = panel.get("id")
+        asset_type = asset_class_map.get(panel_id)
+
+        if not asset_type:
+            header = panel.xpath(".//h3")
+            ft_name = header[0].text.strip() if header else None
+            asset_type = asset_class_map.get(ft_name, ft_name)
+
+        rows = panel.xpath('.//table[contains(@class, "mod-ui-table")]/tbody/tr')
+        for row in rows:
+            cols = row.xpath("./td")
+            if len(cols) >= 2:
+                name = cols[0].text_content().strip()
+                ticker = cols[1].text_content().strip()
+                exchange = cols[2].text_content().strip() if len(cols) > 2 else None
+                country = cols[3].text_content().strip() if len(cols) > 3 else None
+
+                if ticker:
+                    country_code = _map_country_to_code(country)
+
+                    # Currency extraction from ticker: "4GLD:GER:EUR" -> "EUR"
+                    # Note: FT tickers are variable format, often SYMBOL:EXCHANGE:CURRENCY
+                    currency = None
+                    ticker_parts = ticker.split(":")
+                    if len(ticker_parts) >= 3:
+                        # If there are 3 parts, the last one is likely the currency
+                        last_part = ticker_parts[-1].upper()
+                        if len(last_part) == 3 and last_part.isalpha():
+                            currency = last_part
+
+                    try:
+                        sym = Symbol(
+                            ticker=ticker,
+                            name=name,
+                            exchange=exchange,
+                            country=country_code,
+                            currency=currency,
+                            asset_class=asset_type,
+                        )
+                    except Exception:
+                        # If validation fails, try a more lenient approach
+                        sym = Symbol(
+                            ticker=ticker,
+                            name=name,
+                            exchange=exchange,
+                            country=country_code,
+                            currency=None,
+                            asset_class=asset_type,
+                        )
+
+                    results.append(sym)
+
+    return results
+
+
+def _map_country_to_code(country_name: str | None) -> str | None:
+    if not country_name:
+        return None
+
+    # Common mappings
+    mapping = {
+        "United Kingdom": "GB",
+        "United States": "US",
+        "France": "FR",
+        "Germany": "DE",
+        "Canada": "CA",
+        "Italy": "IT",
+        "Spain": "ES",
+        "Netherlands": "NL",
+        "Australia": "AU",
+        "Japan": "JP",
+        "Switzerland": "CH",
+        "Sweden": "SE",
+        "Belgium": "BE",
+        "Ireland": "IE",
+        "Denmark": "DK",
+        "Finland": "FI",
+        "Norway": "NO",
+        "Portugal": "PT",
+        "Hong Kong": "HK",
+        "Singapore": "SG",
+        "China": "CN",
+        "India": "IN",
+    }
+
+    # Return None if not mapped to avoid validation error for unknown names
+    return mapping.get(country_name, None)
+
+
+def resolve_ticker(
+    isin: str | None = None,
+    symbol: str | None = None,
+    description: str | None = None,
+    preferred_exchanges: list[str] | None = None,
+    target_price: float | None = None,
+    target_date: str | None = None,
+    currency: str | None = None,
+    country: str | None = None,
+    asset_class: str | None = None,
+    limit: int = 1,
+) -> list[Symbol]:
+    """
+    Enhanced resolve_ticker that returns a list of matching Symbols.
+    """
+    candidates = []
+
+    # 1. Search Strategy
+    if isin:
+        candidates = search(isin)
+    if not candidates and symbol:
+        candidates = search(symbol)
+    if not candidates and description:
+        candidates = search(description)
+
+    if not candidates:
+        return []
+
+    # 2. Filtering
+    filtered = []
+    for cand in candidates:
+        # Currency Filter
+        if currency:
+            if not cand.currency or str(cand.currency).upper() != currency.upper():
+                continue
+
+        # Country Filter
+        if country:
+            if not cand.country or str(cand.country).upper() != country.upper():
+                continue
+
+        # Asset Class Filter
+        if asset_class:
+            cand_asset = getattr(cand, "asset_class", None)
+            if not cand_asset or cand_asset.upper() != asset_class.upper():
+                continue
+
+        filtered.append(cand)
+
+    if not filtered:
+        return []
+
+    # 3. Sorting (Preferences) - Moved before validation for early exit optimization
+    def match_score(cand):
+        score = 0
+        # Factor A: Exchange Priority
+        if preferred_exchanges:
+            prefs_lower = [p.lower() for p in preferred_exchanges]
+            cand_exc = (cand.exchange or "").lower()
+            cand_sym = cand.ticker.lower()
+            found_exc = False
+            for i, p in enumerate(prefs_lower):
+                if p in cand_exc or p in cand_sym:
+                    score += i
+                    found_exc = True
+                    break
+            if not found_exc:
+                score += len(prefs_lower)
+
+        # Factor B: Currency Match (Highest priority after exchange if not already filtered)
+        if currency:
+            if cand.ticker.upper().endswith(f":{currency.upper()}"):
+                score -= 100
+
+        return score
+
+    filtered.sort(key=match_score)
+
+    # 4. Validation (Price)
+    # If price and date are provided, we only keep candidates that traded near that price.
+    if target_price and target_date:
+        validated = []
+
+        # Determine necessary history period
+        val_period = "3mo"
+        try:
+            target_dt = None
+            for fmt in ("%Y-%m-%d", "%Y%m%d"):
+                try:
+                    target_dt = datetime.strptime(target_date, fmt)
+                    break
+                except ValueError:
+                    pass
+            if target_dt:
+                days_diff = (datetime.now() - target_dt).days
+                if days_diff > 365 * 5:
+                    val_period = "10y"
+                elif days_diff > 365 * 2:
+                    val_period = "5y"
+                elif days_diff > 365:
+                    val_period = "3y"
+                elif days_diff > 180:
+                    val_period = "1y"
+                elif days_diff > 90:
+                    val_period = "6mo"
+        except Exception:
+            pass
+
+        for cand in filtered:
+            try:
+                hist = history(cand.ticker, period=val_period)
+                dt = target_dt
+                if not dt:
+                    for fmt in ("%Y-%m-%d", "%Y%m%d"):
+                        try:
+                            dt = datetime.strptime(target_date, fmt)
+                            break
+                        except ValueError:
+                            pass
+
+                if not dt:
+                    continue
+
+                match = _check_price_match_logic(hist, dt, target_price)
+                if match:
+                    validated.append(cand)
+                    # Early Exit: If we reached the limit, we can stop
+                    if limit > 0 and len(validated) >= limit:
+                        break
+            except Exception:
+                continue
+        filtered = validated
+
+    if not filtered:
+        return []
+
+    # 5. Limit
+    if limit > 0:
+        return filtered[:limit]
+
+    return filtered
+
+
+def history(ticker: str, period: str = "1mo") -> History:
+    """
+    Fetch historical data for a ticker.
+    Period options: '1d', '1mo', '3mo', '6mo', '1y', '3y', '5y', '10y', 'max'
+    """
+    # 1. Get Summary to find Internal ID (xid)
+    # Note: Optimization - we could cache this mapping
+    url_summary = f"/data/equities/tearsheet/summary?s={ticker}"
+    resp = client.get(url_summary)
+    resp.raise_for_status()
+
+    tree = html.fromstring(resp.content)
+
+    # Extract xid
+    xid = None
+    # Method A: data-mod-config
+    divs = tree.xpath("//div[@data-mod-config]")
+    for div in divs:
+        try:
+            raw_cfg = div.get("data-mod-config")
+            if raw_cfg:
+                decoded_cfg = html_lib.unescape(raw_cfg)
+                cfg = json.loads(decoded_cfg)
+                if "xid" in cfg:
+                    xid = cfg["xid"]
+                    break
+        except (ValueError, KeyError, json.JSONDecodeError):
+            pass
+
+    if not xid:
+        # Method B: Regex (Handle potentially escaped quotes)
+        # Matches: xid:"123" or xid="123" or "xid":"123"
+        # Also handle "
+        # Look for xid followed by colon/equals, optional quotes, and digits
+        regex = r'(?:xid|"xid")\s*[:=]\s*(?:["\']|")?(\d+)(?:["\']|")?'
+        match = re.search(regex, resp.text)
+        if match:
+            xid = match.group(1)
+
+    if not xid:
+        raise ValueError(f"Could not determine internal FT ID for ticker {ticker}")
+
+    # 2. Fetch Series Data
+    # Map period to days
+    days_map = {
+        "1d": 2,  # safety
+        "1mo": 35,
+        "3mo": 100,
+        "6mo": 200,
+        "1y": 365,
+        "3y": 365 * 3,
+        "5y": 365 * 5,
+        "10y": 365 * 10,
+        "max": 365 * 30,
+    }
+    days = days_map.get(period, 365)
+
+    payload = {
+        "days": days,
+        "dataNormalized": False,
+        "dataPeriod": "Day",
+        "dataInterval": 1,
+        "realtime": False,
+        "yFormat": "0.###",
+        "timeServiceFormat": "JSON",
+        "returnDateType": "ISO8601",
+        "elements": [{"Type": "price", "Symbol": xid}, {"Type": "volume", "Symbol": xid}],
+    }
+
+    resp_series = client.post("/data/chartapi/series", json=payload)
+    resp_series.raise_for_status()
+
+    data = resp_series.json()
+
+    # 3. Parse Response
+    candles = []
+    dates = data.get("Dates", [])
+    elements = data.get("Elements", [])
+
+    if not dates or not elements:
+        return History(symbol=Symbol(ticker=ticker, name=ticker), candles=[])
+
+    # Find Price and Volume components
+    price_comp = next((e for e in elements if e.get("Type") == "price"), None)
+    vol_comp = next((e for e in elements if e.get("Type") == "volume"), None)
+
+    if not price_comp:
+        return History(symbol=Symbol(ticker=ticker, name=ticker), candles=[])
+
+    ohlc = price_comp.get("ComponentSeries", [])
+    volumes = vol_comp.get("ComponentSeries", []) if vol_comp else []
+
+    # Let's extract vectors first
+    highs = next((s["Values"] for s in ohlc if s["Type"] == "High"), [])
+    lows = next((s["Values"] for s in ohlc if s["Type"] == "Low"), [])
+    opens = next((s["Values"] for s in ohlc if s["Type"] == "Open"), [])
+    closes = next((s["Values"] for s in ohlc if s["Type"] == "Close"), [])
+    vols = next((s["Values"] for s in volumes if s["Type"] == "Volume"), [])
+
+    for i, d_str in enumerate(dates):
+        dt = datetime.fromisoformat(d_str)
+        c_open = opens[i] if i < len(opens) else None
+        c_high = highs[i] if i < len(highs) else None
+        c_low = lows[i] if i < len(lows) else None
+        c_close = closes[i] if i < len(closes) else None
+        c_vol = vols[i] if i < len(vols) else None
+
+        candles.append(
+            OHLCV(date=dt, open=c_open, high=c_high, low=c_low, close=c_close, volume=c_vol)
+        )
+
+    # Try to extract real name from earlier response?
+    # We don't have it easily here without another request or parsing summary more.
+    # Ticker defaults to just ticker string for now.
+    sym = Symbol(ticker=ticker, name=ticker)
+
+    return History(symbol=sym, candles=candles)
+
+
+def _check_price_match_logic(history: History, target_dt: datetime, target_price: float) -> bool:
+    """Internal helper for validation logic"""
+    # Convert to DataFrame for easier lookups or iterate
+    # Let's iterate efficiently
+    # Find exact date
+    match_row = None
+    target_ts = pd.Timestamp(target_dt)
+
+    # Check exact date (ignoring time)
+    for c in history.candles:
+        if pd.Timestamp(c.date).date() == target_ts.date():
+            match_row = c
+            break
+
+    # Fallback: Nearest (within 3 days)
+    if not match_row:
+        # Sort by diff
+        candidates = []
+        for c in history.candles:
+            diff = abs((pd.Timestamp(c.date).date() - target_ts.date()).days)
+            if diff <= 3:
+                candidates.append((diff, c))
+
+        if candidates:
+            # Sort by diff
+            candidates.sort(key=lambda x: x[0])
+            match_row = candidates[0][1]
+
+    if not match_row:
+        return False
+
+    # Range Check
+    if match_row.high is not None and match_row.low is not None:
+        if match_row.low <= target_price <= match_row.high:
+            return True
+        else:
+            return False  # Strict range check
+
+    # Close Check
+    if match_row.close is not None:
+        diff = abs(match_row.close - target_price)
+        pct = diff / target_price
+        return pct < 0.05
+
+    return False
+
+
+class FTDataSource(DataSource):
+    """
+    Financial Times (markets.ft.com) data source implementation.
+    """
+
+    def search(self, query: str) -> list[Symbol]:
+        return search(query)
+
+    def resolve(self, criteria: SecurityCriteria) -> Symbol | None:
+        # Note: SecurityCriteria in pydantic-market-data might not
+        # have preferred_exchanges yet. We use what's available.
+        results = resolve_ticker(
+            isin=criteria.isin,
+            symbol=criteria.symbol,
+            description=criteria.description,
+            preferred_exchanges=None,
+            target_price=criteria.target_price,
+            target_date=str(criteria.target_date) if criteria.target_date else None,
+            currency=criteria.currency,
+            limit=1,
+        )
+        if results:
+            return results[0]
+        return None
+
+    def history(self, ticker: str, period: str = "1mo") -> History:
+        return history(ticker, period=period)
+
+    def validate(self, ticker: str, target_date: Any, target_price: float) -> bool:
+        """
+        Validates if the ticker traded near the target price on the target date.
+        """
+        try:
+            hist = self.history(ticker, period="3mo")
+            # Convert target_date to datetime if it's a date or str
+            if isinstance(target_date, str):
+                dt = None
+                for fmt in ("%Y-%m-%d", "%Y%m%d"):
+                    try:
+                        dt = datetime.strptime(target_date, fmt)
+                        break
+                    except ValueError:
+                        pass
+            elif isinstance(target_date, date):
+                dt = datetime.combine(target_date, datetime.min.time())
+            else:
+                dt = target_date
+
+            if not dt:
+                return False
+
+            return _check_price_match_logic(hist, dt, target_price)
+        except Exception:
+            return False

ftmarkets/cli.py

@@ -0,0 +1,23 @@
+import argparse
+
+from .commands import history, lookup
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Financial Times Markets CLI Tool")
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Register commands
+    lookup.setup_parser(subparsers)
+    history.setup_parser(subparsers)
+
+    args = parser.parse_args()
+
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

ftmarkets/client.py

@@ -0,0 +1,55 @@
+from typing import Any
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+
+class FTClient:
+    """
+    Stateless client for markets.ft.com.
+    """
+
+    BASE_URL = "https://markets.ft.com"
+
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "User-Agent": (
+                    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                ),
+                "Accept": "application/json, text/plain, */*",
+                "Referer": "https://markets.ft.com/data/equities",
+            }
+        )
+
+        # Retry strategy
+        retries = Retry(
+            total=3,
+            backoff_factor=1,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["HEAD", "GET", "POST", "OPTIONS"],
+        )
+        adapter = HTTPAdapter(max_retries=retries)
+        self.session.mount("https://", adapter)
+        self.session.mount("http://", adapter)
+
+    def get(self, path: str, params: dict[str, Any] | None = None, **kwargs) -> requests.Response:
+        url = f"{self.BASE_URL}{path}" if path.startswith("/") else path
+        # If full URL passed (e.g. for scraping), handle it
+        if path.startswith("http"):
+            url = path
+
+        kwargs.setdefault("timeout", 10)  # default 10s timeout
+        return self.session.get(url, params=params, **kwargs)
+
+    def post(self, path: str, json: dict[str, Any] | None = None, **kwargs) -> requests.Response:
+        url = f"{self.BASE_URL}{path}"
+        kwargs.setdefault("timeout", 10)
+        return self.session.post(url, json=json, **kwargs)
+
+
+# Singleton instance
+client = FTClient()

ftmarkets/commands/history.py

@@ -0,0 +1,84 @@
+import sys
+
+import pandas as pd
+
+from .. import api
+from ..utils import parse_date
+
+
+def setup_parser(subparsers):
+    parser = subparsers.add_parser("history", help="Fetch history and validate")
+    parser.add_argument("--isin", help="ISIN of the security")
+    parser.add_argument("--symbol", help="Symbol")
+    parser.add_argument("--desc", help="Description")
+    parser.add_argument("--exchange", help="Preferred exchange")
+    parser.add_argument("--period", default="1mo", help="Period (e.g. 1mo, 1y)")
+    parser.add_argument("--price", type=float, help="Validation price")
+    parser.add_argument("--date", help="Validation date")
+    parser.set_defaults(func=handle)
+
+
+def handle(args):
+    preferred = [args.exchange] if args.exchange else None
+
+    ticker_str = api.resolve_ticker(
+        isin=args.isin,
+        symbol=args.symbol,
+        description=args.desc,
+        preferred_exchanges=preferred,
+        target_price=args.price,
+        target_date=args.date,
+    )
+
+    if not ticker_str:
+        print("Could not resolve ticker.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Resolved to: {ticker_str}")
+    hist = api.history(ticker_str, period=args.period)
+    df = hist.to_pandas()
+
+    if df.empty:
+        print("No history found.", file=sys.stderr)
+        sys.exit(1)
+
+    print(df.tail())
+
+    if args.price and args.date:
+        target_dt = parse_date(args.date)
+        if not target_dt:
+            print(f"Invalid date: {args.date}", file=sys.stderr)
+            sys.exit(1)
+
+        target_ts = pd.Timestamp(target_dt)
+        row = None
+        if target_ts in df.index:
+            row = df.loc[target_ts]
+        else:
+            idx = df.index.get_indexer([target_ts], method="nearest")[0]
+            if idx != -1:
+                actual_ts = df.index[idx]
+                if abs((actual_ts - target_ts).days) <= 3:
+                    row = df.iloc[idx]
+                    print(f"Using nearest data from {actual_ts.date()}")
+
+        if row is None:
+            print(f"Date {args.date} not found in history.", file=sys.stderr)
+            sys.exit(1)
+
+        high, low, close_ = row.get("High"), row.get("Low"), row.get("Close")
+        passed = False
+        if pd.notna(high) and pd.notna(low):
+            passed = low <= args.price <= high
+        elif pd.notna(close_):
+            passed = (abs(close_ - args.price) / args.price) < 0.05
+
+        if passed:
+            print("VALIDATION PASSED")
+        else:
+            msg = (
+                f"VALIDATION FAILED (Open={row.get('Open')}, "
+                f"High={high}, Low={low}, Close={close_})"
+            )
+            print(msg)
+            sys.exit(1)

ftmarkets/commands/lookup.py

@@ -0,0 +1,70 @@
+import json
+import sys
+
+from .. import api
+
+
+def setup_parser(subparsers):
+    parser = subparsers.add_parser("lookup", help="Lookup a ticker symbol")
+    parser.add_argument("--isin", help="ISIN of the security")
+    parser.add_argument("--symbol", help="Symbol")
+    parser.add_argument("--desc", help="Description")
+    parser.add_argument("--exchange", help="Preferred exchange")
+    parser.add_argument("--currency", help="Filter by currency (e.g. EUR, USD)")
+    parser.add_argument("--country", help="Filter by country (e.g. DE, US)")
+    parser.add_argument("--asset-class", help="Filter by asset class (ETF, Equity, Fund, Index)")
+    parser.add_argument(
+        "--limit", type=int, default=100, help="Limit number of results (0 for all)"
+    )
+    parser.add_argument(
+        "--format",
+        choices=["text", "json", "xml"],
+        default="text",
+        help="Output format",
+    )
+    parser.add_argument("--price", type=float, help="Validation price")
+    parser.add_argument("--date", help="Validation date")
+    parser.set_defaults(func=handle)
+
+
+def handle(args):
+    preferred = [args.exchange] if args.exchange else None
+
+    symbols = api.resolve_ticker(
+        isin=args.isin,
+        symbol=args.symbol,
+        description=args.desc,
+        preferred_exchanges=preferred,
+        target_price=args.price,
+        target_date=args.date,
+        currency=args.currency,
+        country=args.country,
+        asset_class=args.asset_class,
+        limit=args.limit,
+    )
+
+    if not symbols:
+        print("Ticker not found", file=sys.stderr)
+        sys.exit(1)
+
+    if args.format == "json":
+        data = []
+        for s in symbols:
+            d = s.model_dump()
+            data.append(d)
+        print(json.dumps(data, indent=2, default=str))
+    elif args.format == "xml":
+        print("<Results>")
+        for s in symbols:
+            print("  <Symbol>")
+            print(f"    <Ticker>{s.ticker}</Ticker>")
+            print(f"    <Name>{s.name}</Name>")
+            print(f"    <Exchange>{s.exchange or ''}</Exchange>")
+            print(f"    <Country>{s.country or ''}</Country>")
+            print(f"    <Currency>{s.currency or ''}</Currency>")
+            print(f"    <AssetClass>{s.asset_class or ''}</AssetClass>")
+            print("  </Symbol>")
+        print("</Results>")
+    else:
+        for s in symbols:
+            print(s.ticker)

ftmarkets/utils.py

@@ -0,0 +1,10 @@
+from datetime import datetime
+
+
+def parse_date(date_str: str) -> datetime | None:
+    for fmt in ("%Y-%m-%d", "%Y%m%d", "%d/%m/%Y"):
+        try:
+            return datetime.strptime(date_str, fmt)
+        except ValueError:
+            pass
+    return None

py_ftmarkets-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: py-ftmarkets
+Version: 0.1.0
+Summary: Financial Times (markets.ft.com) data source for Python
+Project-URL: Homepage, https://github.com/romamo/ftfinance
+Project-URL: Repository, https://github.com/romamo/ftfinance
+Project-URL: Issues, https://github.com/romamo/ftfinance/issues
+Author-email: Roman Medvedev <pypi@romavm.dev>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.13
+Requires-Dist: html5lib>=1.1
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pydantic-market-data
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: requests>=2.32.5
+Description-Content-Type: text/markdown
+
+# py-ftmarkets
+
+Financial Times (markets.ft.com) data source for Python. Provides a high-level API and CLI to search for securities, fetch historical data, and validate prices.
+
+## Installation
+
+```bash
+uv add py-ftmarkets
+# or
+pip install py-ftmarkets
+```
+
+## CLI Usage
+
+The package provides a CLI tool named `ftmarkets`.
+
+### Lookup a Ticker
+
+Resolve an ISIN or Symbol to the Financial Times ticker format (e.g., `AAPL:NSQ`).
+
+```bash
+# Basic lookup by ISIN
+ftmarkets lookup --isin DE000A0S9GB0
+
+# Lookup with price and date validation (Returns 1 best matching ticker)
+ftmarkets lookup --isin DE000A0S9GB0 --price 117.81 --date 2025-12-12 --limit 1
+
+# Lookup with filters (currency, country, asset-class)
+ftmarkets lookup --isin DE000A0S9GB0 --currency EUR --country DE --asset-class ETF
+
+# Return all matching results in JSON format
+ftmarkets lookup --isin DE000A0S9GB0 --limit 0 --format json
+```
+
+### Fetch History and Validate
+
+Fetch historical data for a resolved ticker and optionally validate a trade price on a specific date.
+
+```bash
+# Fetch 1 month of history for an ISIN
+ftmarkets history --isin DE000A0S9GB0
+
+# Fetch 1 year of history and validate a price
+ftmarkets history --isin DE000A0S9GB0 --period 1y --price 120.50 --date 2025-01-15
+```
+
+## Library Usage
+
+`py-ftmarkets` implements the `DataSource` interface from `pydantic-market-data`.
+
+```python
+from ftmarkets.api import FTDataSource
+from pydantic_market_data.models import SecurityCriteria
+
+source = FTDataSource()
+
+# Resolve a security
+criteria = SecurityCriteria(isin="DE000A0S9GB0")
+symbol = source.resolve(criteria)
+print(f"Ticker: {symbol.ticker}")
+
+# Fetch history
+history = source.history(symbol.ticker, period="1mo")
+df = history.to_pandas()
+print(df.tail())
+
+# Validate price
+is_valid = source.validate(symbol.ticker, target_date="2025-01-15", target_price=120.50)
+print(f"Price valid: {is_valid}")
+```
+
+## Features
+
+- **Robust Resolution**: Searches by ISIN, Symbol, or Description.
+- **Smart Mapping**: Prioritizes results based on preferred exchanges and currency.
+- **Price Validation**: Verifies if a security traded within a range or near a specific price on a given date.
+- **Pandas Integration**: Historical data is easily convertible to Pandas DataFrames.
+- **Modern Python**: Built with Pydantic v2 and async-ready architecture (though currently synchronous).

py_ftmarkets-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+ftmarkets/__init__.py,sha256=7l7ygcfvXNxrxn9D-h60NM4fKIgJAKC6IJ02niJZMVk,327
+ftmarkets/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+ftmarkets/api.py,sha256=f_v3w2QKev6UaHBVLAvWbVxOFe_--60emNJFu5_RS6w,16809
+ftmarkets/cli.py,sha256=1GALiNLDt7f5TrRC2BTgj6n5Jf2G0pf0ab-HVsmhshc,495
+ftmarkets/client.py,sha256=ae2FCZE66ZF4vQwB8mLPrxFmitPQ9oVV-l0QryDNv14,1799
+ftmarkets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ftmarkets/utils.py,sha256=OsW-UqCfyPpMZB3FUajBtBK7KNIRIh4HaN-VAdQ9f8k,258
+ftmarkets/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ftmarkets/commands/history.py,sha256=TP_QEDni0QDqu8jaHRb-ExE0k5GVxGYXvRrx6ok3WXQ,2671
+ftmarkets/commands/lookup.py,sha256=WlAef8iQvVZYL7ErT3aOl663HmeHc-HC7rEmZiotfVk,2392
+py_ftmarkets-0.1.0.dist-info/METADATA,sha256=eTk0DDuU3AlYjLdKRSQezatsOkZckReqOgEFPzp7aTQ,3287
+py_ftmarkets-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+py_ftmarkets-0.1.0.dist-info/entry_points.txt,sha256=Hh8APLa1bUvfbx60Zzi9j6f8QD-8haNshxcfoAODz7c,49
+py_ftmarkets-0.1.0.dist-info/licenses/LICENSE,sha256=s07DUb5DYqzsOxq1d1k3AJvmVxjRl4BHMrKeu-ekeNc,1071
+py_ftmarkets-0.1.0.dist-info/RECORD,,

py_ftmarkets-0.1.0.dist-info/WHEEL

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

py_ftmarkets-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ftmarkets = ftmarkets.cli:main

py_ftmarkets-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roman Medvedev
+
+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.