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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: analysis-poly
-Version: 0.1.2
+Version: 0.1.3
 Summary: Polymarket real-profit web analyzer
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{analysis_poly-0.1.2 → analysis_poly-0.1.3}/analysis_poly/activity_discovery.py

@@ -150,6 +150,9 @@ def summarize_discovered_markets(records: list, warnings: list[WarningItem]) ->
     warned_missing_slug: set[str] = set()
 
     for record in records:
+        if _is_zero_value_redeem(record):
+            continue
+
         slug = str(record.slug or "").strip()
         condition_id = str(record.condition_id or "").strip()
         if not slug:
@@ -187,6 +190,14 @@ def summarize_discovered_markets(records: list, warnings: list[WarningItem]) ->
     )
 
 
+def _is_zero_value_redeem(record) -> bool:
+    if str(getattr(record, "type", "")).upper() != "REDEEM":
+        return False
+    size = float(getattr(record, "size", 0) or 0)
+    usdc_size = float(getattr(record, "usdc_size", 0) or 0)
+    return size <= 0 and usdc_size <= 0
+
+
 def dedupe_activity_records(records: list) -> list:
     deduped: dict[str, object] = {}
     for record in records:

{analysis_poly-0.1.2 → analysis_poly-0.1.3}/analysis_poly/analyzer.py

@@ -147,6 +147,8 @@ class PolymarketProfitAnalyzer:
             )
             discovered_markets = _filter_discovered_markets(
                 discovered_markets,
+                start_ts=req.start_ts,
+                end_ts=req.end_ts,
                 keywords=req.keywords,
             )
             total_markets = len(discovered_markets)
@@ -783,9 +785,23 @@ def _is_market_result_cache_eligible(slug: str, now_ts: int, recent_window_sec:
 
 def _filter_discovered_markets(
     discovered_markets: list[DiscoveredMarket],
+    start_ts: int,
+    end_ts: int,
     keywords: list[str],
 ) -> list[DiscoveredMarket]:
-    return [item for item in discovered_markets if _slug_matches_filters(item.slug, keywords=keywords)]
+    return [
+        item
+        for item in discovered_markets
+        if _slug_in_time_range(item.slug, start_ts=start_ts, end_ts=end_ts)
+        and _slug_matches_filters(item.slug, keywords=keywords)
+    ]
+
+
+def _slug_in_time_range(slug: str, start_ts: int, end_ts: int) -> bool:
+    market_ts = _market_ts(slug)
+    if market_ts is None:
+        return True
+    return start_ts <= market_ts <= end_ts
 
 
 def _slug_matches_filters(slug: str, keywords: list[str]) -> bool:

{analysis_poly-0.1.2 → analysis_poly-0.1.3}/analysis_poly/profit_engine.py

@@ -128,6 +128,11 @@ class ProfitEngine:
             )
 
         for redeem in redeem_activities:
+            redeem_size = float(redeem.size)
+            redeem_usdc_size = float(redeem.usdc_size)
+            if redeem_size <= 0 and redeem_usdc_size <= 0:
+                continue
+
             winner_token = _resolve_winner_token(market)
             if not winner_token:
                 warnings.append(
@@ -146,8 +151,8 @@ class ProfitEngine:
                     tx=redeem.transaction_hash,
                     kind="REDEEM",
                     token_id=winner_token,
-                    size=float(redeem.size),
-                    usdc_size=float(redeem.usdc_size),
+                    size=redeem_size,
+                    usdc_size=redeem_usdc_size,
                 )
             )
 

{analysis_poly-0.1.2 → analysis_poly-0.1.3}/analysis_poly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: analysis-poly
-Version: 0.1.2
+Version: 0.1.3
 Summary: Polymarket real-profit web analyzer
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{analysis_poly-0.1.2 → analysis_poly-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "analysis-poly"
-version = "0.1.2"
+version = "0.1.3"
 description = "Polymarket real-profit web analyzer"
 readme = "README.md"
 requires-python = ">=3.11"

{analysis_poly-0.1.2 → analysis_poly-0.1.3}/tests/test_analyzer_discovery.py

@@ -1,5 +1,6 @@
 import asyncio
 
+from analysis_poly.activity_discovery import summarize_discovered_markets
 from analysis_poly.analyzer import PolymarketProfitAnalyzer
 from analysis_poly.models import ActivityRecord, AnalysisRequest, MarketReport, PolymarketMarket, TokenReport
 from analysis_poly.profit_engine import PnlDelta
@@ -122,6 +123,107 @@ def test_run_discovers_daily_markets_and_filters_keywords(monkeypatch):
     asyncio.run(runner())
 
 
+def test_run_filters_discovered_markets_by_slug_timestamp(monkeypatch):
+    class FakeClient:
+        async def get_user_activity_page(
+            self,
+            user,
+            activity_types=None,
+            start_ts=None,
+            end_ts=None,
+            limit=500,
+            offset=0,
+            sort_direction="ASC",
+        ):
+            activity_key = tuple(activity_types or [])
+            if activity_key == ("TRADE", "SPLIT", "REDEEM"):
+                return [
+                    ActivityRecord.model_validate(
+                        {
+                            "transactionHash": "0xold_redeem",
+                            "timestamp": 1776432712,
+                            "type": "REDEEM",
+                            "conditionId": "cond_old",
+                            "slug": "btc-updown-15m-1767960900",
+                            "size": 1,
+                            "usdcSize": 1,
+                        }
+                    ),
+                    ActivityRecord.model_validate(
+                        {
+                            "transactionHash": "0xlive_trade",
+                            "timestamp": 1776432800,
+                            "type": "TRADE",
+                            "conditionId": "cond_live",
+                            "slug": "btc-updown-15m-1776432800",
+                            "size": 1,
+                            "usdcSize": 0.5,
+                        }
+                    ),
+                ]
+            return []
+
+        async def aclose(self):
+            return
+
+    fetched_slugs = []
+
+    async def fake_fetch_markets_with_status(_client, slugs, concurrency):
+        fetched_slugs.extend(slugs)
+        market = PolymarketMarket(
+            slug="btc-updown-15m-1776432800",
+            condition_id="cond_live",
+            up_token_id="up_live",
+            down_token_id="down_live",
+            outcomes=["Up", "Down"],
+            outcome_prices=[0.5, 0.5],
+        )
+        return [(slug, market if slug == market.slug else None) for slug in slugs]
+
+    async def fake_process_single_market(client, engine, engine_no_fee, address, address_market_cache, req, market):
+        report = MarketReport(
+            market_slug=market.slug,
+            condition_id=market.condition_id,
+            up_token_id=market.up_token_id,
+            down_token_id=market.down_token_id,
+            realized_pnl_usdc=1.0,
+            tokens=[TokenReport(token_id=market.up_token_id, outcome="Up", realized_pnl_usdc=1.0, trade_count=1)],
+        )
+        delta = PnlDelta(timestamp=1776432800, market_slug=market.slug, token_id=market.up_token_id, delta_pnl_usdc=1.0)
+        from analysis_poly.analyzer import _MarketProcessResult
+
+        return _MarketProcessResult(
+            market_slug=market.slug,
+            market_report=report,
+            market_report_no_fee=report,
+            deltas=[delta],
+            deltas_no_fee=[delta],
+            warnings=[],
+        )
+
+    async def runner():
+        monkeypatch.setattr("analysis_poly.analyzer.PolymarketApiClient", lambda timeout_sec=20: FakeClient())
+        analyzer = PolymarketProfitAnalyzer()
+        monkeypatch.setattr(analyzer, "_fetch_markets_with_status", fake_fetch_markets_with_status)
+        monkeypatch.setattr(analyzer, "_process_single_market", fake_process_single_market)
+
+        report = await analyzer.run(
+            AnalysisRequest(
+                address="0xb4ef1257f7ac40c26f4dfaaad69ed75f6458682f",
+                start_ts=1774972800,
+                end_ts=1776679380,
+                keywords=[],
+                page_limit=1000,
+                concurrency=5,
+            )
+        )
+
+        assert fetched_slugs == ["btc-updown-15m-1776432800"]
+        assert [market.market_slug for market in report.markets] == ["btc-updown-15m-1776432800"]
+
+    asyncio.run(runner())
+
+
 def test_run_adds_daily_maker_rebate_to_summary_and_total_curve(monkeypatch):
     class FakeClient:
         async def get_user_activity_page(
@@ -226,3 +328,36 @@ def test_run_adds_daily_maker_rebate_to_summary_and_total_curve(monkeypatch):
         assert [item.model_dump() for item in report.maker_rebates] == [{"timestamp": 200, "usdc_size": 23.3977}]
 
     asyncio.run(runner())
+
+
+def test_discovery_ignores_zero_value_redeem_activity():
+    warnings = []
+    records = [
+        ActivityRecord.model_validate(
+            {
+                "transactionHash": "0xzero",
+                "timestamp": 1776432712,
+                "type": "REDEEM",
+                "conditionId": "cond_old",
+                "slug": "btc-updown-15m-1767960900",
+                "size": 0,
+                "usdcSize": 0,
+            }
+        ),
+        ActivityRecord.model_validate(
+            {
+                "transactionHash": "0xtrade",
+                "timestamp": 1776432800,
+                "type": "TRADE",
+                "conditionId": "cond_live",
+                "slug": "btc-updown-15m-1776432800",
+                "size": 1,
+                "usdcSize": 0.5,
+            }
+        ),
+    ]
+
+    discovered = summarize_discovered_markets(records, warnings)
+
+    assert [item.slug for item in discovered] == ["btc-updown-15m-1776432800"]
+    assert warnings == []

{analysis_poly-0.1.2 → analysis_poly-0.1.3}/tests/test_profit_engine.py

@@ -438,6 +438,52 @@ def test_closed_market_without_redeem_losing_position_counts_as_loss():
     assert not any(w.code == "CLOSED_MARKET_UNKNOWN_OUTCOME" for w in warnings)
 
 
+def test_zero_value_redeem_does_not_shift_closed_market_settlement_timestamp():
+    market = PolymarketMarket(
+        slug="btc-updown-15m-1767960900",
+        condition_id="cond_zero_redeem",
+        up_token_id="up_token",
+        down_token_id="down_token",
+        outcomes=["Up", "Down"],
+        outcome_prices=[0, 1],
+        closed=True,
+    )
+
+    taker_buy = TradeRecord.model_validate(
+        {
+            "transactionHash": "0xbuy",
+            "timestamp": 1767960918,
+            "side": "BUY",
+            "asset": "up_token",
+            "conditionId": "cond_zero_redeem",
+            "size": 10,
+            "price": 0.52,
+        }
+    )
+    zero_redeem = ActivityRecord.model_validate(
+        {
+            "transactionHash": "0xzero",
+            "timestamp": 1776432712,
+            "type": "REDEEM",
+            "conditionId": "cond_zero_redeem",
+            "size": 0,
+            "usdcSize": 0,
+        }
+    )
+
+    engine = ProfitEngine(fee_rate_bps=1000, missing_cost_warn_qty=0.5)
+    report, deltas, _ = engine.process_market(
+        market=market,
+        taker_trades=[taker_buy],
+        all_trades=[taker_buy],
+        split_activities=[],
+        redeem_activities=[zero_redeem],
+    )
+
+    assert report.realized_pnl_usdc == -5.2
+    assert [delta.timestamp for delta in deltas] == [1767960918]
+
+
 def test_closed_market_without_resolved_outcome_prices_warns_and_keeps_position():
     market = PolymarketMarket(
         slug="btc-updown-5m-4000",