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

poly_position_watcher/schema/base.py

@@ -0,0 +1,27 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-06 19:09:43
+# @Author: Donvink wuwukai
+# @Site:
+# @File: base.py
+# @Software: PyCharm
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+def datetime_to_gmt_str(dt: datetime) -> str:
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+class PrettyPrintBaseModel(BaseModel):
+    def __str__(self):
+        # 将每个字段和值分行显示
+        lines = [f"{name}: {value!r}" for name, value in self.__dict__.items()]
+        return f"{self.__class__.__name__}(\n  " + ",\n  ".join(lines) + "\n)"
+
+    # 可选：让 repr() 打印同样效果
+    __repr__ = __str__
+    model_config = ConfigDict(
+        json_encoders={datetime: datetime_to_gmt_str},
+        populate_by_name=True,
+    )

poly_position_watcher/schema/common_model.py

@@ -0,0 +1,150 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/10/13 10:03
+# @Author: pinbar
+# @Site:
+# @File: schema.py
+# @Software: PyCharm
+import time
+from typing import Optional
+from pydantic import BaseModel, model_validator, Field
+
+from poly_position_watcher.common.enums import Side
+from poly_position_watcher.schema.base import PrettyPrintBaseModel
+
+
+class OrderSummary(BaseModel):
+    price: float = None
+    size: float = None
+    size_cumsum: float = None
+
+
+class OrderBookSummary(BaseModel):
+    market: str = None
+    period: Optional[str] = None
+    asset_id: str = None
+    timestamp: float = None
+    bids: Optional[list[OrderSummary]] = None
+    asks: Optional[list[OrderSummary]] = None
+    min_order_size: str = None
+    neg_risk: bool = None
+    tick_size: str = None
+    hash: str = None
+
+    def flush_cumsum(self):
+        tick_size = len(self.tick_size) - 2
+        for item in [[*self.bids], [*self.asks]]:
+            cumsum = 0
+            for row in item[::-1]:
+                row.size = float(row.size)
+                row.price = round(float(row.price), tick_size)
+                cumsum += row.size
+                row.size_cumsum = cumsum
+
+    def set_price(self, item: dict, timestamp):
+        tick_size = len(self.tick_size) - 2
+        new_price = round(float(item["price"]), tick_size)
+        for row in [*self.asks, *self.bids]:
+            if row.price == new_price:
+                row.size = float(item["size"])
+        self.timestamp = timestamp
+        self.flush_cumsum()
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_fields(cls, values: dict):
+        if isinstance(values, dict):
+            if timestamp := values.get("timestamp"):
+                values["timestamp"] = int(timestamp) / 1000
+            tick_size = len(values.get("tick_size")) - 2
+            for item in [values.get("bids", []), values.get("asks", [])]:
+                cumsum = 0
+                for row in item[::-1]:
+                    row["size"] = float(row["size"])
+                    row["price"] = round(float(row["price"]), tick_size)
+                    cumsum += row["size"]
+                    row["size_cumsum"] = cumsum
+        return values
+
+    def print_order_book(
+        self,
+    ) -> str:
+        """漂亮打印盘口，不依赖第三方库，返回字符串"""
+        depth = 8
+        bids = self.bids[-depth:]
+        asks = self.asks[-depth:]
+
+        lines = []
+        lines.append("\n📊 Order Book Summary")
+        lines.append(f"Min Order Size: {self.min_order_size}")
+        lines.append(f"Tick Size: {self.tick_size}")
+        lines.append(f"{'Price':>10} | {'Size':>12} | {'Size_Cumsum':>12}")
+        lines.append("-" * 30)
+
+        # 卖单从高到低打印（视觉上上方高价）
+        for ask in asks:
+            lines.append(
+                f"{ask.price:>10.3f} | {ask.size:>12,.2f} | {ask.size_cumsum:>12,.2f}"
+            )
+
+        lines.append("-" * 30)
+
+        for bid in reversed(bids):
+            lines.append(
+                f"{bid.price:>10.3f} | {bid.size:>12,.2f} | {bid.size_cumsum:>12,.2f}"
+            )
+
+        lines.append("-" * 30)
+        lines.append("")
+
+        return "\n".join(lines)
+
+
+class UserPosition(PrettyPrintBaseModel):
+    buy_price: Optional[float] = 0
+    sell_price: Optional[float] = 0
+    original_size: Optional[float] = 0
+    buy_size_matched: Optional[float] = 0
+    status: Optional[str] = None
+    remaining_size: Optional[float] = 0
+    sell_size_matched: Optional[float] = 0
+
+
+class MarketOrder(BaseModel):
+    order_id: Optional[str] = None
+    slug: str = None
+    token_id: str = None
+    shares: float = None
+    side: Side = None
+    amount: float = None
+    take_profit: float = 0
+    price: float = None
+    tick_size: str = None
+    neg_risk: bool = None
+
+
+class StreakPosition(PrettyPrintBaseModel):
+    shares: float = None
+    origin_shares: float = None
+    price: float = None
+    real_price: float = None
+    volume: float = None
+    real_volume: float = None
+    combine_now: str = ""
+    side: str = ""
+    market: str = ""
+    streak_len: int = 2
+
+
+class PeakData(BaseModel):
+    """峰值数据模型"""
+
+    is_peak: bool
+    peak_idx: int = None
+    peak_value: float = None
+    left: float = None
+    center: float = None
+    right: float = None
+    center_token_id: Optional[str] = Field(None, description="中心token ID")
+    right_token_id: Optional[str] = Field(None, description="右侧token ID")
+    left_token_id: Optional[str] = Field(None, description="左侧token ID")
+    last_update: float = Field(default_factory=time.time)

poly_position_watcher/schema/position_model.py

@@ -0,0 +1,152 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/1 16:15
+# @Author: pinbar
+# @Site:
+# @File: model.py
+# @Software: PyCharm
+from datetime import datetime
+from typing import List, Optional, Literal
+
+from pydantic import BaseModel, field_validator, model_validator
+
+from poly_position_watcher.common.enums import Side
+from poly_position_watcher.schema.base import PrettyPrintBaseModel
+
+
+class MakerOrder(BaseModel):
+    asset_id: str
+    matched_amount: float
+    size: float = 0
+    order_id: str
+    outcome: str
+    owner: str
+    price: float
+    fee_rate_bps: float
+    outcome_index: int | None = None
+    maker_address: str
+    side: Side
+
+    @field_validator("fee_rate_bps", "price", "matched_amount", "size", mode="before")
+    @classmethod
+    def validate_float(cls, v: str):
+        return float(v)
+
+    @model_validator(mode="after")
+    def validate_size(self):
+        self.size = self.matched_amount
+        return self
+
+
+class TradeMessage(BaseModel):
+    type: Literal["TRADE"] = "Trade"
+    event_type: Literal["trade"] = "trade"
+
+    asset_id: str
+    id: str
+    maker_orders: List[MakerOrder]
+    transaction_hash: str
+    market: str
+    maker_address: str
+    outcome: str
+    owner: str
+    price: float
+    side: Side
+    size: float
+    status: str
+    taker_order_id: str
+    timestamp: int | None = None
+    match_time: int | None = None
+    last_update: int | None = None
+    trade_owner: Optional[str] = None
+    fee_rate_bps: float
+    created_at: datetime | None = None
+
+    @model_validator(mode="after")
+    def validate_datetime(self):
+        base_ts = self.match_time or self.last_update
+        if base_ts:
+            self.created_at = datetime.fromtimestamp(base_ts)
+        return self
+
+    @field_validator("timestamp", "last_update", "match_time", mode="before")
+    @classmethod
+    def validate_int(cls, v: str):
+        if v in (None, ""):
+            return None
+        return int(v)
+
+    @field_validator("fee_rate_bps", "price", "size", mode="before")
+    @classmethod
+    def validate_float(cls, v: str):
+        return float(v)
+
+
+class OrderMessage(PrettyPrintBaseModel):
+    type: Optional[str] = None  # Literal["PLACEMENT", "UPDATE", "CANCELLATION"]
+    event_type: Optional[str] = None  # Literal["order"]
+
+    asset_id: Optional[str] = None
+    associate_trades: Optional[List[str]] = None
+    id: Optional[str]
+    market: Optional[str] = None
+    order_owner: Optional[str] = None
+    original_size: float | None = None
+    outcome: Optional[str] = None
+    owner: Optional[str] = None
+    price: float
+    side: Literal["BUY", "SELL"]
+    size_matched: float
+    timestamp: float
+    filled: bool = False
+    status: Optional[str] = None
+    created_at: datetime | None = None
+
+    @field_validator(
+        "size_matched", "price", "original_size", "timestamp", mode="before"
+    )
+    @classmethod
+    def validate_float(cls, v: str):
+        return float(v)
+
+    @model_validator(mode="after")
+    def validate_datetime(self):
+        base_ts = self.timestamp
+        if base_ts:
+            self.created_at = datetime.fromtimestamp(base_ts / 1000)
+        return self
+
+
+class UserPosition(PrettyPrintBaseModel):
+    price: float
+    size: float
+    volume: float
+    token_id: Optional[str] = None
+    last_update: float
+    market_id: Optional[str] = None
+    outcome: Optional[str] = None
+    created_at: datetime | None = None
+
+
+class PositionDetails(BaseModel):
+    """仓位详细信息"""
+
+    buy_events: int
+    sell_events: int
+    total_trades: int
+
+
+class PositionResult(PrettyPrintBaseModel):
+    """仓位计算结果"""
+
+    size: float
+    avg_price: float
+    realized_pnl: float
+    amount: float
+    position_value: Optional[float] = None
+    unrealized_pnl: Optional[float] = None
+    total_pnl: Optional[float] = None
+    profit_rate: Optional[float] = None
+    is_long: bool
+    is_short: bool
+    details: PositionDetails
+    last_update: float

poly_position_watcher/trade_calculator.py

@@ -0,0 +1,148 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-06 15:50:02
+# @Author: Donvink wuwukai
+# @Site:
+# @File: trade_calculator.py
+# @Software: PyCharm
+from collections import deque
+from typing import List
+
+from poly_position_watcher.common.enums import Side
+from poly_position_watcher.schema.position_model import (
+    PositionResult,
+    PositionDetails,
+    TradeMessage,
+)
+
+
+def calculate_position_from_trades(
+    trades: List[TradeMessage], user_address: str
+) -> PositionResult:
+    """
+    根据交易记录直接计算用户仓位（带浮点误差修正）
+    """
+
+    # ==== 新增：统一误差阈值 ====
+    EPS = 0.01
+
+    def clean(x: float) -> float:
+        return 0.0 if abs(x) < EPS else x
+
+    buy_events = []
+    sell_events = []
+
+    # --- 1. 解析所有交易 ---
+    for trade in trades:
+        is_maker_order = False
+
+        # maker 部分
+        for order in trade.maker_orders:
+            if order.maker_address != user_address:
+                continue
+            is_maker_order = True
+
+            if order.side == Side.BUY:
+                buy_events.append((order.size, order.price, trade.match_time))
+            else:
+                sell_events.append((-order.size, order.price, trade.match_time))
+
+        # taker 部分
+        if not is_maker_order and trade.maker_address == user_address:
+            if trade.side == Side.BUY:
+                buy_events.append((trade.size, trade.price, trade.match_time))
+            else:
+                sell_events.append((-trade.size, trade.price, trade.match_time))
+
+    # --- 2. 时间排序 ---
+    all_events = sorted(buy_events + sell_events, key=lambda x: x[2])
+
+    # --- 3. FIFO 撮合 ---
+    buy_queue = deque()
+    realized_pnl = 0.0
+
+    for size, price, _ in all_events:
+        size = clean(size)  # ← 新增：修正
+
+        if size > 0:
+            # 买入加入队列
+            buy_queue.append([size, price])
+
+        else:
+            # 卖出（size 为负）
+            sell_size = clean(-size)
+
+            while sell_size > EPS and buy_queue:
+                lot_size, lot_price = buy_queue[0]
+
+                if lot_size <= sell_size + EPS:
+                    # 完全消耗
+                    realized_pnl += (price - lot_price) * lot_size
+                    sell_size -= lot_size
+                    buy_queue.popleft()
+                else:
+                    # 部分消耗
+                    realized_pnl += (price - lot_price) * sell_size
+                    buy_queue[0][0] = clean(lot_size - sell_size)
+                    sell_size = 0.0
+
+            # 如果还有卖不完 → 变成空头
+            if sell_size > EPS:
+                buy_queue.appendleft([-sell_size, price])
+
+    # --- 4. 计算最终持仓 ---
+    total_size = clean(sum(q[0] for q in buy_queue))
+    cost_basis = clean(sum(clean(q[0]) * q[1] for q in buy_queue))
+
+    # 若因误差产生 0.0000003 的 ghost position → 完全清掉
+    if abs(total_size) < EPS:
+        total_size = 0.0
+        cost_basis = 0.0
+
+    avg_price = cost_basis / total_size if total_size != 0 else 0.0
+
+    return PositionResult(
+        size=total_size,
+        avg_price=avg_price,
+        realized_pnl=realized_pnl,
+        amount=cost_basis,
+        is_long=total_size > 0,
+        is_short=total_size < 0,
+        details=PositionDetails(
+            buy_events=len(buy_events),
+            sell_events=len(sell_events),
+            total_trades=len(all_events),
+        ),
+        last_update=max([i.match_time for i in trades]) if trades else None,
+    )
+
+
+def calculate_position_with_price(
+    trades: List[TradeMessage], user_address: str, market_price: float
+) -> PositionResult:
+    """
+    包含市场价格的仓位计算
+
+    Args:
+        market_price: 当前市场价格
+
+    Returns:
+        额外包含:
+        - position_value: 持仓市值
+        - unrealized_pnl: 未实现盈亏
+        - total_pnl: 总盈亏
+    """
+    position = calculate_position_from_trades(trades, user_address)
+    size = position.size
+
+    if size != 0:
+        position_value = size * market_price
+        position.position_value = position_value
+        cost_basis = position.amount
+        unrealized = position_value - cost_basis
+        position.unrealized_pnl = unrealized
+        position.total_pnl = position.realized_pnl + unrealized
+        position.profit_rate = (
+            position.total_pnl / cost_basis * 100 if cost_basis else None
+        )
+
+    return position