cryptofeed 3.0.2__tar.gz → 3.0.3__tar.gz

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/CHANGES.md

@@ -1,5 +1,17 @@
 ## Changelog
 
+### 3.0.3 (2026-11-02)
+* Bugfix: Duplication issues in NBBO
+* Update: `liquidation_history` feed option, like `trade_history` and `candle_history` - deliver the historical liquidations sent on initial subscribe
+* Update: OKX `info()` has `contract_size` and `contract_currency` for swaps, futures and options; their sizes are in contracts, of that many units of that currency (the base coin on linear contracts and options, USD on inverse swaps and futures)
+* Bugfix: OKX candles have `timestamp` None (exchange sends no timestamp), and monthly (`1M`) candles stop at the next calendar month (UTC+8) instead of a fixed 2,630,000 s after their start
+* Update: OKX TRADES subscribes the `trades-all` channel (one Trade per fill with its own id).
+* Bugfix: OKX no longer subscribes spot and option symbols to funding-rate, or spot symbols to open-interest, which the venue refused with error 60018
+* Bugfix: OKX and Crypto.com skip a ticker update with an empty bid or ask side instead of reporting a price of 0
+* Update: `OKX.instrument_type()` removed (unused)
+* Bugfix: Gate candle volume is now the base currency amount (`a`), not the quote currency volume (`v`)
+* Update: musllinux wheels support
+
 ### 3.0.2 (2026-10-29)
 * Bugfix: Bybit liquidation side is now the side of the liquidation order (SELL when a long is liquidated), as for Binance and OKX
 * Bugfix: Deribit liquidations flagged `M` (maker liquidated) reported the taker's side

{cryptofeed-3.0.2/cryptofeed.egg-info → cryptofeed-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cryptofeed
-Version: 3.0.2
+Version: 3.0.3
 Summary: Cryptocurrency Exchange Websocket Data Feed Handler
 Author-email: Bryant Moscon <bmoscon@gmail.com>
 License-Expression: AGPL-3.0-or-later
@@ -171,8 +171,8 @@ cryptofeed received the message that produced the callback. The objects are defi
   set when the venue provides them.
 * `Candle.closed` is `True` once the bar is final, by default only closed candles are delivered.
   (`candle_closed_only=False` also delivers each update of the open bar).
-* `trade_history` and `candle_history` control whether the batch of recent trades or candles some venues send on
-  subscribe is delivered, by default it is `False`.
+* `trade_history`, `candle_history` and `liquidation_history` control whether the batch of recent trades, candles or
+  liquidations some venues send on subscribe is delivered, by default it is `False`.
 
 ## Backends
 

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/README.md

@@ -121,8 +121,8 @@ cryptofeed received the message that produced the callback. The objects are defi
   set when the venue provides them.
 * `Candle.closed` is `True` once the bar is final, by default only closed candles are delivered.
   (`candle_closed_only=False` also delivers each update of the open bar).
-* `trade_history` and `candle_history` control whether the batch of recent trades or candles some venues send on
-  subscribe is delivered, by default it is `False`.
+* `trade_history`, `candle_history` and `liquidation_history` control whether the batch of recent trades, candles or
+  liquidations some venues send on subscribe is delivered, by default it is `False`.
 
 ## Backends
 

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/cryptofeed/capture/recorder.py

@@ -107,6 +107,7 @@ class PcapRecorder:
                 'candle_closed_only': feed.candle_closed_only,
                 'trade_history': feed.trade_history,
                 'candle_history': feed.candle_history,
+                'liquidation_history': feed.liquidation_history,
                 'max_depth': feed.max_depth,
                 'sandbox': feed.sandbox,
             },

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/cryptofeed/exchanges/cryptodotcom.py

@@ -204,12 +204,9 @@ class CryptoDotCom(Feed):
 
         for entry in msg['data']:
             ts = self.timestamp_normalize(entry['t'])
-            if wants_ticker:
-                # an instrument with one side of the book empty omits that side's price
-                t = Ticker(self.id, symbol,
-                           Decimal(entry['b']) if entry.get('b') else Decimal(0),
-                           Decimal(entry['k']) if entry.get('k') else Decimal(0),
-                           ts, raw=entry)
+            # an instrument with one side of the book empty omits that side's price
+            if wants_ticker and entry.get('b') and entry.get('k'):
+                t = Ticker(self.id, symbol, Decimal(entry['b']), Decimal(entry['k']), ts, raw=entry)
                 await self.callback(TICKER, t, timestamp)
             if wants_oi:
                 await self.callback(OPEN_INTEREST, OpenInterest(self.id, symbol, Decimal(entry['oi']), ts, raw=entry), timestamp)

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/cryptofeed/exchanges/gate.py

@@ -292,7 +292,7 @@ class Gate(SnapshotSync, Feed):
             Decimal(msg['result']['c']),
             Decimal(msg['result']['h']),
             Decimal(msg['result']['l']),
-            Decimal(msg['result']['v']),
+            Decimal(msg['result']['a']),
             bool(msg['result'].get('w')),
             float(msg['time']),
             raw=msg

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/cryptofeed/exchanges/okx.py

@@ -5,6 +5,7 @@ Please see the LICENSE file for the terms and conditions
 associated with this software.
 '''
 from collections import defaultdict
+from datetime import datetime, timedelta, timezone
 from decimal import Decimal
 from typing import Dict, List, Tuple, Union
 from cryptofeed import _json as json
@@ -16,7 +17,7 @@ from cryptofeed.connection import AsyncConnection, HTTPAsyncConn, RestEndpoint,
 from cryptofeed.defines import CALL, FUTURES, OKX as OKX_str, LIQUIDATIONS, BUY, OPTION, PERPETUAL, PUT, SELL, FILLED, ASK, BID, FUNDING, L2_BOOK, OPEN_INTEREST, TICKER, TRADES, CANDLES, SPOT, UNFILLED
 from cryptofeed.feed import Feed
 from cryptofeed.exceptions import MissingSequenceNumber
-from cryptofeed.symbols import Symbol
+from cryptofeed.symbols import Symbol, str_to_symbol
 from cryptofeed.types import OrderBook, Trade, Ticker, Funding, OpenInterest, Liquidation, Candle
 
 
@@ -33,21 +34,27 @@ class OKX(Feed):
     provides_sequence_number = True
     validates_sequence_number = True
     valid_candle_intervals = {'1M', '1W', '1D', '12H', '6H', '4H', '2H', '1H', '30m', '15m', '5m', '3m', '1m'}
-    candle_interval_map = {'1M': 2630000, '1W': 604800, '1D': 86400, '12H': 43200, '6H': 21600, '4H': 14400, '2H': 7200, '1H': 3600, '30m': 1800, '15m': 900, '5m': 300, '3m': 180, '1m': 60}
+    # bar lengths in seconds; a 1M bar is a calendar month, see _candle_stop
+    candle_interval_map = {'1W': 604800, '1D': 86400, '12H': 43200, '6H': 21600, '4H': 14400, '2H': 7200, '1H': 3600, '30m': 1800, '15m': 900, '5m': 300, '3m': 180, '1m': 60}
+    # bars without the utc suffix open at 00:00 UTC+8 ("UTC+8 opening price k-line: 6H/12H/1D/2D/3D/1W/1M/3M"),
+    # so a 1M bar opens at 16:00 UTC on the last day of the previous month
+    CANDLE_TZ = timezone(timedelta(hours=8))
     websocket_channels = {
         L2_BOOK: 'books',
-        TRADES: 'trades',
+        TRADES: 'trades-all',
         TICKER: 'tickers',
         FUNDING: 'funding-rate',
         OPEN_INTEREST: 'open-interest',
         LIQUIDATIONS: LIQUIDATIONS,
         CANDLES: 'candle'
     }
+    # instrument types a channel refuses
+    channel_excludes = {FUNDING: (SPOT, OPTION), OPEN_INTEREST: (SPOT,)}
     websocket_endpoints = [
-        WebsocketEndpoint('wss://ws.okx.com/ws/v5/public', channel_filter=(websocket_channels[L2_BOOK], websocket_channels[TRADES], websocket_channels[TICKER], websocket_channels[FUNDING], websocket_channels[OPEN_INTEREST], websocket_channels[LIQUIDATIONS]), options={'compression': None}),
-        WebsocketEndpoint('wss://ws.okx.com/ws/v5/business', channel_filter=(websocket_channels[CANDLES],), options={'compression': None}),
+        WebsocketEndpoint('wss://ws.okx.com/ws/v5/public', channel_filter=(websocket_channels[L2_BOOK], websocket_channels[TICKER], websocket_channels[FUNDING], websocket_channels[OPEN_INTEREST], websocket_channels[LIQUIDATIONS]), options={'compression': None}),
+        WebsocketEndpoint('wss://ws.okx.com/ws/v5/business', channel_filter=(websocket_channels[CANDLES], websocket_channels[TRADES]), options={'compression': None}),
     ]
-    rest_endpoints = [RestEndpoint('https://www.okx.com', routes=Routes(['/api/v5/public/instruments?instType=SPOT', '/api/v5/public/instruments?instType=SWAP', '/api/v5/public/instruments?instType=FUTURES'], currencies='/api/v5/public/underlying?instType=OPTION', liquidations='/api/v5/public/liquidation-orders?instType={}&limit=100&state={}&uly={}', l2book='/api/v5/market/books?instId={}&sz={}'))]
+    rest_endpoints = [RestEndpoint('https://www.okx.com', routes=Routes(['/api/v5/public/instruments?instType=SPOT', '/api/v5/public/instruments?instType=SWAP', '/api/v5/public/instruments?instType=FUTURES'], currencies='/api/v5/public/underlying?instType=OPTION', liquidations='/api/v5/public/liquidation-orders?instType={}&limit=100&state={}&uly={}'))]
     option_instruments = '/api/v5/public/instruments?instType=OPTION&uly={}'
     default_option_underlyings = ('BTC-USD', 'ETH-USD')
     request_limit = 20
@@ -108,17 +115,20 @@ class OKX(Feed):
                 ret[s.normalized] = e['instId']
                 info['tick_size'][s.normalized] = e['tickSz']
                 info['instrument_type'][s.normalized] = stype
+                if e.get('ctVal') and e.get('ctMult'):
+                    # the size is in ctValCcy - the base coin on linear swaps, futures and options, USD on inverse
+                    # swaps and futures (ctType says 'inverse' on BTC-settled options whose value is still in BTC)
+                    info['contract_size'][s.normalized] = Decimal(e['ctVal']) * Decimal(e['ctMult'])
+                    info['contract_currency'][s.normalized] = e['ctValCcy']
 
         return ret, info
 
     async def _liquidations(self, pairs: list):
-        last_update = defaultdict(dict)
         """
         for PERP liquidations, the following arguments are required: uly, state
         for FUTURES liquidations, the following arguments are required: uly, state, alias
         FUTURES, MARGIN and OPTION liquidation request not currently supported by the below
         """
-
         while True:
             for pair in pairs:
                 if 'SWAP' in pair:
@@ -127,23 +137,20 @@ class OKX(Feed):
                 else:
                     continue
 
+                symbol = self.exchange_symbol_to_std_symbol(pair)
                 for status in (FILLED, UNFILLED):
-                    data = await self.http_conn.read(self.rest_endpoints[0].route('liquidations', sandbox=self.sandbox).format(instrument_type, status, uly))
+                    address = self.rest_endpoints[0].route('liquidations', sandbox=self.sandbox).format(instrument_type, status, uly)
+                    data = await self.http_conn.read(address)
                     data = json.loads(data, parse_float=Decimal)
                     timestamp = time.time()
                     if not data['data']:
-                        LOG.info('%s: no liquidation data received for %s @ %s', self.id, pair, self.rest_endpoints[0].route('liquidations', sandbox=self.sandbox).format(instrument_type, status, uly))
-                        continue
-                    if len(data['data'][0]['details']) == 0 or (len(data['data'][0]['details']) > 0 and last_update.get(pair) == data['data'][0]['details'][0]):
-                        continue
-                    for entry in data['data'][0]['details']:
-                        if pair in last_update:
-                            if entry == last_update[pair].get(status):
-                                break
-
-                        liq = Liquidation(
+                        # the usual answer for unfilled liquidations, which fill within seconds
+                        LOG.debug('%s: no liquidation data received for %s @ %s', self.id, pair, address)
+
+                    liquidations = [
+                        Liquidation(
                             self.id,
-                            self.exchange_symbol_to_std_symbol(pair),
+                            symbol,
                             BUY if entry['side'] == 'buy' else SELL,
                             Decimal(entry['sz']),
                             Decimal(entry['bkPx']),
@@ -152,22 +159,23 @@ class OKX(Feed):
                             self.timestamp_normalize(int(entry['ts'])),
                             raw=data
                         )
+                        for entry in (data['data'][0]['details'] if data['data'] else [])
+                    ]
+                    for liq in self.liquidation_watermark.batch(liquidations, symbol=symbol, status=status):
                         await self.callback(LIQUIDATIONS, liq, timestamp)
-                    last_update[pair][status] = data['data'][0]['details'][0]
                 await asyncio.sleep(0.1)
             await asyncio.sleep(60)
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.__reset()
-
-    def __reset(self):
-        self._l2_book = {}
         self.seq_no = {}
 
-    @classmethod
-    def instrument_type(cls, symbol: str):
-        return cls.info()['instrument_type'][symbol]
+    def _candle_stop(self, start: float) -> float:
+        if self.candle_interval == '1M':
+            opened = datetime.fromtimestamp(start, tz=self.CANDLE_TZ)
+            year, month = (opened.year + 1, 1) if opened.month == 12 else (opened.year, opened.month + 1)
+            return opened.replace(year=year, month=month).timestamp()
+        return start + self.candle_interval_map[self.candle_interval]
 
     async def _candle(self, msg: dict, timestamp: float):
         '''
@@ -190,9 +198,10 @@ class OKX(Feed):
                 ]
             ]
         }
+
+        the update carries no event time, so Candle.timestamp is None
         '''
         symbol = self.exchange_symbol_to_std_symbol(msg['arg']['instId'])
-        interval = self.candle_interval_map[self.candle_interval]
 
         for entry in msg['data']:
             closed = len(entry) > 8 and entry[8] == '1'
@@ -204,7 +213,7 @@ class OKX(Feed):
                 self.id,
                 symbol,
                 start,
-                start + interval,
+                self._candle_stop(start),
                 self.candle_interval,
                 None,
                 Decimal(entry[1]),
@@ -213,7 +222,7 @@ class OKX(Feed):
                 Decimal(entry[3]),
                 Decimal(entry[5]),
                 closed,
-                timestamp,
+                None,
                 raw=msg
             )
             await self.callback(CANDLES, candle, timestamp)
@@ -224,13 +233,15 @@ class OKX(Feed):
         """
         pair = self.exchange_symbol_to_std_symbol(msg['arg']['instId'])
         for update in msg['data']:
-            update_timestamp = self.timestamp_normalize(int(update['ts']))
+            if not update['bidPx'] or not update['askPx']:
+                # a side of the book is empty
+                continue
             t = Ticker(
                 self.id,
                 pair,
-                Decimal(update['bidPx']) if update['bidPx'] else Decimal(0),
-                Decimal(update['askPx']) if update['askPx'] else Decimal(0),
-                update_timestamp,
+                Decimal(update['bidPx']),
+                Decimal(update['askPx']),
+                self.timestamp_normalize(int(update['ts'])),
                 raw=update
             )
             await self.callback(TICKER, t, timestamp)
@@ -268,17 +279,18 @@ class OKX(Feed):
         """
         {
             "arg": {
-                "channel": "trades",
-                "instId": "BTC-USD-191227"
+                "channel": "trades-all",
+                "instId": "BTC-USDT"
             },
             "data": [
                 {
-                    "instId": "BTC-USD-191227",
-                    "tradeId": "9",
-                    "px": "0.016",
-                    "sz": "50",
+                    "instId": "BTC-USDT",
+                    "tradeId": "1077229381",
+                    "px": "77910.5",
+                    "sz": "0.16",
                     "side": "buy",
-                    "ts": "1597026383085"
+                    "ts": "1793569925719",
+                    "source": "0"
                 }
             ]
         }
@@ -327,22 +339,6 @@ class OKX(Feed):
         self.seq_no[pair] = sequence
         return True
 
-    def _parse_snapshot(self, symbol: str, data) -> OrderBook:
-        response = json.loads(data, parse_float=Decimal)
-        if response.get('code') not in ('0', 0):
-            raise ValueError(f"{self.id}: book snapshot for {symbol} returned code {response.get('code')!r}: {response.get('msg')!r}")
-        if not response.get('data'):
-            raise ValueError(f'{self.id}: book snapshot for {symbol} carried no data - is the instrument listed?')
-        entry = response['data'][0]
-
-        bids = {Decimal(price): Decimal(size) for price, size, *_ in entry['bids']}
-        asks = {Decimal(price): Decimal(size) for price, size, *_ in entry['asks']}
-        book = OrderBook(self.id, symbol, max_depth=self.max_depth, bids=bids, asks=asks)
-        book.timestamp = self.timestamp_normalize(int(entry['ts'])) if entry.get('ts') else None
-        book.sequence_number = int(entry['seqId']) if entry.get('seqId') is not None else None
-        book.raw = entry
-        return book
-
     async def _book(self, msg: dict, timestamp: float):
         if msg['action'] == 'snapshot':
             # snapshot
@@ -395,38 +391,50 @@ class OKX(Feed):
             else:
                 LOG.warning("%s: Unhandled event %s", self.id, msg)
         elif 'arg' in msg:
-            if self.websocket_channels[L2_BOOK] in msg['arg']['channel']:
+            channel = msg['arg']['channel']
+            if channel == self.websocket_channels[L2_BOOK]:
                 await self._book(msg, timestamp)
-            elif self.websocket_channels[TICKER] in msg['arg']['channel']:
+            elif channel == self.websocket_channels[TICKER]:
                 await self._ticker(msg, timestamp)
-            elif self.websocket_channels[TRADES] in msg['arg']['channel']:
+            elif channel in (self.websocket_channels[TRADES], 'trades'):
+                # trades is the aggregated channel
                 await self._trade(msg, timestamp)
-            elif self.websocket_channels[CANDLES] in msg['arg']['channel']:
+            elif channel.startswith(self.websocket_channels[CANDLES]):
                 await self._candle(msg, timestamp)
-            elif self.websocket_channels[FUNDING] in msg['arg']['channel']:
+            elif channel == self.websocket_channels[FUNDING]:
                 await self._funding(msg, timestamp)
-            elif self.websocket_channels[OPEN_INTEREST] in msg['arg']['channel']:
+            elif channel == self.websocket_channels[OPEN_INTEREST]:
                 await self._open_interest(msg, timestamp)
         else:
             LOG.warning("%s: Unhandled message %s", self.id, msg)
 
     async def subscribe(self, connection: AsyncConnection):
         channels = []
-        for chan in connection.subscription:
+        for chan, pairs in connection.subscription.items():
             if chan == LIQUIDATIONS:
-                self._spawn('liquidations', self._liquidations, connection.subscription[chan])
+                self._spawn('liquidations', self._liquidations, pairs)
                 continue
-            for pair in connection.subscription[chan]:
+            for pair in self._supported(chan, pairs):
                 channels.append(self.build_subscription(chan, pair))
 
         if channels:
             await connection.write(json.dumps({"op": "subscribe", "args": channels}))
 
+    def _supported(self, channel: str, pairs: list) -> list:
+        '''
+        returns a list of the supported instruments for a channel
+        '''
+        excluded = self.channel_excludes.get(self.exchange_channel_to_std(channel), ())
+        if not excluded:
+            return pairs
+        kept, skipped = [], []
+        for pair in pairs:
+            (skipped if str_to_symbol(self.exchange_symbol_to_std_symbol(pair)).type in excluded else kept).append(pair)
+        if skipped:
+            LOG.warning('%s: %s does not exist for %s instruments, not subscribing %d symbols (%s%s)', self.id, channel, ', '.join(excluded), len(skipped), ', '.join(skipped[:5]), ', ...' if len(skipped) > 5 else '')
+        return kept
+
     def build_subscription(self, channel: str, ticker: str) -> dict:
-        if channel in ['candle']:
-            subscription_dict = {"channel": f"{channel}{self.candle_interval}",
-                                 "instId": ticker}
-        else:
-            subscription_dict = {"channel": channel,
-                                 "instId": ticker}
-        return subscription_dict
+        if channel == self.websocket_channels[CANDLES]:
+            channel = f'{channel}{self.candle_interval}'
+        return {'channel': channel, 'instId': ticker}

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/cryptofeed/feed.py

@@ -23,7 +23,7 @@ from cryptofeed.defines import CANDLES, FUNDING, INDEX, L1_BOOK, L2_BOOK, L3_BOO
 from cryptofeed.exceptions import BidAskOverlapping
 from cryptofeed.exchange import Exchange
 from cryptofeed.types import OrderBook
-from cryptofeed.util.history import CandleWatermark, TradeWatermark
+from cryptofeed.util.history import CandleWatermark, LiquidationWatermark, TradeWatermark
 
 
 LOG = logging.getLogger(__name__)
@@ -71,7 +71,7 @@ class Feed(Exchange):
     async def keepalive(self, conn: AsyncConnection):
         raise NotImplementedError(f'{self.id}: keepalive_interval is set but keepalive() is not implemented')
 
-    def __init__(self, candle_interval=None, candle_closed_only=True, trade_history=False, candle_history=False, timeout=120, timeout_interval=30, retries=15, symbols=None, channels=None, subscription=None, callbacks=None, max_depth=0, checksum_validation=None, cross_check=False, exceptions=None, log_message_on_error=False, delay_start=0, http_proxy: StrOrURL = None, shutdown_timeout=10.0, **kwargs):
+    def __init__(self, candle_interval=None, candle_closed_only=True, trade_history=False, candle_history=False, liquidation_history=False, timeout=120, timeout_interval=30, retries=15, symbols=None, channels=None, subscription=None, callbacks=None, max_depth=0, checksum_validation=None, cross_check=False, exceptions=None, log_message_on_error=False, delay_start=0, http_proxy: StrOrURL = None, shutdown_timeout=10.0, **kwargs):
         """
         candle_interval: str
             the candle interval. See the specific exchange to see what intervals they support.
@@ -83,6 +83,8 @@ class Feed(Exchange):
             deliver historical trades sent on initial subscribe (not all exchange support this)
         candle_history: bool
             deliver historical candles sent on initial subscribe (not all exchange support this)
+        liquidation_history: bool
+            deliver historical liquidations sent on initial subscribe (not all exchanges support this)
         timeout: int
             wait time in seconds before feed is considered dead
             Set to -1 for infinite. quiet_channels are ignored
@@ -132,6 +134,7 @@ class Feed(Exchange):
         self.candle_closed_only = candle_closed_only
         self.trade_watermark = TradeWatermark(trade_history)
         self.candle_watermark = CandleWatermark(candle_history)
+        self.liquidation_watermark = LiquidationWatermark(liquidation_history)
         self.shutdown_timeout = shutdown_timeout
         self._conn_tg = None
         self._spawned = set()
@@ -204,6 +207,14 @@ class Feed(Exchange):
     def candle_history(self, value: bool):
         self.candle_watermark.history = value
 
+    @property
+    def liquidation_history(self) -> bool:
+        return self.liquidation_watermark.history
+
+    @liquidation_history.setter
+    def liquidation_history(self, value: bool):
+        self.liquidation_watermark.history = value
+
     def _build_subscription(self):
         self._ensure_symbol_mapping()
 

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/cryptofeed/nbbo.py

@@ -12,7 +12,7 @@ class NBBO(Callback):
         self.bids = {symbol: {} for symbol in symbols}
         self.asks = {symbol: {} for symbol in symbols}
 
-        self.last_update = None
+        self.last_update = {}
 
         super(NBBO, self).__init__(callback)
 
@@ -36,9 +36,9 @@ class NBBO(Callback):
             return
 
         # only write updates when a best bid / best ask changes
-        if self.last_update == update:
+        if self.last_update.get(book.symbol) == update:
             return
-        self.last_update = update
+        self.last_update[book.symbol] = update
 
         bid, ask, bid_feed, ask_feed = update
         await self.callback(book.symbol, bid['price'], bid['size'], ask['price'], ask['size'], bid_feed, ask_feed)

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/cryptofeed/util/history.py

@@ -36,6 +36,9 @@ def _group(rows, stream, extra=None) -> dict:
 
 class TradeWatermark:
     # at a high level, this ensures that a feed delivers every trade once and only once, and in time ascending order
+    # one watermark per stream, the symbol for trades
+    _stream_of = staticmethod(_symbol)
+
     def __init__(self, history: bool = False, key=None):
         self.history = history
         self.key = key
@@ -50,7 +53,7 @@ class TradeWatermark:
         key = self.key or _trade_key
         out = []
 
-        for sym, rows in _group(trades, _symbol, symbol).items():
+        for sym, rows in _group(trades, self._stream_of, symbol).items():
             rows.sort(key=lambda t: (t.timestamp, key(t)))
             mark = self._marks.get(sym)
 
@@ -70,7 +73,7 @@ class TradeWatermark:
         key = self.key or _trade_key
         trades = sorted(trades, key=lambda t: (t.timestamp, key(t))) if sort else list(trades)
         for trade in trades:
-            self._note(trade.symbol, trade, key)
+            self._note(self._stream_of(trade), trade, key)
         return trades
 
     def expect(self, symbols):
@@ -111,6 +114,29 @@ class TradeWatermark:
             mark[1][key(trade)] += 1
 
 
+def _liquidation_stream(liquidation):
+    return (liquidation.symbol, liquidation.status)
+
+
+def _liquidation_key(liquidation):
+    # liquidations carry no id
+    return (liquidation.side, liquidation.price, liquidation.quantity)
+
+
+class LiquidationWatermark(TradeWatermark):
+    # the trade watermark per (symbol, status): a venue lists its filled and unfilled liquidations separately
+    _stream_of = staticmethod(_liquidation_stream)
+
+    def __init__(self, history: bool = False):
+        super().__init__(history, _liquidation_key)
+
+    def get(self, symbol, status):
+        return super().get((symbol, status))
+
+    def batch(self, liquidations, symbol=None, status=None) -> list:
+        return super().batch(liquidations, None if symbol is None else (symbol, status))
+
+
 class CandleWatermark:
     # at a high level, this ensures that a feed delivers every candle
     # once and only once, and in time ascending order

{cryptofeed-3.0.2 → cryptofeed-3.0.3/cryptofeed.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cryptofeed
-Version: 3.0.2
+Version: 3.0.3
 Summary: Cryptocurrency Exchange Websocket Data Feed Handler
 Author-email: Bryant Moscon <bmoscon@gmail.com>
 License-Expression: AGPL-3.0-or-later
@@ -171,8 +171,8 @@ cryptofeed received the message that produced the callback. The objects are defi
   set when the venue provides them.
 * `Candle.closed` is `True` once the bar is final, by default only closed candles are delivered.
   (`candle_closed_only=False` also delivers each update of the open bar).
-* `trade_history` and `candle_history` control whether the batch of recent trades or candles some venues send on
-  subscribe is delivered, by default it is `False`.
+* `trade_history`, `candle_history` and `liquidation_history` control whether the batch of recent trades, candles or
+  liquidations some venues send on subscribe is delivered, by default it is `False`.
 
 ## Backends
 

{cryptofeed-3.0.2 → cryptofeed-3.0.3}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cryptofeed"
-version = "3.0.2"
+version = "3.0.3"
 description = "Cryptocurrency Exchange Websocket Data Feed Handler"
 readme = "README.md"
 license = "AGPL-3.0-or-later"
@@ -97,7 +97,6 @@ define-macros = [["CYTHON_WITHOUT_ASSERTIONS", ""]]
 
 [tool.cibuildwheel]
 build = "cp313-* cp314-* cp314t-* cp315-* cp315t-*"
-skip = "*musllinux*"
 test-command = "python -c \"import sys, sysconfig; from cryptofeed import FeedHandler; from cryptofeed.types import COMPILED_WITH_ASSERTIONS; assert COMPILED_WITH_ASSERTIONS is False; assert not (sysconfig.get_config_var('Py_GIL_DISABLED') and sys._is_gil_enabled()), 'importing cryptofeed re-enabled the GIL'\""
 
 [tool.cibuildwheel.linux]