poly-position-watcher 0.1.0__py3-none-any.whl

poly_position_watcher/wss_worker.py

@@ -0,0 +1,460 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/1 16:16
+# @Author: pinbar
+# @Site:
+# @File: wss.py
+# @Software: PyCharm
+import json
+import threading
+import time
+from typing import Callable, List, Optional
+
+import requests
+
+from websocket import WebSocketApp, WebSocket
+
+from poly_position_watcher.common.enums import MarketEvent
+from poly_position_watcher.common.logger import logger
+from poly_position_watcher.schema.common_model import OrderBookSummary
+
+WSS_URL = "wss://ws-subscriptions-clob.polymarket.com"
+MARKET_CHANNEL = "market"
+USER_CHANNEL = "user"
+
+
+def json_dumps(msg: dict) -> str:
+    return json.dumps(msg, indent=4, ensure_ascii=False)
+
+
+def fetch_order_books(asset_ids: list[str]) -> list[OrderBookSummary]:
+    """
+    Fetch an initial snapshot for every asset id before subscribing to the WS stream.
+    """
+    if not asset_ids:
+        return []
+    url = "https://clob.polymarket.com/books"
+    payload = [{"token_id": token_id} for token_id in asset_ids]
+    response = requests.post(
+        url, json=payload, headers={"Content-Type": "application/json"}
+    )
+    response.raise_for_status()
+    books = response.json()
+    return [OrderBookSummary(**book) for book in books]
+
+
+class PolymarketUserWS:
+    def __init__(
+        self,
+        api_key: str,
+        api_secret: str,
+        api_passphrase: str,
+        markets: Optional[List[str]] = None,
+        ping_interval: int = 10,
+        ping_timeout: int = 6,
+        idle_timeout: Optional[int] = 60 * 60,
+        reconnect_delay: int = 5,
+        on_message_callback: Optional[Callable[[dict], None]] = None,
+        wss_proxies: Optional[dict] = None,
+    ):
+        """
+        :param markets: 订阅的 condition_ids 列表，为 None 或 [] 时表示订阅全部（视后端协议而定）
+        :param ping_interval: WebSocket 库自带 PING 间隔（秒）
+        :param ping_timeout: WebSocket 库自带 PONG 超时时间（秒），超过这个时间视为连接异常
+        :param idle_timeout: 业务层“长时间没有任意消息”的超时（秒）；为 None / 0 时关闭此功能
+        :param reconnect_delay: 断线后重连间隔（秒）
+        :param on_message_callback: 收到业务消息时的回调函数，参数为 dict
+        """
+        self.api_key = api_key
+        self.api_secret = api_secret
+        self.api_passphrase = api_passphrase
+        self.markets = markets or []
+
+        self.ping_interval = ping_interval
+        self.ping_timeout = ping_timeout
+        self.idle_timeout = idle_timeout
+        self.reconnect_delay = reconnect_delay
+
+        self.on_message_callback = on_message_callback
+        self._wss_proxies = wss_proxies or {}
+
+        self.ws: Optional[WebSocketApp] = None
+        self._stop = False
+
+        # 业务消息 / 任意消息的最近活跃时间
+        self._last_activity = time.time()
+
+        # 监控“长时间无消息”的线程
+        self._monitor_thread: Optional[threading.Thread] = None
+        self._monitor_stop_evt = threading.Event()
+
+    # ---------- 公共方法 ----------
+
+    def start(self):
+        """
+        阻塞运行，带自动重连。
+        使用 websocket-client 自带 ping/pong（ping_interval & ping_timeout）。
+        """
+        while not self._stop:
+            try:
+                logger.info("[WS] Connecting...")
+
+                self.ws = WebSocketApp(
+                    f"{WSS_URL}/ws/user",
+                    on_open=self._on_open,
+                    on_message=self._on_message,
+                    on_error=self._on_error,
+                    on_close=self._on_close,
+                )
+
+                # 每次新连接重置最近活跃时间
+                self._last_activity = time.time()
+                self._monitor_stop_evt.clear()
+
+                # 如果配置了 idle_timeout，则启动一个监控线程
+                if self.idle_timeout and self.idle_timeout > 0:
+                    self._monitor_thread = threading.Thread(
+                        target=self._activity_monitor_loop,
+                        daemon=True,
+                    )
+                    self._monitor_thread.start()
+                else:
+                    self._monitor_thread = None
+
+                # 这里使用库自带的 ping_interval / ping_timeout，负责底层心跳与超时
+                self.ws.run_forever(
+                    **self._wss_proxies,
+                    ping_interval=self.ping_interval,
+                    ping_timeout=self.ping_timeout,
+                )
+
+            except Exception as e:
+                logger.exception("[WS] run_forever error:")
+
+            # 当前连接生命周期结束，停止监控线程
+            self._monitor_stop_evt.set()
+            if self._monitor_thread and self._monitor_thread.is_alive():
+                self._monitor_thread.join(timeout=1)
+
+            if self._stop:
+                break
+
+            logger.info(
+                f"[WS] Disconnected, reconnecting in {self.reconnect_delay}s..."
+            )
+            time.sleep(self.reconnect_delay)
+
+    def stop(self):
+        """
+        手动停止
+        """
+        self._stop = True
+        self._monitor_stop_evt.set()
+        if self.ws:
+            try:
+                self.ws.close()
+            except Exception:
+                pass
+
+    def _on_open(self, ws: WebSocket):
+        logger.info("[WS] Opened")
+
+        auth = {
+            "apiKey": self.api_key,
+            "secret": self.api_secret,
+            "passphrase": self.api_passphrase,
+        }
+
+        sub_msg = {
+            "type": "USER",  # 文档要求 - 订阅 user channel
+            "auth": auth,
+        }
+
+        if self.markets:
+            sub_msg["markets"] = self.markets
+        else:
+            sub_msg["markets"] = []
+
+        ws.send(json.dumps(sub_msg))
+        logger.info("[WS] Sent subscribe: \n{}", json_dumps(sub_msg))
+
+    def _on_message(self, ws: WebSocket, message: str):
+        # 收到任何消息都视为有“活跃”
+        self._last_activity = time.time()
+
+        # 对方如果返回的是纯文本心跳，可在这里过滤
+        # 但 websocket-client 的 ping/pong 是底层帧，不会走到这里
+        if str(message) == "PONG":
+            return
+
+        try:
+            data = json.loads(message)
+        except json.JSONDecodeError:
+            # 对于非 JSON 消息，按需处理或直接打印
+            logger.warning("[WS] Non-JSON message: {}", message)
+            return
+
+        if self.on_message_callback:
+            try:
+                self.on_message_callback(data)
+            except Exception as e:
+                logger.exception("[WS] on_message_callback error:")
+
+    def _on_error(self, ws: WebSocket, error):
+        logger.error("[WS] Error: {}", error)
+        # 出现错误时关闭连接，交给外层循环重连
+        try:
+            ws.close()
+        except Exception:
+            pass
+
+    def _on_close(self, ws: WebSocket, close_status_code, close_msg):
+        logger.info(f"[WS] Closed: code={close_status_code}, msg={close_msg}")
+
+    # ---------- 业务层“长时间无消息”监控 ----------
+
+    def _activity_monitor_loop(self):
+        """
+        仅在配置了 idle_timeout 时启用：
+        如果长时间（idle_timeout 秒）没有收到任何消息，则主动关闭连接，
+        交由外层循环进行重连。
+        """
+        while not self._monitor_stop_evt.is_set():
+            now = time.time()
+            if now - self._last_activity > self.idle_timeout:
+                logger.info(
+                    f"[WS] No activity for {self.idle_timeout}s, "
+                    f"closing connection to force reconnect..."
+                )
+                try:
+                    if self.ws:
+                        self.ws.close()
+                except Exception:
+                    pass
+                # 触发一次关闭即可，退出监控线程
+                break
+
+            # 等待 1 秒再检查，可按需要调整粒度
+            self._monitor_stop_evt.wait(1)
+
+
+class OrderBookWS:
+    def __init__(
+        self,
+        asset_ids: list[str],
+        url: str = "wss://ws-subscriptions-clob.polymarket.com",
+        event_name: str = "",
+        ping_interval: int = 10,
+        ping_timeout: int = 6,  # 如需用 websocket 内建 ping，可通过 run_forever 传入
+        idle_timeout: Optional[int] = 60 * 60,
+        reconnect_delay: int = 5,
+        callback: Callable = None,
+        wss_proxies: Optional[dict] = None,
+    ):
+        """
+        :param asset_ids: 订阅的 asset_id 列表
+        :param url: 基础 ws url
+        :param event_name: 日志里的事件名，仅用于调试
+        :param ping_interval: 自定义业务层 "PING" 间隔（秒）
+        :param ping_timeout: 预留，如果想用 websocket 内建 ping/pong，可透传给 run_forever
+        :param idle_timeout: 若长时间未收到任何消息（秒），则主动断开重连；为 None/0 表示关闭
+        :param reconnect_delay: 断线后重连间隔（秒）
+        """
+        self.url = url
+        self.asset_ids = asset_ids
+        self.event_name = event_name
+
+        self.ping_interval = ping_interval
+        self.ping_timeout = ping_timeout
+        self.idle_timeout = idle_timeout
+        self.reconnect_delay = reconnect_delay
+
+        self.ws: Optional[WebSocketApp] = None
+        self._stop = False
+
+        # 活跃时间（收到任意消息时更新）
+        self._last_activity = time.time()
+
+        # “长时间无消息”监控线程
+        self._monitor_thread: Optional[threading.Thread] = None
+        self._monitor_stop_evt = threading.Event()
+
+        self.order_books: dict[str, OrderBookSummary] = {}
+
+        self._furl = url.rstrip("/") + "/ws/" + MARKET_CHANNEL
+        self.callback = callback
+        self._wss_proxies = wss_proxies or {}
+
+        self.initialize()
+
+    # ---------- 初始化 order book 快照 ----------
+
+    def initialize(self):
+        books = fetch_order_books(self.asset_ids)
+        for book in books:
+            self.order_books[book.asset_id] = book
+
+    # ---------- 公共方法 ----------
+
+    def start(self):
+        """
+        阻塞运行，带自动重连逻辑。
+        """
+        while not self._stop:
+            try:
+                logger.info("[OrderBookWS] Connecting to {} ...", self._furl)
+
+                self.ws = WebSocketApp(
+                    self._furl,
+                    on_message=self._on_message,
+                    on_error=self._on_error,
+                    on_close=self._on_close,
+                    on_open=self._on_open,
+                )
+
+                # 重置状态
+                self._last_activity = time.time()
+                self._monitor_stop_evt.clear()
+
+                # 启动“长时间无消息”监控线程
+                if self.idle_timeout and self.idle_timeout > 0:
+                    self._monitor_thread = threading.Thread(
+                        target=self._activity_monitor_loop,
+                        daemon=True,
+                    )
+                    self._monitor_thread.start()
+                else:
+                    self._monitor_thread = None
+
+                self.ws.run_forever(
+                    ping_interval=self.ping_interval,
+                    ping_timeout=self.ping_timeout,
+                    **self._wss_proxies,
+                )
+
+            except Exception as e:
+                logger.exception(
+                    "[OrderBookWS] run_forever error",
+                )
+
+            # 连接生命周期结束，停止监控线程和 ping 线程
+            self._monitor_stop_evt.set()
+
+            if self._monitor_thread and self._monitor_thread.is_alive():
+                self._monitor_thread.join(timeout=1)
+
+            if self._stop:
+                break
+
+            logger.info(
+                f"[OrderBookWS] Disconnected, reconnecting in {self.reconnect_delay}",
+            )
+            time.sleep(self.reconnect_delay)
+
+    def stop(self):
+        """
+        手动停止（优雅退出）
+        """
+        logger.info("[OrderBookWS] Stopping...")
+        self._stop = True
+        self._monitor_stop_evt.set()
+
+        if self.ws:
+            try:
+                self.ws.close()
+            except Exception:
+                logger.exception("[OrderBookWS] error when closing ws")
+
+    # ---------- WebSocket 回调 ----------
+
+    def _on_open(self, ws: WebSocket):
+        logger.info("[OrderBookWS] Opened")
+
+        sub_msg = {"assets_ids": self.asset_ids, "type": MARKET_CHANNEL}
+
+        ws.send(json.dumps(sub_msg))
+        logger.info("[OrderBookWS] Sent subscribe: {}", json_dumps(sub_msg))
+
+    def _on_callback(self):
+        if self.callback is not None:
+            try:
+                self.callback(self.order_books)
+            except Exception:
+                logger.exception(f"wss callback error")
+
+    def _on_message(self, ws: WebSocket, message: str):
+        # 收到任何消息都算活跃
+        self._last_activity = time.time()
+
+        try:
+            messages = json.loads(message)
+            if not isinstance(messages, list):
+                messages = [messages]
+        except json.decoder.JSONDecodeError:
+            # 非 JSON 消息直接忽略，或者按需处理
+            logger.debug(f"[OrderBookWS] Non-JSON message: {message}")
+            return
+
+        try:
+            for message in messages:
+                event = message["event_type"]
+                timestamp = int(message["timestamp"]) / 1000
+
+                if event == MarketEvent.PRICE_CHANGE:
+                    for price in message["price_changes"]:
+                        if price["asset_id"] in self.asset_ids:
+                            self.order_books[price["asset_id"]].set_price(
+                                price, timestamp
+                            )
+                elif event == MarketEvent.TICK_SIZE_CHANGE:
+                    self.order_books[message["asset_id"]].tick_size = message[
+                        "new_tick_size"
+                    ]
+                elif event == MarketEvent.BOOK:
+                    order = self.order_books[message["asset_id"]]
+                    self.order_books[message["asset_id"]] = order.model_validate(
+                        {**order.model_dump(), **message}
+                    )
+            self._on_callback()
+        except Exception:
+            logger.exception(f"[OrderBookWS] receive message error: {message}")
+            # 不再 exit(1)，而是交给外层重连
+
+    def _on_error(self, ws: WebSocket, error):
+        logger.error(f"[OrderBookWS] Error: {error}")
+        # 出现错误时关闭连接，交给外层循环重连
+        try:
+            ws.close()
+        except Exception:
+            logger.exception("[OrderBookWS] error when closing on error")
+
+    def _on_close(self, ws: WebSocket, close_status_code, close_msg):
+        logger.info(f"[OrderBookWS] Closed: code={close_status_code}, msg={close_msg}")
+        # 不再 exit(0)，让 run_forever 返回，外层 while 负责重连
+
+    # ---------- “长时间无消息”监控 ----------
+
+    def _activity_monitor_loop(self):
+        """
+        如果长时间（idle_timeout 秒）没有收到任何消息，则主动关闭连接，
+        交由外层循环进行重连。
+        """
+        while not self._monitor_stop_evt.is_set() and not self._stop:
+            now = time.time()
+            if self.idle_timeout and now - self._last_activity > self.idle_timeout:
+                logger.info(
+                    f"[OrderBookWS] No activity for %ss, closing connection to force reconnect..., {self.idle_timeout}"
+                )
+                try:
+                    if self.ws:
+                        self.ws.close()
+                except Exception:
+                    logger.exception("[OrderBookWS] error when closing in idle monitor")
+                break
+
+            # 每秒检查一次
+            self._monitor_stop_evt.wait(1)
+
+
+def handle_user_message(msg: dict):
+    # 这里可以根据 type=TRADE / PLACEMENT / UPDATE 等自己做处理
+    logger.info("[USER EVENT], type: {}, msg: {}", msg.get("type"), json_dumps(msg))

poly_position_watcher-0.1.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: poly-position-watcher
+Version: 0.1.0
+Summary: clear about domain + functionality.
+Home-page: https://github.com/tosmart01/polymarket-position-watcher
+Author: pinbar
+Project-URL: Homepage, https://github.com/tosmart01/polymarket-position-watcher
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: py-clob-client>=0.25.0
+Requires-Dist: websocket-client>=1.8.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# poly-position-watcher
+
+`poly-position-watcher` 将我们在内部使用的仓位监控逻辑独立成了一个可复用的 Python 包，方便接入者基于 Polymarket 官方 `py-clob-client` SDK 快速搭建自己的仓位看板或做市机器人。该包负责：
+
+- 通过 WebSocket 追踪实时 `TRADE` 与 `ORDER` 事件
+- 把 HTTP API 的历史数据和 WebSocket 增量数据统一成同一套 Pydantic 模型
+- 在内存中维护每个 `token_id` 的仓位、订单状态及阻塞式读取接口
+- 提供易于扩展的 HTTP 轮询上下文（在 WebSocket 之外兜底同步）
+- 内置 FIFO 仓位计算器，支持带市价估值与盈亏指标
+
+## 安装
+
+```bash
+pip install poly-position-watcher
+```
+
+如果你是从源码安装，先克隆本仓库然后执行 `pip install -e .`。
+
+## 快速开始
+
+```python
+from py_clob_client.client import ClobClient
+from poly_position_watcher import PositionWatcherService
+
+client = ClobClient(
+    base_url="https://clob.polymarket.com",
+    key="<wallet-key>",
+    secret="<wallet-secret>",
+)
+
+with PositionWatcherService(client=client) as service:
+    # 可选：HTTP 轮询兜底历史仓位
+    with service.http_listen(markets=["<condition_id>"], bootstrap_http=True):
+        position = service.blocking_get_position("<token_id>", timeout=5)
+        order = service.get_order("<order_id>")
+        print(position)
+        print(order)
+```
+
+### 进阶示例（`examples/http_bootstrap_example.py`）
+
+下面是一段更完整的示例脚本（对应 `examples/http_bootstrap_example.py`），演示如何在启动时通过 `http_listen` 获取历史订单 & 仓位，并实时追踪：
+
+```python
+from py_clob_client.client import ClobClient
+from poly_position_watcher import PositionWatcherService
+
+client = ClobClient(...)
+TARGET_MARKETS = ["0x3b7e9926575eb7fae204d27ee9d3c9db0f34d357e4b8c..."]
+TARGET_ORDERS = ["0x74a71abb9efe59c994e0987fa81963aae23d7165f036afb..."]
+token_id = ""
+
+with PositionWatcherService(client=client) as service:
+    # 如果已经存在历史仓位，需要提前告诉 http_listen 所有关心的 markets / orders 并开启 bootstrap_http
+    with service.http_listen(markets=TARGET_MARKETS, orders=TARGET_ORDERS, bootstrap_http=True):
+        order = service.blocking_get_order(TARGET_ORDERS[0], timeout=5)
+        position = service.blocking_get_position(
+            token_id=token_id,
+            timeout=5,
+        )
+        print(order)
+        print(position)
+
+```
+
+示例输出：
+
+```shell
+OrderMessage(
+  type: 'update',
+  event_type: 'order',
+  asset_id: '7718951783559279583290056782453440...',
+  associate_trades: ['8bf02a75-5...'],
+  id: '0x74a71abb9efe59c994e0...',
+  market: '0x3b7e9926575eb7fae2...',
+  order_owner: None,
+  original_size: 37.5,
+  outcome: 'Up',
+  owner: '',
+  price: 0.52,
+  side: 'BUY',
+  size_matched: 37.5,
+  timestamp: 0.0,
+  filled: True,
+  status: 'MATCHED',
+  created_at: datetime.datetime(2025, 12, 8, 9, 44, 50, tzinfo=TzInfo(0))
+)
+UserPosition(
+  price: 0.0,
+  size: 0.0,
+  volume: 0.0,
+  token_id: '',
+  last_update: 0.0,
+  market_id: None,
+  outcome: None,
+  created_at: None
+)
+```
+
+> ⚠️ 注意：如果你是先启动监控再产生仓位，可令 `bootstrap_http=False` 且 `markets/orders` 参数为空列表即可；只有当已经存在历史仓位/订单需要补偿时才需要提前传入，并开启 `bootstrap_http=True`。
+
+### 只使用 HTTP 轮询
+
+`HttpListenerContext` 可在需要时单独使用：
+
+```python
+with service.http_listen(markets=["<condition_id>"], http_poll_interval=2.5) as ctx:
+    ctx.add(markets=["other_condition_id"], orders=["<order_id>"])
+```
+
+## 可选配置
+
+| 环境变量 | 说明 |
+| --- | --- |
+| `poly_position_watcher_LOG_LEVEL` | 调整日志级别，默认为 `INFO` |
+
+若需要为 WebSocket 连接设置代理，可在实例化 `PositionWatcherService` 及 `http_listen` 前自行构造一个字典并通过 `wss_proxies` 传入，例如：
+
+```python
+PROXY = {"http_proxy_host": "127.0.0.1", "http_proxy_port": 7890}
+service = PositionWatcherService(client, wss_proxies=PROXY)
+```
+
+## 依赖
+
+- [`py-clob-client`](https://github.com/Polymarket/py-clob-client)
+- [`pydantic`](https://docs.pydantic.dev/)
+- [`websocket-client`](https://github.com/websocket-client/websocket-client)
+- [`requests`](https://requests.readthedocs.io/en/latest/)
+
+## 目录结构
+
+```
+poly_position_watcher/
+├── api_worker.py          # HTTP 补数与上下文管理
+├── position_service.py    # 核心入口，维护仓位/订单缓存
+├── trade_calculator.py    # 仓位计算工具
+├── wss_worker.py          # WebSocket 客户端实现
+├── common/                # 日志与枚举
+└── schema/                # Pydantic 数据模型
+```
+
+## 许可证
+
+MIT

poly_position_watcher-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+poly_position_watcher/__init__.py,sha256=VR3T8B08l2YJbRIeysWzN0xPCTdh0k1m2ZPQzphhnRU,546
+poly_position_watcher/_version.py,sha256=_tAoPRxHlRWnnqYQFVPJqTq0794zoiaHgxaXAAREvUI,52
+poly_position_watcher/api_worker.py,sha256=05q5siawpyrNnCCqO59oskOqzbkg4cVEC_tQia2Gwcg,7939
+poly_position_watcher/position_service.py,sha256=GvrNtQoASZm_lWUVPBZtlf86l8UT4kyjYwNC4skHrwo,12656
+poly_position_watcher/trade_calculator.py,sha256=8AVJ16NEU7dPHvB37fa3RlbUGWA27xFSfGbgxKWFiQI,4612
+poly_position_watcher/wss_worker.py,sha256=WLHyjxCs5AdXcuTZOus8e-WpLg5unY0raVED8HecQyY,16700
+poly_position_watcher/common/__init__.py,sha256=8tLsESE6V-OHYvu1fHozSeLll1vO2vZ1nSMjoHGBiys,183
+poly_position_watcher/common/enums.py,sha256=L7L5ehkLSOlbplfBP0uRRESF5wPqtx7tsp86nSz_4rY,430
+poly_position_watcher/common/logger.py,sha256=JU8d5MhOrRUFaMtD6mDjQ2t4TaIBT6msPL09wVPl_uw,1716
+poly_position_watcher/schema/__init__.py,sha256=r4fZmcqPLw7FL6kIYiUr0hdiAs5lWdbptZIpVx9i5uU,430
+poly_position_watcher/schema/base.py,sha256=ZMY4YpKC6g9Zg6QJlZ0PCkVLd0KFfjjTElofqCsUacA,780
+poly_position_watcher/schema/common_model.py,sha256=tCcZN-oZPZETuX6s1WBkiIkBXIhrPb_2rJituDAMHrw,4732
+poly_position_watcher/schema/position_model.py,sha256=fB84lneZuO1KOHpyLXyDLAKINSe2UazVJUIOZFzNq2A,4075
+poly_position_watcher-0.1.0.dist-info/licenses/LICENSE,sha256=s7XOR4h-6YPXj4pJvUjZ4OXOy13IlQuQGPcIP4tWDus,1085
+poly_position_watcher-0.1.0.dist-info/METADATA,sha256=_xGsBYbowdlGwTFeBooKVgxnsECqxSemMmhyKyCPLLo,5447
+poly_position_watcher-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+poly_position_watcher-0.1.0.dist-info/top_level.txt,sha256=UahKe-xC4_pgBU0_USUmMIweRzHaS5PTA9P-1TDK9AY,22
+poly_position_watcher-0.1.0.dist-info/RECORD,,

poly_position_watcher-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

poly_position_watcher-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Donvink
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

poly_position_watcher-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+poly_position_watcher