poly-position-watcher 0.3.4__tar.gz → 0.3.6__tar.gz

{poly_position_watcher-0.3.4/poly_position_watcher.egg-info → poly_position_watcher-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poly-position-watcher
-Version: 0.3.4
+Version: 0.3.6
 Summary: polymarket proxy wallet redeem
 Home-page: https://github.com/tosmart01/polymarket-position-watcher
 Author: pinbar
@@ -73,8 +73,14 @@ with PositionWatcherService(
 
     # Non-blocking: Get current positions and orders (returns immediately)
     position: UserPosition = service.get_position("<token_id>")
+    strategy_position: UserPosition | None = service.get_position_by_order_ids(["<order_id>"])
+    strategy_positions: dict[str, UserPosition] = service.get_positions_by_order_ids(
+        ["<order_id_1>", "<order_id_2>"]
+    )
     order: OrderMessage = service.get_order("<order_id>")
     print(position)
+    print(strategy_position)
+    print(strategy_positions)
     print(order)
     if position:
         print("size(post-fee):", position.size)
@@ -91,6 +97,12 @@ with PositionWatcherService(
     
     # Optional: If you open new positions/orders and want to monitor them via HTTP fallback
     # service.add_http_listen(market_ids=["<condition_id>"], order_ids=["<order_id>"])
+    # service.set_http_listen(
+    #     market_ids=["<condition_id>"],
+    #     order_ids=["<order_id>"],
+    #     group="strategy-a",
+    # )
+    # service.clear_http(group="strategy-a")
     # service.remove_http_listen(market_ids=["<condition_id>"], order_ids=["<order_id>"])
     # service.clear_http()  # Clear all monitoring items, threads continue running
 ```
@@ -98,6 +110,8 @@ with PositionWatcherService(
 Important:
 - When `enable_fee_calc=True`, you must register market fee metadata with `set_market_fee_schedule(...)` or `set_market_fee_schedules(...)`.
 - `get_position()` does not fetch `/markets` automatically.
+- If you need strategy-level positions, use `get_position_by_order_ids(...)` or `get_positions_by_order_ids(...)`; these resolve `order.associate_trades` first and then fall back to the internal trade index built from live trades.
+- If multiple callers share one watcher, pass `group="..."` to `add_http_listen(...)`, `remove_http_listen(...)`, `set_http_listen(...)`, `set_market_http_listen(...)`, `set_order_http_listen(...)`, or `clear_http(...)` so each caller manages its own HTTP fallback namespace without overwriting others.
 - If a market is missing `feeSchedule`, fee calculation is skipped for that market and a warning is logged once.
 
 Where does `feeSchedule` come from:

{poly_position_watcher-0.3.4 → poly_position_watcher-0.3.6}/README.md

@@ -54,8 +54,14 @@ with PositionWatcherService(
 
     # Non-blocking: Get current positions and orders (returns immediately)
     position: UserPosition = service.get_position("<token_id>")
+    strategy_position: UserPosition | None = service.get_position_by_order_ids(["<order_id>"])
+    strategy_positions: dict[str, UserPosition] = service.get_positions_by_order_ids(
+        ["<order_id_1>", "<order_id_2>"]
+    )
     order: OrderMessage = service.get_order("<order_id>")
     print(position)
+    print(strategy_position)
+    print(strategy_positions)
     print(order)
     if position:
         print("size(post-fee):", position.size)
@@ -72,6 +78,12 @@ with PositionWatcherService(
     
     # Optional: If you open new positions/orders and want to monitor them via HTTP fallback
     # service.add_http_listen(market_ids=["<condition_id>"], order_ids=["<order_id>"])
+    # service.set_http_listen(
+    #     market_ids=["<condition_id>"],
+    #     order_ids=["<order_id>"],
+    #     group="strategy-a",
+    # )
+    # service.clear_http(group="strategy-a")
     # service.remove_http_listen(market_ids=["<condition_id>"], order_ids=["<order_id>"])
     # service.clear_http()  # Clear all monitoring items, threads continue running
 ```
@@ -79,6 +91,8 @@ with PositionWatcherService(
 Important:
 - When `enable_fee_calc=True`, you must register market fee metadata with `set_market_fee_schedule(...)` or `set_market_fee_schedules(...)`.
 - `get_position()` does not fetch `/markets` automatically.
+- If you need strategy-level positions, use `get_position_by_order_ids(...)` or `get_positions_by_order_ids(...)`; these resolve `order.associate_trades` first and then fall back to the internal trade index built from live trades.
+- If multiple callers share one watcher, pass `group="..."` to `add_http_listen(...)`, `remove_http_listen(...)`, `set_http_listen(...)`, `set_market_http_listen(...)`, `set_order_http_listen(...)`, or `clear_http(...)` so each caller manages its own HTTP fallback namespace without overwriting others.
 - If a market is missing `feeSchedule`, fee calculation is skipped for that market and a warning is logged once.
 
 Where does `feeSchedule` come from:

{poly_position_watcher-0.3.4 → poly_position_watcher-0.3.6}/poly_position_watcher/_version.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.4"
+__version__ = "0.3.6"

{poly_position_watcher-0.3.4 → poly_position_watcher-0.3.6}/poly_position_watcher/api_worker.py

@@ -196,34 +196,103 @@ class HttpFallbackManager:
     Manages HTTP fallback polling with persistent threads.
     Markets and orders sets can be modified dynamically while threads keep running.
     """
-    
+
+    DEFAULT_GROUP = "__default__"
+
     def __init__(self, service: "PositionWatcherService", http_poll_interval: float = 3):
         self.service = service
         self.http_poll_interval = http_poll_interval
         # Use service's existing APIWorker instance
         self.api_worker = service.api_worker
         self._slug_cache: dict[str, str] = {}
-        
-        # Thread-safe sets for markets and orders
+
+        # Thread-safe grouped monitoring state
         self._lock = threading.RLock()
-        self.markets: set[str] = set()
-        self.orders: set[str] = set()
-        
+        self.market_groups: dict[str, set[str]] = {}
+        self.order_groups: dict[str, set[str]] = {}
+
         # Thread control
         self._stop_event = threading.Event()
         self._trade_thread = None
         self._order_thread = None
         self._running = False
-    
+
+    @staticmethod
+    def _normalize_group(group: str | None) -> str:
+        return group or HttpFallbackManager.DEFAULT_GROUP
+
+    @staticmethod
+    def _clean_ids(values: list[str] | None) -> set[str]:
+        return {value for value in (values or []) if value}
+
+    def _aggregated_markets_locked(self) -> set[str]:
+        markets: set[str] = set()
+        for group_markets in self.market_groups.values():
+            markets.update(group_markets)
+        return markets
+
+    def _aggregated_orders_locked(self) -> set[str]:
+        order_ids: set[str] = set()
+        for group_orders in self.order_groups.values():
+            order_ids.update(group_orders)
+        return order_ids
+
+    def add(
+        self,
+        market_ids: list[str] = None,
+        order_ids: list[str] = None,
+        group: str | None = None,
+    ):
+        """Add markets/orders to monitor for a specific group."""
+        group_name = self._normalize_group(group)
+        with self._lock:
+            if clean_market_ids := self._clean_ids(market_ids):
+                self.market_groups.setdefault(group_name, set()).update(clean_market_ids)
+            if clean_order_ids := self._clean_ids(order_ids):
+                self.order_groups.setdefault(group_name, set()).update(clean_order_ids)
+            logger.info(
+                "Added HTTP monitoring for group {}: {} markets, {} orders",
+                group_name,
+                len(market_ids or []),
+                len(order_ids or []),
+            )
+
+    def set_group(
+        self,
+        *,
+        group: str,
+        market_ids: list[str] | None = None,
+        order_ids: list[str] | None = None,
+    ):
+        """Replace monitored markets/orders for a specific group."""
+        group_name = self._normalize_group(group)
+        clean_market_ids = self._clean_ids(market_ids)
+        clean_order_ids = self._clean_ids(order_ids)
+        with self._lock:
+            if clean_market_ids:
+                self.market_groups[group_name] = clean_market_ids
+            else:
+                self.market_groups.pop(group_name, None)
+            if clean_order_ids:
+                self.order_groups[group_name] = clean_order_ids
+            else:
+                self.order_groups.pop(group_name, None)
+            logger.info(
+                "Set HTTP monitoring group {}: {} markets, {} orders",
+                group_name,
+                len(clean_market_ids),
+                len(clean_order_ids),
+            )
+
     def start(self):
         """Start HTTP polling threads (persistent, runs until stop is called)."""
         with self._lock:
             if self._running:
                 return
-            
+
             self._stop_event.clear()
             self._running = True
-            
+
             self._trade_thread = threading.Thread(
                 target=self._trade_loop,
                 daemon=True,
@@ -232,120 +301,157 @@ class HttpFallbackManager:
                 target=self._order_loop,
                 daemon=True,
             )
-            
+
             self._trade_thread.start()
             self._order_thread.start()
             logger.info("Started HTTP fallback polling threads")
-    
+
     def stop(self):
         """Stop HTTP polling threads."""
         with self._lock:
             if not self._running:
                 return
-            
+
             self._stop_event.set()
             self._running = False
-            
+
             # Wait for threads to finish
             if self._trade_thread:
                 self._trade_thread.join(timeout=2)
             if self._order_thread:
                 self._order_thread.join(timeout=2)
-            
+
             logger.info("Stopped HTTP fallback polling threads")
-    
-    def add(self, market_ids: list[str] = None, order_ids: list[str] = None):
-        """Add markets/orders to monitor."""
-        with self._lock:
-            if market_ids:
-                self.markets.update(market_ids)
-            if order_ids:
-                self.orders.update(order_ids)
-            logger.info(f"Added HTTP monitoring: {len(market_ids or [])} markets, {len(order_ids or [])} orders")
-
-    def set_markets(self, market_ids: list[str] | None = None):
-        """Replace monitored markets with the provided list."""
+
+    def set_markets(self, market_ids: list[str] | None = None, group: str | None = None):
+        """Replace monitored markets for a specific group."""
+        group_name = self._normalize_group(group)
         with self._lock:
-            self.markets = set(market_ids or [])
-            logger.info(f"Set HTTP monitoring markets: {len(self.markets)} total")
+            clean_market_ids = self._clean_ids(market_ids)
+            if clean_market_ids:
+                self.market_groups[group_name] = clean_market_ids
+            else:
+                self.market_groups.pop(group_name, None)
+            logger.info(
+                "Set HTTP monitoring markets for group {}: {} total",
+                group_name,
+                len(clean_market_ids),
+            )
 
-    def set_orders(self, order_ids: list[str] | None = None):
-        """Replace monitored orders with the provided list."""
+    def set_orders(self, order_ids: list[str] | None = None, group: str | None = None):
+        """Replace monitored orders for a specific group."""
+        group_name = self._normalize_group(group)
         with self._lock:
-            self.orders = set(order_ids or [])
-            logger.info(f"Set HTTP monitoring orders: {len(self.orders)} total")
-    
-    def remove(self, market_ids: list[str] = None, order_ids: list[str] = None):
-        """Remove markets/orders from monitoring."""
+            clean_order_ids = self._clean_ids(order_ids)
+            if clean_order_ids:
+                self.order_groups[group_name] = clean_order_ids
+            else:
+                self.order_groups.pop(group_name, None)
+            logger.info(
+                "Set HTTP monitoring orders for group {}: {} total",
+                group_name,
+                len(clean_order_ids),
+            )
+
+    def remove(
+        self,
+        market_ids: list[str] = None,
+        order_ids: list[str] = None,
+        group: str | None = None,
+    ):
+        """Remove markets/orders from monitoring for a specific group."""
+        group_name = self._normalize_group(group)
         with self._lock:
-            if market_ids:
-                self.markets -= set(market_ids)
-            if order_ids:
-                self.orders -= set(order_ids)
-            logger.info(f"Removed HTTP monitoring: {len(market_ids or [])} markets, {len(order_ids or [])} orders")
-    
-    def clear(self):
-        """Clear all markets and orders (threads keep running)."""
+            if clean_market_ids := self._clean_ids(market_ids):
+                group_markets = self.market_groups.get(group_name)
+                if group_markets is not None:
+                    group_markets -= clean_market_ids
+                    if not group_markets:
+                        self.market_groups.pop(group_name, None)
+            if clean_order_ids := self._clean_ids(order_ids):
+                group_orders = self.order_groups.get(group_name)
+                if group_orders is not None:
+                    group_orders -= clean_order_ids
+                    if not group_orders:
+                        self.order_groups.pop(group_name, None)
+            logger.info(
+                "Removed HTTP monitoring for group {}: {} markets, {} orders",
+                group_name,
+                len(market_ids or []),
+                len(order_ids or []),
+            )
+
+    def clear(self, group: str | None = None):
+        """Clear monitoring state for one group, or all groups when group is omitted."""
         with self._lock:
-            self.markets.clear()
-            self.orders.clear()
-            logger.info("Cleared all HTTP monitoring items (threads continue running)")
-    
+            if group is None:
+                self.market_groups.clear()
+                self.order_groups.clear()
+                logger.info("Cleared all HTTP monitoring groups (threads continue running)")
+                return
+            group_name = self._normalize_group(group)
+            self.market_groups.pop(group_name, None)
+            self.order_groups.pop(group_name, None)
+            logger.info(
+                "Cleared HTTP monitoring group {} (threads continue running)",
+                group_name,
+            )
+
     def _trade_loop(self):
         """Trade polling loop - runs continuously until stopped."""
         while not self._stop_event.wait(self.http_poll_interval):
             try:
                 self._update_missing_market_slugs()
                 with self._lock:
-                    markets = list(self.markets)
-                
+                    markets = list(self._aggregated_markets_locked())
+
                 if not markets:
                     continue  # No markets to poll, continue waiting
-                
+
                 tasks = []
                 for market in markets:
                     task = executor.submit(self.api_worker.fetch_trades, market)
                     task._market_id = market
                     tasks.append(task)
-                
+
                 for task in as_completed(tasks):
                     try:
                         trades = task.result()
                     except Exception as e:
                         logger.error(f"Failed to http fetch trades market {task._market_id}: {e}")
                         continue
-                    
+
                     for trade in sorted(trades, key=lambda x: x.event_time):
                         self.service._ingest_trade(trade)
             except Exception as e:
                 logger.error(f"Error in trade loop: {e}")
-        
+
         logger.info("Trade polling loop stopped")
-    
+
     def _order_loop(self):
         """Order polling loop - runs continuously until stopped."""
         while not self._stop_event.wait(self.http_poll_interval):
             try:
                 self._update_missing_market_slugs()
                 with self._lock:
-                    order_ids = list(self.orders)
-                
+                    order_ids = list(self._aggregated_orders_locked())
+
                 if not order_ids:
                     continue  # No orders to poll, continue waiting
-                
+
                 tasks = []
                 for order_id in order_ids:
                     task = executor.submit(self.api_worker.fetch_order, order_id)
                     task._order_id = order_id
                     tasks.append(task)
-                
+
                 for task in as_completed(tasks):
                     try:
                         order = task.result()
                     except Exception as e:
                         logger.error(f"Failed to fetch order {task._order_id}: {e}")
                         continue
-                    
+
                     if order is None:
                         exists = self.service.position_store.orders.get(task._order_id)
                         if exists:
@@ -355,7 +461,7 @@ class HttpFallbackManager:
                         self.service._ingest_order(order)
             except Exception as e:
                 logger.error(f"Error in order loop: {e}")
-        
+
         logger.info("Order polling loop stopped")
 
     def _update_missing_market_slugs(self):

{poly_position_watcher-0.3.4 → poly_position_watcher-0.3.6}/poly_position_watcher/position_service.py

@@ -54,18 +54,27 @@ class PositionStore:
             if fee_schedule
         }
         self.trades_by_token: Dict[str, Dict[str, TradeMessage]] = defaultdict(dict)
+        self.trades_by_id: Dict[str, TradeMessage] = {}
+        self.trade_ids_by_order: Dict[str, set[str]] = defaultdict(set)
         self.positions: Dict[str, UserPosition] = {}
         self.orders: Dict[str, OrderMessage] = {}
         self._warned_failed_trade_keys: set[tuple[str, str]] = set()
         self._lock = threading.RLock()
         self.queue_dict: Dict[str, Queue] = {}
 
-    def get_token_id_from_trade(self, trade: TradeMessage) -> tuple[str, str] | None:
-        if trade.maker_address.upper() == self.user_address.upper():
-            return trade.outcome, trade.asset_id
+    def _is_user_outer_trade(self, trade: TradeMessage) -> bool:
+        return trade.maker_address.upper() == self.user_address.upper()
+
+    def _iter_user_maker_orders(self, trade: TradeMessage):
         for order in trade.maker_orders:
             if order.maker_address.upper() == self.user_address.upper():
-                return order.outcome, order.asset_id
+                yield order
+
+    def get_token_id_from_trade(self, trade: TradeMessage) -> tuple[str, str] | None:
+        if self._is_user_outer_trade(trade):
+            return trade.outcome, trade.asset_id
+        for order in self._iter_user_maker_orders(trade):
+            return order.outcome, order.asset_id
 
     def _put(self, _id: str, item: UserPosition | OrderMessage) -> None:
         if _id not in self.queue_dict:
@@ -99,8 +108,10 @@ class PositionStore:
             existing = trades_map.get(trade.id)
             if existing and trade.event_time < existing.event_time:
                 return
-            else:
-                trades_map[trade.id] = trade
+            if existing:
+                self._remove_trade_indexes(existing)
+            trades_map[trade.id] = trade
+            self._index_trade(trade)
             user_pos = self.build_position(
                 trades=list(trades_map.values()), token_id=token_id, outcome=outcome
             )
@@ -120,7 +131,10 @@ class PositionStore:
             outcome, token_id = result
             trades_map = self.trades_by_token[token_id]
             for trade in trades:
+                if existing := trades_map.get(trade.id):
+                    self._remove_trade_indexes(existing)
                 trades_map[trade.id] = trade
+                self._index_trade(trade)
             user_pos = self.build_position(
                 trades=list(trades_map.values()), token_id=token_id, outcome=outcome
             )
@@ -141,7 +155,10 @@ class PositionStore:
                 and order.status == existing.status
             ):
                 return
-            if abs(order.size_matched - order.original_size) < 0.5:
+            if (
+                order.original_size is not None
+                and abs(order.size_matched - order.original_size) < 0.5
+            ):
                 order.filled = True
             self.orders[order.id] = order
             self._put(order.id, order)
@@ -190,9 +207,43 @@ class PositionStore:
             self.positions[token_id] = user_pos
             self._put(token_id, user_pos)
 
-    def build_position(
-        self, trades: list[TradeMessage], token_id, outcome: str
+    def _iter_user_order_ids_for_trade(self, trade: TradeMessage):
+        if self._is_user_outer_trade(trade) and trade.taker_order_id:
+            yield trade.taker_order_id
+        for order in self._iter_user_maker_orders(trade):
+            yield order.order_id
+
+    def _index_trade(self, trade: TradeMessage) -> None:
+        self.trades_by_id[trade.id] = trade
+        for order_id in self._iter_user_order_ids_for_trade(trade):
+            if order_id:
+                self.trade_ids_by_order[order_id].add(trade.id)
+
+    def _remove_trade_indexes(self, trade: TradeMessage) -> None:
+        existing = self.trades_by_id.get(trade.id)
+        if existing is trade or existing is not None:
+            self.trades_by_id.pop(trade.id, None)
+        for order_id in self._iter_user_order_ids_for_trade(trade):
+            if not order_id:
+                continue
+            trade_ids = self.trade_ids_by_order.get(order_id)
+            if not trade_ids:
+                continue
+            trade_ids.discard(trade.id)
+            if not trade_ids:
+                self.trade_ids_by_order.pop(order_id, None)
+
+    def _build_user_position(
+        self,
+        trades: list[TradeMessage],
+        token_id: str,
+        outcome: str,
+        *,
+        warn_failed: bool,
     ) -> UserPosition | None:
+        if not trades:
+            return None
+
         def _status_is(trade: TradeMessage, status: TradeStatus) -> bool:
             return trade.status == status or trade.status == status.value
 
@@ -202,22 +253,23 @@ class PositionStore:
             i for i in success_trades if _status_is(i, TradeStatus.CONFIRMED)
         ]
         has_failed = bool(len(failed_trades))
-        new_failed_trades = [
-            trade
-            for trade in failed_trades
-            if (token_id, trade.id) not in self._warned_failed_trade_keys
-        ]
-        if new_failed_trades:
-            self._warned_failed_trade_keys.update(
-                (token_id, trade.id) for trade in new_failed_trades
-            )
-            failed_size = sum(i.size for i in new_failed_trades)
-            failed_trade_ids = [trade.id for trade in new_failed_trades]
-            logger.warning(
-                "Found failed trades, total size: {}, ids: {}",
-                failed_size,
-                failed_trade_ids,
-            )
+        if warn_failed:
+            new_failed_trades = [
+                trade
+                for trade in failed_trades
+                if (token_id, trade.id) not in self._warned_failed_trade_keys
+            ]
+            if new_failed_trades:
+                self._warned_failed_trade_keys.update(
+                    (token_id, trade.id) for trade in new_failed_trades
+                )
+                failed_size = sum(i.size for i in new_failed_trades)
+                failed_trade_ids = [trade.id for trade in new_failed_trades]
+                logger.warning(
+                    "Found failed trades, total size: {}, ids: {}",
+                    failed_size,
+                    failed_trade_ids,
+                )
         market_slug = next(
             (trade.market_slug for trade in trades if trade.market_slug), ""
         )
@@ -238,7 +290,7 @@ class PositionStore:
                 fee_calc_fn=self.fee_calc_fn,
             )
             sellable_size = confirmed_result.size
-        current = UserPosition(
+        return UserPosition(
             price=position_result.avg_price,
             size=position_result.size,
             original_size=position_result.original_size,
@@ -258,7 +310,16 @@ class PositionStore:
             market_slug=market_slug,
             failed_trades=failed_trades,
         )
-        return current
+
+    def build_position(
+        self, trades: list[TradeMessage], token_id, outcome: str
+    ) -> UserPosition | None:
+        return self._build_user_position(
+            trades=trades,
+            token_id=token_id,
+            outcome=outcome,
+            warn_failed=True,
+        )
         # if exists_pos := self.positions.get(token_id):
         #     if exists_pos.last_update < current.last_update:
         #         return current
@@ -278,6 +339,53 @@ class PositionStore:
     def get_order_by_id(self, order_id: str) -> OrderMessage:
         return self.orders.get(order_id)
 
+    def get_positions_by_order_ids(
+        self, order_ids: list[str]
+    ) -> Dict[str, UserPosition]:
+        with self._lock:
+            trade_ids: set[str] = set()
+            for order_id in order_ids:
+                if order := self.orders.get(order_id):
+                    trade_ids.update(order.associate_trades or [])
+                trade_ids.update(self.trade_ids_by_order.get(order_id, set()))
+
+            grouped_trades: Dict[str, list[TradeMessage]] = defaultdict(list)
+            outcomes: Dict[str, str] = {}
+            for trade_id in trade_ids:
+                trade = self.trades_by_id.get(trade_id)
+                if trade is None:
+                    continue
+                result = self.get_token_id_from_trade(trade)
+                if result is None:
+                    continue
+                outcome, token_id = result
+                grouped_trades[token_id].append(trade)
+                outcomes[token_id] = outcome
+
+            positions: Dict[str, UserPosition] = {}
+            for token_id, trades in grouped_trades.items():
+                position = self._build_user_position(
+                    trades=trades,
+                    token_id=token_id,
+                    outcome=outcomes[token_id],
+                    warn_failed=False,
+                )
+                if position is not None:
+                    positions[token_id] = position
+            return positions
+
+    def get_position_by_order_ids(
+        self, order_ids: list[str]
+    ) -> UserPosition | None:
+        positions = self.get_positions_by_order_ids(order_ids)
+        if not positions:
+            return None
+        if len(positions) > 1:
+            raise ValueError(
+                "order_ids resolve to multiple token positions; use get_positions_by_order_ids instead."
+            )
+        return next(iter(positions.values()))
+
     def blocking_get_token_position(
         self, token_id: str, timeout: float = None
     ) -> UserPosition:
@@ -662,6 +770,16 @@ class PositionWatcherService:
     def get_order(self, order_id: str) -> OrderMessage:
         return self.position_store.get_order_by_id(order_id)
 
+    def get_positions_by_order_ids(
+        self, order_ids: list[str]
+    ) -> Dict[str, UserPosition]:
+        return self.position_store.get_positions_by_order_ids(order_ids)
+
+    def get_position_by_order_ids(
+        self, order_ids: list[str]
+    ) -> UserPosition | None:
+        return self.position_store.get_position_by_order_ids(order_ids)
+
     def blocking_get_position(
         self, token_id: str, timeout: float = None
     ) -> UserPosition | None:
@@ -689,14 +807,20 @@ class PositionWatcherService:
     # -------------------------------------------------------------------------
     # HTTP Fallback Management (delegates to HttpFallbackManager)
     # -------------------------------------------------------------------------
+    DEFAULT_HTTP_LISTEN_GROUP = HttpFallbackManager.DEFAULT_GROUP
+
     def add_http_listen(
-        self, order_ids: list[str] = None, market_ids: list[str] = None
+        self,
+        order_ids: list[str] = None,
+        market_ids: list[str] = None,
+        group: str = DEFAULT_HTTP_LISTEN_GROUP,
     ):
         """
         Add markets/orders to HTTP fallback polling.
 
         :param order_ids: List of order IDs to monitor
         :param market_ids: List of market (condition) IDs to monitor
+        :param group: Optional namespace/group name for this caller
         """
         if not self.enable_http_fallback or not self._http_fallback:
             logger.warning(
@@ -704,47 +828,101 @@ class PositionWatcherService:
             )
             return
 
-        self._http_fallback.add(market_ids=market_ids, order_ids=order_ids)
+        self._http_fallback.add(
+            market_ids=market_ids,
+            order_ids=order_ids,
+            group=group,
+        )
 
     def remove_http_listen(
-        self, order_ids: list[str] = None, market_ids: list[str] = None
+        self,
+        order_ids: list[str] = None,
+        market_ids: list[str] = None,
+        group: str = DEFAULT_HTTP_LISTEN_GROUP,
     ):
         """
         Remove markets/orders from HTTP fallback polling.
 
         :param order_ids: List of order IDs to remove
         :param market_ids: List of market (condition) IDs to remove
+        :param group: Optional namespace/group name for this caller
+        """
+        if not self.enable_http_fallback or not self._http_fallback:
+            return
+
+        self._http_fallback.remove(
+            market_ids=market_ids,
+            order_ids=order_ids,
+            group=group,
+        )
+
+    def set_http_listen(
+        self,
+        order_ids: list[str] = None,
+        market_ids: list[str] = None,
+        group: str = DEFAULT_HTTP_LISTEN_GROUP,
+    ):
+        """
+        Replace HTTP fallback monitoring for one group atomically.
+
+        :param order_ids: List of order IDs to monitor
+        :param market_ids: List of market (condition) IDs to monitor
+        :param group: Optional namespace/group name for this caller
         """
         if not self.enable_http_fallback or not self._http_fallback:
             return
 
-        self._http_fallback.remove(market_ids=market_ids, order_ids=order_ids)
+        self._http_fallback.set_group(
+            group=group,
+            market_ids=market_ids,
+            order_ids=order_ids,
+        )
 
-    def set_market_http_listen(self, market_ids: list[str] = None):
+    def set_market_http_listen(
+        self,
+        market_ids: list[str] = None,
+        group: str = DEFAULT_HTTP_LISTEN_GROUP,
+    ):
         """
         Replace HTTP fallback market monitoring list.
 
         :param market_ids: List of market (condition) IDs to monitor
+        :param group: Optional namespace/group name for this caller
         """
         if not self.enable_http_fallback or not self._http_fallback:
             return
 
-        self._http_fallback.set_markets(market_ids=market_ids)
+        self._http_fallback.set_markets(
+            market_ids=market_ids,
+            group=group,
+        )
 
-    def set_order_http_listen(self, order_ids: list[str] = None):
+    def set_order_http_listen(
+        self,
+        order_ids: list[str] = None,
+        group: str = DEFAULT_HTTP_LISTEN_GROUP,
+    ):
         """
         Replace HTTP fallback order monitoring list.
 
         :param order_ids: List of order IDs to monitor
+        :param group: Optional namespace/group name for this caller
         """
         if not self.enable_http_fallback or not self._http_fallback:
             return
 
-        self._http_fallback.set_orders(order_ids=order_ids)
+        self._http_fallback.set_orders(
+            order_ids=order_ids,
+            group=group,
+        )
+
+    def clear_http(self, group: str | None = None):
+        """
+        Clear HTTP fallback monitoring.
 
-    def clear_http(self):
-        """Clear all HTTP fallback monitoring (threads keep running)."""
+        :param group: When provided, clear only that group; otherwise clear all groups.
+        """
         if not self.enable_http_fallback or not self._http_fallback:
             return
 
-        self._http_fallback.clear()
+        self._http_fallback.clear(group=group)

{poly_position_watcher-0.3.4 → poly_position_watcher-0.3.6/poly_position_watcher.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poly-position-watcher
-Version: 0.3.4
+Version: 0.3.6
 Summary: polymarket proxy wallet redeem
 Home-page: https://github.com/tosmart01/polymarket-position-watcher
 Author: pinbar
@@ -73,8 +73,14 @@ with PositionWatcherService(
 
     # Non-blocking: Get current positions and orders (returns immediately)
     position: UserPosition = service.get_position("<token_id>")
+    strategy_position: UserPosition | None = service.get_position_by_order_ids(["<order_id>"])
+    strategy_positions: dict[str, UserPosition] = service.get_positions_by_order_ids(
+        ["<order_id_1>", "<order_id_2>"]
+    )
     order: OrderMessage = service.get_order("<order_id>")
     print(position)
+    print(strategy_position)
+    print(strategy_positions)
     print(order)
     if position:
         print("size(post-fee):", position.size)
@@ -91,6 +97,12 @@ with PositionWatcherService(
     
     # Optional: If you open new positions/orders and want to monitor them via HTTP fallback
     # service.add_http_listen(market_ids=["<condition_id>"], order_ids=["<order_id>"])
+    # service.set_http_listen(
+    #     market_ids=["<condition_id>"],
+    #     order_ids=["<order_id>"],
+    #     group="strategy-a",
+    # )
+    # service.clear_http(group="strategy-a")
     # service.remove_http_listen(market_ids=["<condition_id>"], order_ids=["<order_id>"])
     # service.clear_http()  # Clear all monitoring items, threads continue running
 ```
@@ -98,6 +110,8 @@ with PositionWatcherService(
 Important:
 - When `enable_fee_calc=True`, you must register market fee metadata with `set_market_fee_schedule(...)` or `set_market_fee_schedules(...)`.
 - `get_position()` does not fetch `/markets` automatically.
+- If you need strategy-level positions, use `get_position_by_order_ids(...)` or `get_positions_by_order_ids(...)`; these resolve `order.associate_trades` first and then fall back to the internal trade index built from live trades.
+- If multiple callers share one watcher, pass `group="..."` to `add_http_listen(...)`, `remove_http_listen(...)`, `set_http_listen(...)`, `set_market_http_listen(...)`, `set_order_http_listen(...)`, or `clear_http(...)` so each caller manages its own HTTP fallback namespace without overwriting others.
 - If a market is missing `feeSchedule`, fee calculation is skipped for that market and a warning is logged once.
 
 Where does `feeSchedule` come from:

{poly_position_watcher-0.3.4 → poly_position_watcher-0.3.6}/poly_position_watcher.egg-info/SOURCES.txt

@@ -21,5 +21,6 @@ poly_position_watcher/schema/__init__.py
 poly_position_watcher/schema/base.py
 poly_position_watcher/schema/common_model.py
 poly_position_watcher/schema/position_model.py
+tests/test_http_fallback_manager.py
 tests/test_position_model.py
 tests/test_trade_calculator.py

{poly_position_watcher-0.3.4 → poly_position_watcher-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "poly-position-watcher"
-version = "0.3.4"
+version = "0.3.6"
 description = "polymarket proxy wallet redeem"
 readme = "README.md"
 requires-python = ">=3.11"

poly_position_watcher-0.3.6/tests/test_http_fallback_manager.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import unittest
+
+from poly_position_watcher.api_worker import APIWorker, HttpFallbackManager
+
+
+class DummyPositionStore:
+    positions = {}
+    orders = {}
+
+
+class DummyService:
+    def __init__(self) -> None:
+        self.api_worker = object()
+        self.position_store = DummyPositionStore()
+
+
+class HttpFallbackManagerTests(unittest.TestCase):
+    def test_default_group_keeps_old_api_compatible(self) -> None:
+        manager = HttpFallbackManager(DummyService(), http_poll_interval=1)
+
+        manager.add(market_ids=["market-1"], order_ids=["order-1"])
+
+        self.assertEqual(
+            manager.market_groups[HttpFallbackManager.DEFAULT_GROUP],
+            {"market-1"},
+        )
+        self.assertEqual(
+            manager.order_groups[HttpFallbackManager.DEFAULT_GROUP],
+            {"order-1"},
+        )
+
+    def test_group_sets_are_aggregated_across_namespaces(self) -> None:
+        manager = HttpFallbackManager(DummyService(), http_poll_interval=1)
+
+        manager.set_group(group="strategy-a", market_ids=["market-a"], order_ids=["order-a"])
+        manager.set_group(group="strategy-b", market_ids=["market-b"], order_ids=["order-b"])
+
+        self.assertEqual(manager._aggregated_markets_locked(), {"market-a", "market-b"})
+        self.assertEqual(manager._aggregated_orders_locked(), {"order-a", "order-b"})
+
+    def test_clear_one_group_does_not_affect_others(self) -> None:
+        manager = HttpFallbackManager(DummyService(), http_poll_interval=1)
+
+        manager.set_group(group="strategy-a", market_ids=["market-a"], order_ids=["order-a"])
+        manager.set_group(group="strategy-b", market_ids=["market-b"], order_ids=["order-b"])
+        manager.clear(group="strategy-a")
+
+        self.assertNotIn("strategy-a", manager.market_groups)
+        self.assertNotIn("strategy-a", manager.order_groups)
+        self.assertEqual(manager.market_groups["strategy-b"], {"market-b"})
+        self.assertEqual(manager.order_groups["strategy-b"], {"order-b"})
+
+    def test_remove_only_touches_target_group(self) -> None:
+        manager = HttpFallbackManager(DummyService(), http_poll_interval=1)
+
+        manager.add(group="strategy-a", market_ids=["market-a"], order_ids=["order-a"])
+        manager.add(group="strategy-b", market_ids=["market-a"], order_ids=["order-a"])
+        manager.remove(group="strategy-a", market_ids=["market-a"], order_ids=["order-a"])
+
+        self.assertNotIn("strategy-a", manager.market_groups)
+        self.assertNotIn("strategy-a", manager.order_groups)
+        self.assertEqual(manager.market_groups["strategy-b"], {"market-a"})
+        self.assertEqual(manager.order_groups["strategy-b"], {"order-a"})
+
+
+if __name__ == "__main__":
+    unittest.main()

poly_position_watcher-0.3.6/tests/test_position_model.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from poly_position_watcher.position_service import PositionStore
+from poly_position_watcher.schema.position_model import OrderMessage, TradeMessage, UserPosition
+
+
+def build_trade(trade_id: str, status: str = "FAILED", size: float = 10.0) -> TradeMessage:
+    return TradeMessage(
+        type="TRADE",
+        event_type="trade",
+        asset_id="0xtoken",
+        id=trade_id,
+        maker_orders=[],
+        transaction_hash=f"0xhash-{trade_id}",
+        market="0xmarket",
+        maker_address="0xuser",
+        outcome="YES",
+        owner="0xuser",
+        price=0.25,
+        side="BUY",
+        size=size,
+        status=status,
+        taker_order_id=f"0xorder-{trade_id}",
+        timestamp=1,
+        match_time=1,
+        last_update=1,
+        trade_owner="0xuser",
+        trader_side="TAKER",
+        fee_rate_bps=0,
+        market_slug="test-market",
+    )
+
+
+def build_order(
+    order_id: str,
+    *,
+    asset_id: str = "0xtoken",
+    associate_trades: list[str] | None = None,
+) -> OrderMessage:
+    return OrderMessage(
+        type="update",
+        event_type="order",
+        asset_id=asset_id,
+        associate_trades=associate_trades,
+        id=order_id,
+        market="0xmarket",
+        outcome="YES",
+        owner="0xuser",
+        price=0.25,
+        side="BUY",
+        size_matched=10.0,
+        timestamp=1,
+        status="LIVE",
+        market_slug="test-market",
+    )
+
+
+class UserPositionTests(unittest.TestCase):
+    def test_failed_trade_ids_are_exposed_in_string_output(self) -> None:
+        position = UserPosition(
+            price=0.25,
+            size=10.0,
+            original_size=10.0,
+            volume=2.5,
+            fee_amount=0.0,
+            sellable_size=10.0,
+            token_id="0xtoken",
+            last_update=1,
+            market_id="0xmarket",
+            outcome="YES",
+            has_failed=True,
+            failed_trades=[build_trade("failed-1"), build_trade("failed-2")],
+        )
+
+        self.assertEqual(position.failed_trade_ids, ["failed-1", "failed-2"])
+        rendered = str(position)
+        self.assertIn("failed_trades: ['failed-1', 'failed-2']", rendered)
+        self.assertNotIn("transaction_hash", rendered)
+
+    def test_failed_trade_warning_logs_once_per_token_and_trade_id(self) -> None:
+        store = PositionStore(user_address="0xuser")
+        trades = [
+            build_trade("confirmed-1", status="CONFIRMED", size=5.0),
+            build_trade("failed-1", status="FAILED", size=10.0),
+        ]
+
+        with patch("poly_position_watcher.position_service.logger.warning") as warning:
+            store.build_position(trades=trades, token_id="0xtoken", outcome="YES")
+            store.build_position(trades=trades, token_id="0xtoken", outcome="YES")
+
+        warning.assert_called_once_with(
+            "Found failed trades, total size: {}, ids: {}",
+            10.0,
+            ["failed-1"],
+        )
+
+    def test_get_position_by_order_ids_uses_order_trade_links(self) -> None:
+        store = PositionStore(user_address="0xuser")
+        trade_a = build_trade("trade-a", status="CONFIRMED", size=3.0)
+        trade_a.taker_order_id = "order-a"
+        trade_b = build_trade("trade-b", status="CONFIRMED", size=5.0)
+        trade_b.taker_order_id = "order-b"
+        store.append_trade(trade_a)
+        store.append_trade(trade_b)
+        store.append_order(build_order("order-a", associate_trades=["trade-a"]))
+        store.append_order(build_order("order-b", associate_trades=["trade-b"]))
+
+        position_a = store.get_position_by_order_ids(["order-a"])
+        combined_positions = store.get_positions_by_order_ids(["order-a", "order-b"])
+
+        self.assertIsNotNone(position_a)
+        self.assertEqual(position_a.token_id, "0xtoken")
+        self.assertEqual(position_a.size, 3.0)
+        self.assertIn("0xtoken", combined_positions)
+        self.assertEqual(combined_positions["0xtoken"].size, 8.0)
+
+    def test_get_position_by_order_ids_falls_back_to_trade_index_when_order_missing_associate_trades(self) -> None:
+        store = PositionStore(user_address="0xuser")
+        trade = build_trade("trade-a", status="CONFIRMED", size=4.0)
+        trade.taker_order_id = "order-a"
+        store.append_trade(trade)
+        store.append_order(build_order("order-a", associate_trades=None))
+
+        position = store.get_position_by_order_ids(["order-a"])
+
+        self.assertIsNotNone(position)
+        self.assertEqual(position.size, 4.0)
+
+    def test_trade_index_only_uses_current_user_related_order_ids(self) -> None:
+        store = PositionStore(user_address="0xuser")
+        trade = TradeMessage(
+            type="TRADE",
+            event_type="trade",
+            asset_id="0xup-token",
+            id="trade-realistic",
+            maker_orders=[
+                {
+                    "order_id": "irrelevant-order-1",
+                    "owner": "other-owner",
+                    "maker_address": "0xother1",
+                    "matched_amount": "20",
+                    "price": "0.45",
+                    "fee_rate_bps": "1000",
+                    "asset_id": "0xdown-token",
+                    "outcome": "Down",
+                    "side": "BUY",
+                },
+                {
+                    "order_id": "user-maker-order",
+                    "owner": "user-owner",
+                    "maker_address": "0xuser",
+                    "matched_amount": "6",
+                    "price": "0.55",
+                    "fee_rate_bps": "1000",
+                    "asset_id": "0xup-token",
+                    "outcome": "Up",
+                    "side": "SELL",
+                },
+                {
+                    "order_id": "irrelevant-order-2",
+                    "owner": "other-owner-2",
+                    "maker_address": "0xother2",
+                    "matched_amount": "40",
+                    "price": "0.41",
+                    "fee_rate_bps": "1000",
+                    "asset_id": "0xdown-token",
+                    "outcome": "Down",
+                    "side": "BUY",
+                },
+            ],
+            transaction_hash="0xhash-realistic",
+            market="0xmarket",
+            maker_address="0xouter-not-user",
+            outcome="Up",
+            owner="outer-owner",
+            price=0.59,
+            side="BUY",
+            size=6.0,
+            status="CONFIRMED",
+            taker_order_id="outer-taker-order",
+            timestamp=1,
+            match_time=1,
+            last_update=1,
+            trade_owner="outer-owner",
+            trader_side="MAKER",
+            fee_rate_bps=1000,
+            market_slug="test-market",
+        )
+        store.append_trade(trade)
+
+        self.assertEqual(store.get_position_by_order_ids(["user-maker-order"]).size, -6.0)
+        self.assertIsNone(store.get_position_by_order_ids(["irrelevant-order-1"]))
+        self.assertIsNone(store.get_position_by_order_ids(["irrelevant-order-2"]))
+        self.assertIsNone(store.get_position_by_order_ids(["outer-taker-order"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

poly_position_watcher-0.3.4/tests/test_position_model.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-import unittest
-from unittest.mock import patch
-
-from poly_position_watcher.position_service import PositionStore
-from poly_position_watcher.schema.position_model import TradeMessage, UserPosition
-
-
-def build_trade(trade_id: str, status: str = "FAILED", size: float = 10.0) -> TradeMessage:
-    return TradeMessage(
-        type="TRADE",
-        event_type="trade",
-        asset_id="0xtoken",
-        id=trade_id,
-        maker_orders=[],
-        transaction_hash=f"0xhash-{trade_id}",
-        market="0xmarket",
-        maker_address="0xuser",
-        outcome="YES",
-        owner="0xuser",
-        price=0.25,
-        side="BUY",
-        size=size,
-        status=status,
-        taker_order_id=f"0xorder-{trade_id}",
-        timestamp=1,
-        match_time=1,
-        last_update=1,
-        trade_owner="0xuser",
-        trader_side="TAKER",
-        fee_rate_bps=0,
-        market_slug="test-market",
-    )
-
-
-class UserPositionTests(unittest.TestCase):
-    def test_failed_trade_ids_are_exposed_in_string_output(self) -> None:
-        position = UserPosition(
-            price=0.25,
-            size=10.0,
-            original_size=10.0,
-            volume=2.5,
-            fee_amount=0.0,
-            sellable_size=10.0,
-            token_id="0xtoken",
-            last_update=1,
-            market_id="0xmarket",
-            outcome="YES",
-            has_failed=True,
-            failed_trades=[build_trade("failed-1"), build_trade("failed-2")],
-        )
-
-        self.assertEqual(position.failed_trade_ids, ["failed-1", "failed-2"])
-        rendered = str(position)
-        self.assertIn("failed_trades: ['failed-1', 'failed-2']", rendered)
-        self.assertNotIn("transaction_hash", rendered)
-
-    def test_failed_trade_warning_logs_once_per_token_and_trade_id(self) -> None:
-        store = PositionStore(user_address="0xuser")
-        trades = [
-            build_trade("confirmed-1", status="CONFIRMED", size=5.0),
-            build_trade("failed-1", status="FAILED", size=10.0),
-        ]
-
-        with patch("poly_position_watcher.position_service.logger.warning") as warning:
-            store.build_position(trades=trades, token_id="0xtoken", outcome="YES")
-            store.build_position(trades=trades, token_id="0xtoken", outcome="YES")
-
-        warning.assert_called_once_with(
-            "Found failed trades, total size: {}, ids: {}",
-            10.0,
-            ["failed-1"],
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()