hyperquant 1.32__tar.gz → 1.34__tar.gz

{hyperquant-1.32 → hyperquant-1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.32
+Version: 1.34
 Summary: A minimal yet hyper-efficient backtesting framework for quantitative trading
 Project-URL: Homepage, https://github.com/yourusername/hyperquant
 Project-URL: Issues, https://github.com/yourusername/hyperquant/issues

{hyperquant-1.32 → hyperquant-1.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.32"
+version = "1.34"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-1.32 → hyperquant-1.34}/src/hyperquant/broker/models/polymarket.py

@@ -292,7 +292,7 @@ class Detail(DataStore):
 
     @staticmethod
     def _normalize_entry(market: dict[str, Any], token: dict[str, Any]) -> dict[str, Any]:
-        slug = market.get("market_slug") or market.get("question") or market.get("id")
+        slug = market.get("slug")
         outcome = token.get("outcome")
         alias = slug if outcome is None else f"{slug}:{outcome}"
 
@@ -364,10 +364,14 @@ class Detail(DataStore):
 
             for token in tokens:
                 normalized = self._normalize_entry(market, token)
+                slug: str = market.get("slug")
+                # 取最后一个'-'之前部分
+                base_slug = slug.rsplit("-", 1)[0] if slug else slug
                 # Add or update additional fields from market
                 normalized.update({
                     "condition_id": market.get("conditionId"),
                     "slug": market.get("slug"),
+                    "base_slug": base_slug,
                     "end_date": market.get("endDate"),
                     "start_date": market.get("startDate"),
                     "icon": market.get("icon"),

{hyperquant-1.32 → hyperquant-1.34}/src/hyperquant/broker/polymarket.py

@@ -498,7 +498,7 @@ class Polymarket:
         side: str,
         price: float,
         size: float,
-        order_type: str = "GTC",
+        order_type: Literal["GTC", 'FOK'] = "GTC",
         tick_size: str | float | None = None,
         fee_rate_bps: int | None = None,
         expiration: int | None = None,
@@ -523,6 +523,9 @@ class Polymarket:
         - nonce: onchain nonce, default 0
         """
 
+        if price <= 0:
+            raise ValueError("price must be positive; use place_market_order for market orders")
+
         # Ensure L2 creds exist
         if not self._api_creds():
             raise RuntimeError("Polymarket API credentials missing; call create_or_derive_api_creds first")
@@ -552,6 +555,117 @@ class Polymarket:
         }
         return await self._signed_request_via_session("POST", "/order", payload)
 
+    async def place_market_order(
+        self,
+        *,
+        token_id: str,
+        side: str,
+        amount: float,
+        order_type: Literal["FOK", "GTC", "FAK", "GTD"] = "FOK",
+        price: float | None = None,
+        tick_size: str | float | None = None,
+        fee_rate_bps: int | None = None,
+        taker: str = ZERO_ADDRESS,
+        neg_risk: bool = False,
+        owner: str | None = None,
+        nonce: int | None = None,
+    ) -> Any:
+        """Create, sign and submit a market order similar to ``py_clob_client``.
+
+        BUY orders treat ``amount`` as collateral (USDC); SELL orders treat it as shares.
+        """
+
+        if amount <= 0:
+            raise ValueError("amount must be greater than 0 for market orders")
+
+        if not self._api_creds():
+            raise RuntimeError("Polymarket API credentials missing; call create_or_derive_api_creds first")
+
+        private_key, maker_addr, signer_addr = self._get_signing_context()
+        owner_key = self._owner_key(owner)
+        order_type_str = (order_type or "FOK").upper()
+
+        if price is None or price <= 0:
+            price = await self._calculate_market_price(
+                token_id=token_id,
+                side=side,
+                amount=amount,
+                order_type=order_type_str,
+            )
+
+        signed_dict = await self._build_signed_market_order(
+            private_key=private_key,
+            maker_addr=maker_addr,
+            signer_addr=signer_addr,
+            token_id=token_id,
+            side=side,
+            amount=amount,
+            price=price,
+            tick_size=tick_size,
+            fee_rate_bps=fee_rate_bps,
+            taker=taker,
+            neg_risk=neg_risk,
+            nonce=nonce,
+        )
+
+        payload = {
+            "order": signed_dict,
+            "owner": owner_key,
+            "orderType": order_type_str,
+        }
+        return await self._signed_request_via_session("POST", "/order", payload)
+
+    async def _calculate_market_price(
+        self,
+        *,
+        token_id: str,
+        side: str,
+        amount: float,
+        order_type: str,
+    ) -> float:
+        side_flag = side.upper()
+        if side_flag not in {"BUY", "SELL"}:
+            raise ValueError("side must be 'BUY' or 'SELL'")
+        if amount <= 0:
+            raise ValueError("amount must be greater than 0 for market pricing")
+
+        book = await self.get_order_book(token_id)
+        if not isinstance(book, Mapping):
+            raise RuntimeError("Polymarket order book unavailable for market order")
+
+        key = "asks" if side_flag == "BUY" else "bids"
+        raw_levels = book.get(key) or []
+        levels: list[tuple[float, float]] = []
+        for lvl in raw_levels:
+            try:
+                price = float(lvl.get("price"))
+                size = float(lvl.get("size"))
+            except (TypeError, ValueError):
+                continue
+            if price is None or size is None:
+                continue
+            levels.append((price, size))
+
+        if not levels:
+            raise RuntimeError(f"Polymarket market order has no {key} liquidity")
+
+        total = 0.0
+        if side_flag == "BUY":
+            for price, size in reversed(levels):
+                total += price * size
+                if total >= amount:
+                    return price
+        else:
+            for price, size in reversed(levels):
+                total += size
+                if total >= amount:
+                    return price
+
+        if (order_type or "FOK").upper() == "FOK":
+            raise RuntimeError("Polymarket market order exceeds available liquidity")
+
+        return levels[0][0]
+
     async def _signed_request_via_session(
         self, method: str, path: str, body: Mapping[str, Any] | list[Any] | None
     ) -> Any:
@@ -686,6 +800,76 @@ class Polymarket:
             },
         )
 
+    async def _build_signed_market_order(
+        self,
+        *,
+        private_key: str,
+        maker_addr: str,
+        signer_addr: str,
+        token_id: str,
+        side: str,
+        amount: float,
+        price: float,
+        tick_size: str | float | None,
+        fee_rate_bps: int | None,
+        taker: str,
+        neg_risk: bool,
+        nonce: int | None,
+    ) -> dict[str, Any]:
+        side = side.upper()
+        tick = await self._resolve_tick_size(token_id, tick_size)
+        fee_bps = await self._resolve_fee_rate(token_id, fee_rate_bps)
+
+        price_d, size_d, amt_d = self._rounding_for_tick(tick)
+        price = float(self._round_normal(price, price_d))
+        if price <= 0:
+            raise ValueError("market price must be positive")
+
+        amt = float(amount)
+        if amt <= 0:
+            raise ValueError("amount must be greater than 0")
+
+        maker_amt_raw = self._round_down(amt, size_d)
+        if maker_amt_raw <= 0:
+            raise ValueError("amount too small for current tick size")
+
+        if side == "BUY":
+            taker_amt_raw = maker_amt_raw / price
+        elif side == "SELL":
+            taker_amt_raw = maker_amt_raw * price
+        else:
+            raise ValueError("side must be 'BUY' or 'SELL'")
+
+        if self._decimal_places(taker_amt_raw) > amt_d:
+            tmp = self._round_up(taker_amt_raw, amt_d + 4)
+            taker_amt_raw = tmp if self._decimal_places(tmp) <= amt_d else self._round_down(tmp, amt_d)
+
+        maker_amount = self._to_token_decimals(maker_amt_raw)
+        taker_amount = self._to_token_decimals(taker_amt_raw)
+
+        contract = self._contracts(self.chain_id, neg_risk)
+        side_flag = 0 if side == "BUY" else 1
+        sig_type = int(self.signature_type)
+
+        return Auth.sign_polymarket_order(
+            private_key=private_key,
+            chain_id=self.chain_id,
+            exchange_address=contract["exchange"],
+            order={
+                "maker": maker_addr,
+                "signer": signer_addr,
+                "taker": taker or ZERO_ADDRESS,
+                "tokenId": str(token_id),
+                "makerAmount": int(maker_amount),
+                "takerAmount": int(taker_amount),
+                "expiration": 0,
+                "nonce": int(nonce or 0),
+                "feeRateBps": int(fee_bps or 0),
+                "side": side_flag,
+                "signatureType": sig_type,
+            },
+        )
+
     async def _resolve_tick_size(self, token_id: str, tick_size: str | float | None) -> str:
         if tick_size is not None:
             return str(tick_size)
@@ -878,6 +1062,7 @@ class Polymarket:
 
     async def get_trades(self, params: Mapping[str, Any] | None = None) -> list[Any]:
         return await self._paginate("/data/trades", params)
+    
 
     async def get_notifications(self, signature_type: int | None = None) -> Any:
         sig = signature_type if signature_type is not None else self.signature_type
@@ -889,12 +1074,30 @@ class Polymarket:
         return await self._rest("DELETE", "/notifications", params=params)
 
     async def get_balance_allowance(self, **params: Any) -> Any:
-        return await self._rest("GET", "/balance-allowance", params=params or None)
+        query = dict(params or {})
+        query.setdefault("signature_type", self.signature_type)
+        return await self._rest("GET", "/balance-allowance", params=query or None)
 
     async def update_balance_allowance(self, **params: Any) -> Any:
-        return await self._rest("POST", "/balance-allowance/update", json=params or None)
-
-    async def get_usdc(
+        body = dict(params or {})
+        body.setdefault("signature_type", self.signature_type)
+        return await self._rest("POST", "/balance-allowance/update", json=body or None)
+    
+    async def get_usdc(self):
+        data = await self.get_balance_allowance(asset_type='COLLATERAL')
+        balance = float(data.get('balance', 0.0))
+        if balance > 0:
+            balance = balance / 1e6
+        return balance
+    
+    async def get_position(self, token_id: str) -> Any:
+        data = await self.get_balance_allowance(asset_type='CONDITIONAL', token_id=token_id)
+        position = float(data.get('balance', 0.0))
+        if position > 0:
+            position = position / 1e6
+        return position
+
+    async def get_usdc_web3(
         self,
         wallet: str = None,
         rpc_urls: Sequence[str] | None = None,

{hyperquant-1.32 → hyperquant-1.34}/uv.lock

@@ -945,7 +945,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.31"
+version = "1.33"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },