analysis-poly 0.1.0__py3-none-any.whl

analysis_poly/market_cache.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .models import PolymarketMarket
+
+
+class MarketMetadataCache:
+    def __init__(self, cache_dir: str | Path = ".cache/market_by_slug", recent_window_sec: int = 30 * 60):
+        self._cache_dir = Path(cache_dir)
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+        self._recent_window_sec = recent_window_sec
+        self._symbol_payload_cache: dict[str, dict] = {}
+        self._market_obj_cache: dict[str, PolymarketMarket] = {}
+
+    def is_cache_eligible(self, slug: str, now_ts: int) -> bool:
+        market_ts = _market_ts_from_slug(slug)
+        if market_ts is None:
+            return False
+        return (now_ts - market_ts) > self._recent_window_sec
+
+    def get(self, slug: str) -> PolymarketMarket | None:
+        cached_market = self._market_obj_cache.get(slug)
+        if cached_market is not None:
+            return cached_market
+
+        symbol = _symbol_from_slug(slug)
+        if symbol is None:
+            return None
+
+        payload = self._load_symbol_payload(symbol)
+        markets = payload.get("markets", {})
+        market_payload = markets.get(slug)
+        if market_payload is not None:
+            try:
+                market = PolymarketMarket.model_validate(market_payload)
+                self._market_obj_cache[slug] = market
+                return market
+            except Exception:  # noqa: BLE001
+                return None
+
+        # Backward compatibility for legacy per-slug cache files.
+        legacy_path = self._legacy_path_for_slug(slug)
+        if not legacy_path.exists():
+            return None
+        try:
+            market = PolymarketMarket.model_validate_json(legacy_path.read_text(encoding="utf-8"))
+            self._market_obj_cache[slug] = market
+            self.set(slug, market)
+            return market
+        except Exception:  # noqa: BLE001
+            return None
+
+    def set(self, slug: str, market: PolymarketMarket) -> None:
+        symbol = _symbol_from_slug(slug)
+        if symbol is None:
+            return
+
+        payload = self._load_symbol_payload(symbol)
+        market_dump = market.model_dump()
+        payload["symbol"] = symbol
+        markets = payload["markets"]
+        if markets.get(slug) == market_dump:
+            self._market_obj_cache[slug] = market
+            return
+
+        markets[slug] = market_dump
+        self._market_obj_cache[slug] = market
+        self._save_symbol_payload(symbol, payload)
+
+    def _load_symbol_payload(self, symbol: str) -> dict:
+        cached = self._symbol_payload_cache.get(symbol)
+        if cached is not None:
+            return cached
+
+        path = self._path_for_symbol(symbol)
+        payload: dict = {"symbol": symbol, "markets": {}}
+        if path.exists():
+            try:
+                loaded = json.loads(path.read_text(encoding="utf-8"))
+                if isinstance(loaded, dict):
+                    payload = loaded
+            except Exception:  # noqa: BLE001
+                payload = {"symbol": symbol, "markets": {}}
+
+        if not isinstance(payload.get("markets"), dict):
+            payload["markets"] = {}
+        payload["symbol"] = symbol
+        self._symbol_payload_cache[symbol] = payload
+        return payload
+
+    def _save_symbol_payload(self, symbol: str, payload: dict) -> None:
+        path = self._path_for_symbol(symbol)
+        tmp_path = path.with_suffix(".tmp")
+        try:
+            tmp_path.write_text(
+                json.dumps(payload, ensure_ascii=False, separators=(",", ":")),
+                encoding="utf-8",
+            )
+            tmp_path.replace(path)
+        except Exception:  # noqa: BLE001
+            try:
+                if tmp_path.exists():
+                    tmp_path.unlink()
+            except Exception:  # noqa: BLE001
+                pass
+            return
+
+    def _path_for_symbol(self, symbol: str) -> Path:
+        safe_symbol = re.sub(r"[^a-zA-Z0-9_.-]", "_", symbol.lower())
+        return self._cache_dir / f"{safe_symbol}.json"
+
+    def _legacy_path_for_slug(self, slug: str) -> Path:
+        safe_slug = re.sub(r"[^a-zA-Z0-9_.-]", "_", slug)
+        return self._cache_dir / f"{safe_slug}.json"
+
+
+
+def _market_ts_from_slug(slug: str) -> int | None:
+    try:
+        return int(str(slug).rsplit("-", 1)[-1])
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _symbol_from_slug(slug: str) -> str | None:
+    parts = str(slug).split("-")
+    if not parts:
+        return None
+    symbol = parts[0].strip().lower()
+    return symbol or None

analysis_poly/market_result_cache.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import json
+import re
+import time
+from pathlib import Path
+
+
+class AddressMarketResultCache:
+    def __init__(self, cache_dir: str | Path = ".cache/address_market_results"):
+        self._cache_dir = Path(cache_dir)
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def load(self, address: str) -> dict[str, dict]:
+        path = self._path_for_address(address)
+        if not path.exists():
+            return {}
+
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+            markets = payload.get("markets")
+            if isinstance(markets, dict):
+                return markets
+        except Exception:  # noqa: BLE001
+            return {}
+        return {}
+
+    def save(self, address: str, markets: dict[str, dict]) -> None:
+        path = self._path_for_address(address)
+        payload = {
+            "address": address.lower(),
+            "updated_at": int(time.time()),
+            "markets": markets,
+        }
+
+        tmp_path = path.with_suffix(".tmp")
+        try:
+            tmp_path.write_text(
+                json.dumps(payload, ensure_ascii=False, separators=(",", ":")),
+                encoding="utf-8",
+            )
+            tmp_path.replace(path)
+        except Exception:  # noqa: BLE001
+            try:
+                if tmp_path.exists():
+                    tmp_path.unlink()
+            except Exception:  # noqa: BLE001
+                pass
+
+    def _path_for_address(self, address: str) -> Path:
+        safe_addr = re.sub(r"[^a-zA-Z0-9_.-]", "_", address.lower().strip())
+        return self._cache_dir / f"{safe_addr}.json"

analysis_poly/models.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+
+class RunStatus(str, Enum):
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    STOPPING = "STOPPING"
+    COMPLETED = "COMPLETED"
+    STOPPED = "STOPPED"
+    FAILED = "FAILED"
+
+
+class AnalysisRequest(BaseModel):
+    address: str
+    start_ts: int
+    end_ts: int
+    symbols: list[Literal["btc", "eth", "sol", "xrp"]]
+    intervals: list[int]
+    fee_rate_bps: float = 1000
+    maker_reward_ratio: float = 0.2
+    missing_cost_warn_qty: float = 0.5
+    page_limit: int = 1000
+    concurrency: int = 5
+    request_timeout_sec: float = 20
+    output_dir: str = "reports"
+
+    @field_validator("address")
+    @classmethod
+    def validate_address(cls, value: str) -> str:
+        lowered = value.lower().strip()
+        if not lowered.startswith("0x"):
+            raise ValueError("address must start with 0x")
+        return lowered
+
+    @field_validator("symbols")
+    @classmethod
+    def validate_symbols(cls, value: list[str]) -> list[str]:
+        if not value:
+            raise ValueError("symbols cannot be empty")
+        uniq = sorted(set(value))
+        return uniq
+
+    @field_validator("intervals")
+    @classmethod
+    def validate_intervals(cls, value: list[int]) -> list[int]:
+        if not value:
+            raise ValueError("intervals cannot be empty")
+        if any(v <= 0 for v in value):
+            raise ValueError("intervals must be > 0")
+        return sorted(set(value))
+
+    @model_validator(mode="after")
+    def validate_time_range(self) -> "AnalysisRequest":
+        if self.start_ts >= self.end_ts:
+            raise ValueError("start_ts must be smaller than end_ts")
+        return self
+
+
+class RunCreated(BaseModel):
+    run_id: str
+    status: RunStatus
+
+
+class RunStopAck(BaseModel):
+    run_id: str
+    status: RunStatus
+
+
+class RunState(BaseModel):
+    run_id: str
+    status: RunStatus
+    started_at: datetime | None = None
+    ended_at: datetime | None = None
+    progress_current: int = 0
+    progress_total: int = 0
+    message: str = ""
+
+
+class WarningItem(BaseModel):
+    timestamp: int | None = None
+    market_slug: str | None = None
+    token_id: str | None = None
+    code: str
+    message: str
+
+
+class CurvePoint(BaseModel):
+    timestamp: int
+    delta_realized_pnl_usdc: float
+    cumulative_realized_pnl_usdc: float
+
+
+class TokenReport(BaseModel):
+    token_id: str
+    outcome: Literal["Up", "Down"]
+    realized_pnl_usdc: float = 0
+    taker_fee_usdc: float = 0
+    maker_reward_usdc: float = 0
+    buy_qty: float = 0
+    sell_qty: float = 0
+    split_qty: float = 0
+    redeem_qty: float = 0
+    ending_position_qty: float = 0
+    trade_count: int = 0
+
+
+class MarketReport(BaseModel):
+    market_slug: str
+    condition_id: str
+    up_token_id: str
+    down_token_id: str
+    realized_pnl_usdc: float = 0
+    taker_fee_usdc: float = 0
+    maker_reward_usdc: float = 0
+    ending_position_up: float = 0
+    ending_position_down: float = 0
+    tokens: list[TokenReport] = Field(default_factory=list)
+
+
+class SummaryStats(BaseModel):
+    total_realized_pnl_usdc: float = 0
+    total_taker_fee_usdc: float = 0
+    total_maker_reward_usdc: float = 0
+    markets_total: int = 0
+    markets_processed: int = 0
+
+
+class AnalysisReport(BaseModel):
+    request: AnalysisRequest
+    summary: SummaryStats
+    markets: list[MarketReport]
+    total_curve: list[CurvePoint]
+    market_curves: dict[str, list[CurvePoint]]
+    total_curve_no_fee: list[CurvePoint] = Field(default_factory=list)
+    market_curves_no_fee: dict[str, list[CurvePoint]] = Field(default_factory=dict)
+    warnings: list[WarningItem]
+    is_partial: bool = False
+    artifacts: dict[str, str] = Field(default_factory=dict)
+
+
+class PolymarketMarket(BaseModel):
+    slug: str
+    condition_id: str
+    up_token_id: str
+    down_token_id: str
+    outcomes: list[str]
+    outcome_prices: list[float]
+
+
+class TradeRecord(BaseModel):
+    transaction_hash: str = Field(alias="transactionHash")
+    timestamp: int
+    side: Literal["BUY", "SELL"]
+    asset: str
+    condition_id: str = Field(alias="conditionId")
+    size: float
+    price: float
+    outcome: str | None = None
+
+
+class ActivityRecord(BaseModel):
+    transaction_hash: str = Field(alias="transactionHash")
+    timestamp: int
+    type: str
+    condition_id: str = Field(alias="conditionId")
+    slug: str = ""
+    size: float = 0
+    usdc_size: float = Field(default=0, alias="usdcSize")
+
+
+class StreamEvent(BaseModel):
+    event: str
+    data: dict
+
+
+def utc_now() -> datetime:
+    return datetime.now(timezone.utc)

analysis_poly/open_with_params.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import argparse
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import webbrowser
+from datetime import datetime
+
+if __package__ in (None, ""):
+    import sys
+    from pathlib import Path
+
+    sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+    from analysis_poly.logging_config import configure_logging
+    from analysis_poly.web import app
+else:
+    from .logging_config import configure_logging
+    from .web import app
+
+
+def _to_datetime_text(unix_ts: int) -> str:
+    return datetime.fromtimestamp(unix_ts).strftime("%Y-%m-%d %H:%M")
+
+
+def _browser_host(host: str) -> str:
+    if host == "0.0.0.0":
+        return "localhost"
+    return host
+
+
+def _build_bootstrap_query(args: argparse.Namespace) -> dict[str, str]:
+    params: dict[str, str] = {}
+
+    mapping = {
+        "address": "address",
+        "symbols": "symbols",
+        "intervals": "intervals",
+        "start_time": "start_time",
+        "end_time": "end_time",
+        "fee_rate_bps": "fee_rate_bps",
+        "missing_cost_warn_qty": "missing_cost_warn_qty",
+        "maker_reward_ratio": "maker_reward_ratio",
+        "concurrency": "concurrency",
+        "page_limit": "page_limit",
+    }
+    for arg_key, query_key in mapping.items():
+        value = getattr(args, arg_key)
+        if value is None:
+            continue
+        params[query_key] = str(value)
+
+    if args.start_ts is not None and "start_time" not in params:
+        params["start_time"] = _to_datetime_text(args.start_ts)
+    if args.end_ts is not None and "end_time" not in params:
+        params["end_time"] = _to_datetime_text(args.end_ts)
+
+    has_analysis_fields = any(
+        key in params
+        for key in {
+            "address",
+            "symbols",
+            "intervals",
+            "start_time",
+            "end_time",
+            "fee_rate_bps",
+            "missing_cost_warn_qty",
+            "maker_reward_ratio",
+            "concurrency",
+            "page_limit",
+        }
+    )
+    if args.auto_start or has_analysis_fields:
+        params["auto_start"] = "1"
+
+    return params
+
+
+def _build_browser_url(args: argparse.Namespace) -> str:
+    host = _browser_host(args.host)
+    base = f"http://{host}:{args.port}/"
+    params = _build_bootstrap_query(args)
+    if not params:
+        return base
+    return f"{base}?{urllib.parse.urlencode(params)}"
+
+
+def _open_browser_when_ready(url: str, probe_url: str, timeout_sec: float) -> None:
+    deadline = time.monotonic() + timeout_sec
+    while time.monotonic() < deadline:
+        try:
+            with urllib.request.urlopen(probe_url, timeout=0.8):
+                webbrowser.open(url)
+                return
+        except (urllib.error.URLError, TimeoutError):
+            time.sleep(0.25)
+    webbrowser.open(url)
+
+
+def _build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Start web server and open browser with bootstrap params")
+    parser.add_argument("--host", default="0.0.0.0", help="Bind host for web server")
+    parser.add_argument("--port", type=int, default=8000, help="Bind port for web server")
+    parser.add_argument("--browser-timeout-sec", type=float, default=20.0, help="Wait timeout for browser auto-open")
+
+    parser.add_argument("--address")
+    parser.add_argument("--symbols", help='Comma-separated, e.g. "btc,eth,sol"')
+    parser.add_argument("--intervals", help='Comma-separated, e.g. "5,15"')
+    parser.add_argument("--start-time", help='Local datetime, format "YYYY-MM-DD HH:MM"')
+    parser.add_argument("--end-time", help='Local datetime, format "YYYY-MM-DD HH:MM"')
+    parser.add_argument("--start-ts", type=int, help="Unix timestamp (seconds), used when --start-time is missing")
+    parser.add_argument("--end-ts", type=int, help="Unix timestamp (seconds), used when --end-time is missing")
+    parser.add_argument("--fee-rate-bps", type=float)
+    parser.add_argument("--missing-cost-warn-qty", type=float)
+    parser.add_argument("--maker-reward-ratio", type=float)
+    parser.add_argument("--concurrency", type=int)
+    parser.add_argument("--page-limit", type=int)
+    parser.add_argument("--auto-start", action="store_true", help="Force auto start analysis in frontend")
+    return parser
+
+
+def main() -> None:
+    import uvicorn
+
+    args = _build_arg_parser().parse_args()
+    configure_logging()
+
+    browser_host = _browser_host(args.host)
+    probe_url = f"http://{browser_host}:{args.port}/"
+    url = _build_browser_url(args)
+    threading.Thread(
+        target=_open_browser_when_ready,
+        args=(url, probe_url, max(1.0, args.browser_timeout_sec)),
+        daemon=True,
+    ).start()
+
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

analysis_poly/polymarket_client.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import httpx
+
+from .models import ActivityRecord, PolymarketMarket, TradeRecord
+
+
+class PolymarketApiClient:
+    def __init__(self, timeout_sec: float = 20, retries: int = 5):
+        self._timeout_sec = timeout_sec
+        self._retries = retries
+        self._gamma_base = "https://gamma-api.polymarket.com"
+        self._data_base = "https://data-api.polymarket.com"
+        self._client = httpx.AsyncClient(timeout=timeout_sec)
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    async def _request_json(self, method: str, url: str, params: dict[str, Any] | None = None) -> Any:
+        last_exc: Exception | None = None
+        for attempt in range(self._retries):
+            try:
+                response = await self._client.request(method, url, params=params)
+                if response.status_code == 404:
+                    return None
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as exc:
+                last_exc = exc
+                if 400 <= exc.response.status_code < 500:
+                    raise
+            except Exception as exc:  # noqa: BLE001
+                last_exc = exc
+
+            if attempt + 1 < self._retries:
+                await asyncio.sleep(0.4 * (2**attempt))
+
+        if last_exc:
+            raise last_exc
+        raise RuntimeError("request failed without exception")
+
+    async def get_market_by_slug(self, slug: str) -> PolymarketMarket | None:
+        data = await self._request_json("GET", f"{self._gamma_base}/markets/slug/{slug}")
+        if not data:
+            return None
+
+        outcomes_raw = data.get("outcomes", "[]")
+        outcome_prices_raw = data.get("outcomePrices", "[]")
+        tokens_raw = data.get("clobTokenIds", "[]")
+
+        outcomes = _parse_json_field(outcomes_raw, fallback=[])
+        outcome_prices = [float(x) for x in _parse_json_field(outcome_prices_raw, fallback=[])]
+        token_ids = [str(x) for x in _parse_json_field(tokens_raw, fallback=[])]
+
+        if len(token_ids) < 2:
+            return None
+
+        return PolymarketMarket(
+            slug=data["slug"],
+            condition_id=data["conditionId"],
+            up_token_id=token_ids[0],
+            down_token_id=token_ids[1],
+            outcomes=outcomes,
+            outcome_prices=outcome_prices,
+        )
+
+    async def get_trades(
+        self,
+        user: str,
+        market: str,
+        taker_only: bool,
+        limit: int = 1000,
+    ) -> list[TradeRecord]:
+        records: list[TradeRecord] = []
+        offset = 0
+        while True:
+            params = {
+                "user": user,
+                "market": market,
+                "takerOnly": str(taker_only).lower(),
+                "limit": limit,
+                "offset": offset,
+            }
+            data = await self._request_json("GET", f"{self._data_base}/trades", params=params)
+            if not data:
+                break
+            page = [TradeRecord.model_validate(item) for item in data]
+            records.extend(page)
+            if len(page) < limit:
+                break
+            offset += len(page)
+        return records
+
+    async def get_activity(
+        self,
+        user: str,
+        market: str,
+        activity_type: str,
+        limit: int = 1000,
+    ) -> list[ActivityRecord]:
+        records: list[ActivityRecord] = []
+        offset = 0
+        while True:
+            params = {
+                "user": user,
+                "market": market,
+                "type": activity_type,
+                "sortBy": "TIMESTAMP",
+                "sortDirection": "ASC",
+                "limit": limit,
+                "offset": offset,
+            }
+            data = await self._request_json("GET", f"{self._data_base}/activity", params=params)
+            if not data:
+                break
+            page = [ActivityRecord.model_validate(item) for item in data]
+            records.extend(page)
+            if len(page) < limit:
+                break
+            offset += len(page)
+        return records
+
+
+
+def _parse_json_field(raw: Any, fallback: list[Any]) -> list[Any]:
+    if isinstance(raw, list):
+        return raw
+    if isinstance(raw, str):
+        import json
+
+        try:
+            parsed = json.loads(raw)
+            if isinstance(parsed, list):
+                return parsed
+            return fallback
+        except Exception:  # noqa: BLE001
+            return fallback
+    return fallback