analysis-poly 0.1.0__tar.gz → 0.1.2__tar.gz

{analysis_poly-0.1.0 → analysis_poly-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: analysis-poly
-Version: 0.1.0
+Version: 0.1.2
 Summary: Polymarket real-profit web analyzer
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -27,7 +27,8 @@ Polymarket real-profit analyzer with a web UI.
 
 ## Scope (Important)
 
-- This tool is primarily designed for Polymarket crypto `updown` markets with taker fees, especially `5m` and `15m` intervals.
+- This tool is primarily designed for Polymarket crypto `updown` markets with taker fees.
+- The dashboard first discovers participated slugs from Polymarket user activity within the selected time range, then replays only the matched markets.
 - It is **not** intended as a universal PnL engine for all Polymarket market types.
 - Main purpose: quantify and visualize the impact of trading fees on real profitability (`Net PnL` vs `No-Fee PnL`).
 
@@ -48,7 +49,7 @@ After install:
 
 ```bash
 analysis-poly
-analysis-poly-open --address 0xabc --symbols btc,eth --intervals 5,15
+analysis-poly-open --address 0xabc --keywords updown,15m
 ```
 
 ## Run
@@ -67,8 +68,7 @@ Use a standalone script to start server, open browser, and pass params in URL.
 ```bash
 uv run -m analysis_poly.open_with_params \
   --address 0xabc \
-  --symbols btc,eth \
-  --intervals 5,15 \
+  --keywords updown,15m \
   --start-time "2026-03-01 00:00" \
   --end-time "2026-03-02 00:00" \
   --concurrency 8

{analysis_poly-0.1.0 → analysis_poly-0.1.2}/README.md

@@ -11,7 +11,8 @@ Polymarket real-profit analyzer with a web UI.
 
 ## Scope (Important)
 
-- This tool is primarily designed for Polymarket crypto `updown` markets with taker fees, especially `5m` and `15m` intervals.
+- This tool is primarily designed for Polymarket crypto `updown` markets with taker fees.
+- The dashboard first discovers participated slugs from Polymarket user activity within the selected time range, then replays only the matched markets.
 - It is **not** intended as a universal PnL engine for all Polymarket market types.
 - Main purpose: quantify and visualize the impact of trading fees on real profitability (`Net PnL` vs `No-Fee PnL`).
 
@@ -32,7 +33,7 @@ After install:
 
 ```bash
 analysis-poly
-analysis-poly-open --address 0xabc --symbols btc,eth --intervals 5,15
+analysis-poly-open --address 0xabc --keywords updown,15m
 ```
 
 ## Run
@@ -51,8 +52,7 @@ Use a standalone script to start server, open browser, and pass params in URL.
 ```bash
 uv run -m analysis_poly.open_with_params \
   --address 0xabc \
-  --symbols btc,eth \
-  --intervals 5,15 \
+  --keywords updown,15m \
   --start-time "2026-03-01 00:00" \
   --end-time "2026-03-02 00:00" \
   --concurrency 8

analysis_poly-0.1.2/analysis_poly/activity_discovery.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+
+from .models import WarningItem
+
+DISCOVERY_ACTIVITY_TYPES = ("TRADE", "SPLIT", "REDEEM")
+DISCOVERY_ACTIVITY_PAGE_LIMIT_MAX = 500
+DISCOVERY_ACTIVITY_OFFSET_MAX = 10000
+SECONDS_PER_DAY = 24 * 60 * 60
+
+
+@dataclass
+class DiscoveredMarket:
+    slug: str
+    condition_id: str
+    first_activity_ts: int
+    last_activity_ts: int
+
+
+async def collect_user_activity(
+    client,
+    address: str,
+    start_ts: int,
+    end_ts: int,
+    page_limit: int,
+    warnings: list[WarningItem],
+    activity_types: list[str] | tuple[str, ...] | None = None,
+) -> list:
+    records: list = []
+    offset = 0
+    reached_offset_cap = False
+
+    while True:
+        page = await client.get_user_activity_page(
+            user=address,
+            activity_types=list(activity_types or DISCOVERY_ACTIVITY_TYPES),
+            start_ts=start_ts,
+            end_ts=end_ts,
+            limit=page_limit,
+            offset=offset,
+            sort_direction="ASC",
+        )
+        if not page:
+            break
+        records.extend(page)
+        if len(page) < page_limit:
+            break
+        offset += len(page)
+        if offset > DISCOVERY_ACTIVITY_OFFSET_MAX:
+            reached_offset_cap = True
+            break
+
+    if not reached_offset_cap:
+        return dedupe_activity_records(records)
+
+    if end_ts - start_ts <= 1:
+        warnings.append(
+            WarningItem(
+                timestamp=start_ts,
+                code="DISCOVERY_WINDOW_TRUNCATED",
+                message="user activity window is too dense to split further; discovery may be incomplete",
+            )
+        )
+        return dedupe_activity_records(records)
+
+    split_ts = start_ts + ((end_ts - start_ts) // 2)
+    left_records, right_records = await asyncio.gather(
+        collect_user_activity(
+            client=client,
+            address=address,
+            start_ts=start_ts,
+            end_ts=split_ts,
+            page_limit=page_limit,
+            warnings=warnings,
+            activity_types=activity_types,
+        ),
+        collect_user_activity(
+            client=client,
+            address=address,
+            start_ts=split_ts + 1,
+            end_ts=end_ts,
+            page_limit=page_limit,
+            warnings=warnings,
+            activity_types=activity_types,
+        ),
+    )
+    return dedupe_activity_records([*left_records, *right_records])
+
+
+async def discover_user_markets_in_range(
+    client,
+    address: str,
+    start_ts: int,
+    end_ts: int,
+    page_limit: int,
+    warnings: list[WarningItem],
+) -> list[DiscoveredMarket]:
+    records = await collect_user_activity(
+        client=client,
+        address=address,
+        start_ts=start_ts,
+        end_ts=end_ts,
+        page_limit=min(max(1, page_limit), DISCOVERY_ACTIVITY_PAGE_LIMIT_MAX),
+        warnings=warnings,
+        activity_types=DISCOVERY_ACTIVITY_TYPES,
+    )
+    return summarize_discovered_markets(records, warnings)
+
+
+async def discover_user_markets_by_day(
+    client,
+    address: str,
+    start_ts: int,
+    end_ts: int,
+    page_limit: int,
+    warnings: list[WarningItem],
+) -> list[DiscoveredMarket]:
+    market_by_key: dict[str, DiscoveredMarket] = {}
+    for window_start, window_end in iter_day_windows(start_ts, end_ts):
+        day_records = await collect_user_activity(
+            client=client,
+            address=address,
+            start_ts=window_start,
+            end_ts=window_end,
+            page_limit=min(max(1, page_limit), DISCOVERY_ACTIVITY_PAGE_LIMIT_MAX),
+            warnings=warnings,
+            activity_types=DISCOVERY_ACTIVITY_TYPES,
+        )
+        for discovered in summarize_discovered_markets(day_records, warnings):
+            market_key = discovered.condition_id or discovered.slug
+            existing = market_by_key.get(market_key)
+            if existing is None:
+                market_by_key[market_key] = discovered
+                continue
+            existing.first_activity_ts = min(existing.first_activity_ts, discovered.first_activity_ts)
+            existing.last_activity_ts = max(existing.last_activity_ts, discovered.last_activity_ts)
+            if not existing.slug and discovered.slug:
+                existing.slug = discovered.slug
+
+    return sorted(
+        market_by_key.values(),
+        key=lambda item: (item.first_activity_ts, item.last_activity_ts, item.slug),
+    )
+
+
+def summarize_discovered_markets(records: list, warnings: list[WarningItem]) -> list[DiscoveredMarket]:
+    market_by_key: dict[str, DiscoveredMarket] = {}
+    warned_missing_slug: set[str] = set()
+
+    for record in records:
+        slug = str(record.slug or "").strip()
+        condition_id = str(record.condition_id or "").strip()
+        if not slug:
+            dedupe_key = f"{condition_id}:{record.type}"
+            if dedupe_key not in warned_missing_slug:
+                warnings.append(
+                    WarningItem(
+                        timestamp=record.timestamp,
+                        code="DISCOVERY_SKIP_MISSING_SLUG",
+                        message="skip user activity record without market slug",
+                    )
+                )
+                warned_missing_slug.add(dedupe_key)
+            continue
+
+        market_key = condition_id or slug
+        existing = market_by_key.get(market_key)
+        if existing is None:
+            market_by_key[market_key] = DiscoveredMarket(
+                slug=slug,
+                condition_id=condition_id,
+                first_activity_ts=record.timestamp,
+                last_activity_ts=record.timestamp,
+            )
+            continue
+
+        existing.first_activity_ts = min(existing.first_activity_ts, record.timestamp)
+        existing.last_activity_ts = max(existing.last_activity_ts, record.timestamp)
+        if not existing.slug and slug:
+            existing.slug = slug
+
+    return sorted(
+        market_by_key.values(),
+        key=lambda item: (item.first_activity_ts, item.last_activity_ts, item.slug),
+    )
+
+
+def dedupe_activity_records(records: list) -> list:
+    deduped: dict[str, object] = {}
+    for record in records:
+        deduped[activity_key(record)] = record
+    return sorted(
+        deduped.values(),
+        key=lambda item: (
+            int(getattr(item, "timestamp", 0)),
+            str(getattr(item, "transaction_hash", "")),
+            str(getattr(item, "type", "")),
+        ),
+    )
+
+
+def activity_key(record) -> str:
+    return "|".join(
+        [
+            str(getattr(record, "transaction_hash", "")),
+            str(getattr(record, "condition_id", "")),
+            str(getattr(record, "type", "")),
+            str(getattr(record, "timestamp", 0)),
+            str(getattr(record, "slug", "")),
+            str(getattr(record, "size", 0)),
+            str(getattr(record, "usdc_size", 0)),
+        ]
+    )
+
+
+def iter_day_windows(start_ts: int, end_ts: int) -> list[tuple[int, int]]:
+    if start_ts > end_ts:
+        return []
+
+    windows: list[tuple[int, int]] = []
+    current = start_ts
+    while current <= end_ts:
+        day_start = (current // SECONDS_PER_DAY) * SECONDS_PER_DAY
+        day_end = day_start + SECONDS_PER_DAY - 1
+        window_end = min(day_end, end_ts)
+        windows.append((current, window_end))
+        current = window_end + 1
+    return windows