pmxt 1.1.0b3__py3-none-any.whl → 1.1.1__py3-none-any.whl

pmxt/__init__.py

@@ -33,7 +33,7 @@ from .models import (
     CreateOrderParams,
 )
 
-__version__ = "1.1.0b3"
+__version__ = "1.1.1"
 __all__ = [
     # Exchanges
     "Polymarket",

pmxt/_server/server/bundled.js

@@ -104733,6 +104733,7 @@ var require_polymarket = __commonJS({
             timestamp: o.created_at * 1e3
           }));
         } catch (error) {
+          console.error("Error fetching Polymarket open orders:", error);
           return [];
         }
       }
@@ -105366,6 +105367,290 @@ var require_auth2 = __commonJS({
   }
 });
 
+// dist/exchanges/kalshi/websocket.js
+var require_websocket4 = __commonJS({
+  "dist/exchanges/kalshi/websocket.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.KalshiWebSocket = void 0;
+    var ws_1 = __importDefault(require_ws());
+    var KalshiWebSocket = class {
+      constructor(auth, config = {}) {
+        this.orderBookResolvers = /* @__PURE__ */ new Map();
+        this.tradeResolvers = /* @__PURE__ */ new Map();
+        this.orderBooks = /* @__PURE__ */ new Map();
+        this.subscribedTickers = /* @__PURE__ */ new Set();
+        this.messageIdCounter = 1;
+        this.isConnecting = false;
+        this.isConnected = false;
+        this.auth = auth;
+        this.config = {
+          wsUrl: config.wsUrl || "wss://api.elections.kalshi.com/trade-api/ws/v2",
+          reconnectIntervalMs: config.reconnectIntervalMs || 5e3
+        };
+      }
+      async connect() {
+        if (this.isConnected || this.isConnecting) {
+          return;
+        }
+        this.isConnecting = true;
+        return new Promise((resolve, reject) => {
+          try {
+            const url2 = new URL(this.config.wsUrl);
+            const path = url2.pathname;
+            console.log(`Kalshi WS: Connecting to ${this.config.wsUrl} (using path ${path} for signature)`);
+            const headers = this.auth.getHeaders("GET", path);
+            this.ws = new ws_1.default(this.config.wsUrl, { headers });
+            this.ws.on("open", () => {
+              this.isConnected = true;
+              this.isConnecting = false;
+              console.log("Kalshi WebSocket connected");
+              if (this.subscribedTickers.size > 0) {
+                this.subscribeToOrderbook(Array.from(this.subscribedTickers));
+              }
+              resolve();
+            });
+            this.ws.on("message", (data) => {
+              try {
+                const message = JSON.parse(data.toString());
+                this.handleMessage(message);
+              } catch (error) {
+                console.error("Error parsing Kalshi WebSocket message:", error);
+              }
+            });
+            this.ws.on("error", (error) => {
+              console.error("Kalshi WebSocket error:", error);
+              this.isConnecting = false;
+              reject(error);
+            });
+            this.ws.on("close", () => {
+              console.log("Kalshi WebSocket closed");
+              this.isConnected = false;
+              this.isConnecting = false;
+              this.scheduleReconnect();
+            });
+          } catch (error) {
+            this.isConnecting = false;
+            reject(error);
+          }
+        });
+      }
+      scheduleReconnect() {
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectTimer = setTimeout(() => {
+          console.log("Attempting to reconnect Kalshi WebSocket...");
+          this.connect().catch(console.error);
+        }, this.config.reconnectIntervalMs);
+      }
+      subscribeToOrderbook(marketTickers) {
+        if (!this.ws || !this.isConnected) {
+          return;
+        }
+        const subscription = {
+          id: this.messageIdCounter++,
+          cmd: "subscribe",
+          params: {
+            channels: ["orderbook_delta"],
+            market_tickers: marketTickers
+          }
+        };
+        this.ws.send(JSON.stringify(subscription));
+      }
+      subscribeToTrades(marketTickers) {
+        if (!this.ws || !this.isConnected) {
+          return;
+        }
+        const subscription = {
+          id: this.messageIdCounter++,
+          cmd: "subscribe",
+          params: {
+            channels: ["trade"],
+            market_tickers: marketTickers
+          }
+        };
+        this.ws.send(JSON.stringify(subscription));
+      }
+      handleMessage(message) {
+        const msgType = message.type;
+        const data = message.data || message.msg;
+        if (!data && msgType !== "subscribed" && msgType !== "pong") {
+          return;
+        }
+        if (data && typeof data === "object" && !data.ts && !data.created_time) {
+          data.message_ts = message.ts || message.time;
+        }
+        switch (msgType) {
+          case "orderbook_snapshot":
+            this.handleOrderbookSnapshot(data);
+            break;
+          case "orderbook_delta":
+          case "orderbook_update":
+            this.handleOrderbookDelta(data);
+            break;
+          case "trade":
+            this.handleTrade(data);
+            break;
+          case "error":
+            console.error("Kalshi WebSocket error:", message.msg || message.error || message.data);
+            break;
+          case "subscribed":
+            console.log("Kalshi subscription confirmed:", JSON.stringify(message));
+            break;
+          case "pong":
+            break;
+          default:
+            break;
+        }
+      }
+      handleOrderbookSnapshot(data) {
+        const ticker = data.market_ticker;
+        const bids = (data.yes || []).map((level) => {
+          const price = (level.price || level[0]) / 100;
+          const size2 = (level.quantity !== void 0 ? level.quantity : level.size !== void 0 ? level.size : level[1]) || 0;
+          return { price, size: size2 };
+        }).sort((a, b) => b.price - a.price);
+        const asks = (data.no || []).map((level) => {
+          const price = (100 - (level.price || level[0])) / 100;
+          const size2 = (level.quantity !== void 0 ? level.quantity : level.size !== void 0 ? level.size : level[1]) || 0;
+          return { price, size: size2 };
+        }).sort((a, b) => a.price - b.price);
+        const orderBook = {
+          bids,
+          asks,
+          timestamp: Date.now()
+        };
+        this.orderBooks.set(ticker, orderBook);
+        this.resolveOrderBook(ticker, orderBook);
+      }
+      handleOrderbookDelta(data) {
+        const ticker = data.market_ticker;
+        const existing = this.orderBooks.get(ticker);
+        if (!existing) {
+          return;
+        }
+        const price = data.price / 100;
+        const delta = data.delta !== void 0 ? data.delta : data.quantity !== void 0 ? data.quantity : 0;
+        const side = data.side;
+        if (side === "yes") {
+          this.applyDelta(existing.bids, price, delta, "desc");
+        } else {
+          const yesPrice = (100 - data.price) / 100;
+          this.applyDelta(existing.asks, yesPrice, delta, "asc");
+        }
+        existing.timestamp = Date.now();
+        this.resolveOrderBook(ticker, existing);
+      }
+      applyDelta(levels, price, delta, sortOrder) {
+        const existingIndex = levels.findIndex((l) => Math.abs(l.price - price) < 1e-3);
+        if (delta === 0) {
+          if (existingIndex !== -1) {
+            levels.splice(existingIndex, 1);
+          }
+        } else {
+          if (existingIndex !== -1) {
+            levels[existingIndex].size += delta;
+            if (levels[existingIndex].size <= 0) {
+              levels.splice(existingIndex, 1);
+            }
+          } else {
+            levels.push({ price, size: delta });
+            if (sortOrder === "desc") {
+              levels.sort((a, b) => b.price - a.price);
+            } else {
+              levels.sort((a, b) => a.price - b.price);
+            }
+          }
+        }
+      }
+      handleTrade(data) {
+        const ticker = data.market_ticker;
+        let timestamp = Date.now();
+        const rawTime = data.created_time || data.created_at || data.ts || data.time || data.message_ts;
+        if (rawTime) {
+          const parsed = new Date(rawTime).getTime();
+          if (!isNaN(parsed)) {
+            timestamp = parsed;
+            if (timestamp < 1e10) {
+              timestamp *= 1e3;
+            }
+          } else if (typeof rawTime === "number") {
+            timestamp = rawTime;
+            if (timestamp < 1e10) {
+              timestamp *= 1e3;
+            }
+          }
+        }
+        const trade = {
+          id: data.trade_id || `${timestamp}-${Math.random()}`,
+          timestamp,
+          price: data.yes_price || data.price ? (data.yes_price || data.price) / 100 : 0.5,
+          amount: data.count || data.size || 0,
+          side: data.taker_side === "yes" || data.side === "buy" ? "buy" : data.taker_side === "no" || data.side === "sell" ? "sell" : "unknown"
+        };
+        const resolvers = this.tradeResolvers.get(ticker);
+        if (resolvers && resolvers.length > 0) {
+          resolvers.forEach((r) => r.resolve([trade]));
+          this.tradeResolvers.set(ticker, []);
+        }
+      }
+      resolveOrderBook(ticker, orderBook) {
+        const resolvers = this.orderBookResolvers.get(ticker);
+        if (resolvers && resolvers.length > 0) {
+          resolvers.forEach((r) => r.resolve(orderBook));
+          this.orderBookResolvers.set(ticker, []);
+        }
+      }
+      async watchOrderBook(ticker) {
+        if (!this.isConnected) {
+          await this.connect();
+        }
+        if (!this.subscribedTickers.has(ticker)) {
+          this.subscribedTickers.add(ticker);
+          this.subscribeToOrderbook([ticker]);
+        }
+        return new Promise((resolve, reject) => {
+          if (!this.orderBookResolvers.has(ticker)) {
+            this.orderBookResolvers.set(ticker, []);
+          }
+          this.orderBookResolvers.get(ticker).push({ resolve, reject });
+        });
+      }
+      async watchTrades(ticker) {
+        if (!this.isConnected) {
+          await this.connect();
+        }
+        if (!this.subscribedTickers.has(ticker)) {
+          this.subscribedTickers.add(ticker);
+          this.subscribeToTrades([ticker]);
+        }
+        return new Promise((resolve, reject) => {
+          if (!this.tradeResolvers.has(ticker)) {
+            this.tradeResolvers.set(ticker, []);
+          }
+          this.tradeResolvers.get(ticker).push({ resolve, reject });
+        });
+      }
+      async close() {
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+        }
+        if (this.ws) {
+          this.ws.close();
+          this.ws = void 0;
+        }
+        this.isConnected = false;
+        this.isConnecting = false;
+      }
+    };
+    exports2.KalshiWebSocket = KalshiWebSocket;
+  }
+});
+
 // dist/exchanges/kalshi/index.js
 var require_kalshi = __commonJS({
   "dist/exchanges/kalshi/index.js"(exports2) {
@@ -105384,9 +105669,19 @@ var require_kalshi = __commonJS({
     var fetchOrderBook_1 = require_fetchOrderBook2();
     var fetchTrades_1 = require_fetchTrades2();
     var auth_1 = require_auth2();
+    var websocket_1 = require_websocket4();
     var KalshiExchange = class extends BaseExchange_1.PredictionMarketExchange {
-      constructor(credentials) {
+      constructor(options) {
+        let credentials;
+        let wsConfig;
+        if (options && "credentials" in options) {
+          credentials = options.credentials;
+          wsConfig = options.websocket;
+        } else {
+          credentials = options;
+        }
         super(credentials);
+        this.wsConfig = wsConfig;
         if (credentials?.apiKey && credentials?.privateKey) {
           this.auth = new auth_1.KalshiAuth(credentials);
         }
@@ -105620,6 +105915,26 @@ var require_kalshi = __commonJS({
             return "open";
         }
       }
+      async watchOrderBook(id, limit) {
+        const auth = this.ensureAuth();
+        if (!this.ws) {
+          this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
+        }
+        return this.ws.watchOrderBook(id);
+      }
+      async watchTrades(id, since, limit) {
+        const auth = this.ensureAuth();
+        if (!this.ws) {
+          this.ws = new websocket_1.KalshiWebSocket(auth, this.wsConfig);
+        }
+        return this.ws.watchTrades(id);
+      }
+      async close() {
+        if (this.ws) {
+          await this.ws.close();
+          this.ws = void 0;
+        }
+      }
     };
     exports2.KalshiExchange = KalshiExchange;
   }
@@ -105888,10 +106203,16 @@ var crypto_2 = require("crypto");
 var fs_1 = require("fs");
 var path_1 = require("path");
 function getServerVersion() {
-  const packageCtx = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, "../../package.json"), "utf-8");
-  const packageJson = JSON.parse(packageCtx);
-  const baseVersion = packageJson.version;
-  const isDev = process.env.NODE_ENV === "development" || process.env.PMXT_ALWAYS_RESTART === "1" || __dirname.includes("/core/src/") || __dirname.includes("/core/dist/");
+  let baseVersion = "1.0.0";
+  let packageJson;
+  try {
+    const packageCtx = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, "../../package.json"), "utf-8");
+    packageJson = JSON.parse(packageCtx);
+    baseVersion = packageJson.version;
+  } catch (e) {
+    baseVersion = "1.0.0";
+  }
+  const isDev = process.env.NODE_ENV === "development" || process.env.PMXT_ALWAYS_RESTART === "1" || __dirname.includes("/core/src/") && !!packageJson || __dirname.includes("/core/dist/") && !!packageJson;
   if (!isDev) {
     return baseVersion;
   }

pmxt/server_manager.py

@@ -106,8 +106,25 @@ class ServerManager:
             if pkg_path.exists():
                 data = json.loads(pkg_path.read_text())
                 expected_version = data.get('version')
-                if expected_version and not server_info['version'].startswith(expected_version):
-                     return True
+                server_version = server_info['version']
+                
+                if expected_version:
+                    # Extract major.minor.patch (ignore prerelease/dev suffixes)
+                    def normalize_version(v: str) -> str:
+                        """Extract major.minor.patch, ignoring -dev, -b4, etc."""
+                        # Remove -dev.xxx or -b4 suffixes
+                        base = v.split('-')[0]
+                        # Get major.minor.patch
+                        parts = base.split('.')[:3]
+                        return '.'.join(parts)
+                    
+                    expected_base = normalize_version(expected_version)
+                    server_base = normalize_version(server_version)
+                    
+                    # Only restart if major.minor.patch differs
+                    # This allows 1.0.0 and 1.0.0-b4 to coexist in dev
+                    if expected_base != server_base:
+                        return True
         except:
             pass
             

{pmxt-1.1.0b3.dist-info → pmxt-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pmxt
-Version: 1.1.0b3
+Version: 1.1.1
 Summary: Unified prediction market data API - The ccxt for prediction markets
 Author: PMXT Contributors
 License: MIT

{pmxt-1.1.0b3.dist-info → pmxt-1.1.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
-pmxt/__init__.py,sha256=cRd12oU7qiph2roermKAyANsWpvyAtYX_Mu7CWtMxvQ,1152
+pmxt/__init__.py,sha256=oC3V-64mrTjHzRPTbKwdxf_yXeogcO0lFhajSTIcUYU,1150
 pmxt/client.py,sha256=2qlCJsxkQiHYrYvZYX4p-APvYq0rF_yicNfUPgcE3ZU,27368
 pmxt/models.py,sha256=Mu0hLVjQU3PM5m68poK61VQcJtPQ8ZdLdLU7pq1lqjQ,6004
-pmxt/server_manager.py,sha256=wmHcGBM3oMNLSajCZ0xnANNSmqBYt9vWxQzeYmfo0-Y,10635
+pmxt/server_manager.py,sha256=-G97dYEdKl7F3HK9bAOKYl-SGWP6HsvzZIx2QxiZm24,11494
 pmxt/_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pmxt/_server/bin/pmxt-ensure-server,sha256=kXIond0UbxS52FAVQD7kHmSBaL_s6cbIyapLRr4KZJw,4544
-pmxt/_server/server/bundled.js,sha256=TXtX8YZlSnrIoN_ZmxMA25WqQw6j-eZXMi4YNr32p58,4175627
-pmxt_internal/__init__.py,sha256=hLo16IXoN2-p2BsWLhDJYJQwJOE8GYeDWBiXOWygt60,6402
-pmxt_internal/api_client.py,sha256=m9QUfY0jZXZHZv2nXoO1iMXdzsJrK592Km06ka3Mzy4,27891
+pmxt/_server/server/bundled.js,sha256=bgJSNnbYAsY2opHDoF-EfnJZgD03Ws2FmKpWGGKcGYg,4187137
+pmxt_internal/__init__.py,sha256=a97YaMsu1ntU_7slo9f95xL5giaVGFT9RRH80wf8wbI,6400
+pmxt_internal/api_client.py,sha256=sP-gP9rDauf5QEq_1VmqAcZ233AcLrdHpCO82jh_I6s,27889
 pmxt_internal/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
-pmxt_internal/configuration.py,sha256=VHt377shApQvdfeD_UaDInr0ddLCUv-3cyoDLdITH5Y,18322
+pmxt_internal/configuration.py,sha256=kI70vRzd_DKVSeDLYqsQL6frn6Ob4o-3fz4_GJ6pQW0,18320
 pmxt_internal/exceptions.py,sha256=txF8A7vlan57JS69kFPs-IZF-Qhp7IZobBTJVa4fOaM,6644
 pmxt_internal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pmxt_internal/rest.py,sha256=FMj4yaV6XLr842u_ScWHSzQsTFdk0jaUeuWLJoRbogQ,9760
@@ -56,7 +56,7 @@ pmxt_internal/models/unified_market.py,sha256=mNyUrGKWxvI2f2KCa2uhGwq22cBdDia2hD
 pmxt_internal/models/watch_order_book_request.py,sha256=kavGUI-SLz2-Kam_jcJ_h0GDe0-9UkxqCmVsAi6Uios,3726
 pmxt_internal/models/watch_order_book_request_args_inner.py,sha256=ZHrjmFDGxRG5MXbuz4mUp9KFfo3XS7zuXWTyMNgi4xI,5464
 pmxt_internal/models/watch_trades_request.py,sha256=brrg8JbEe-aeg7mIe_Y2HzRPogp-IfRhkXChrxzqoLU,3722
-pmxt-1.1.0b3.dist-info/METADATA,sha256=WO2btv7I0cpZ3qevrK7MUULNDWQHe7xZyexG91z5z6Y,6290
-pmxt-1.1.0b3.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-pmxt-1.1.0b3.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
-pmxt-1.1.0b3.dist-info/RECORD,,
+pmxt-1.1.1.dist-info/METADATA,sha256=YHfyvkeNC3WJxsyAArgpmpeEeJrElWodY1aeebaKSRw,6288
+pmxt-1.1.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+pmxt-1.1.1.dist-info/top_level.txt,sha256=J_jrcouJ-x-5lpcXMxeW0GOSi1HsBVR5_PdSfvigVrw,19
+pmxt-1.1.1.dist-info/RECORD,,

pmxt_internal/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "1.1.0b3"
+__version__ = "1.1.1"
 
 # Define package exports
 __all__ = [

pmxt_internal/api_client.py

@@ -91,7 +91,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/1.1.0b3/python'
+        self.user_agent = 'OpenAPI-Generator/1.1.1/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

pmxt_internal/configuration.py

@@ -506,7 +506,7 @@ class Configuration:
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 0.4.4\n"\
-               "SDK Package Version: 1.1.0b3".\
+               "SDK Package Version: 1.1.1".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]: