cryptofeed 3.0.0__tar.gz → 3.0.2__tar.gz

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

@@ -1,5 +1,51 @@
 ## Changelog
 
+### 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
+* Bugfix: Bybit open interest now uses `singleOpenInterest`; `openInterest` counts both sides (2x other exchanges)
+* Bugfix: reconnection of unstable feeds adjusted with backoffs
+* Bugfix: the silence watchdog starts only after subscribe
+* Bugfix: HTTP requests time out after 60s (10 s to connect)
+* Bugfix: log_message_on_error raised UnboundLocalError when the read failed before the first message
+* Bugfix: improvements to `log` section in config
+* Update: the default Feed `retries` is now 15
+* Update: Python 3.15 and free-threaded 3.15t are built, tested and shipped as wheels
+* Bugfix: Gemini no longer emits trades for symbols that were only subscribed to L2_BOOK
+* Update: OKX websocket endpoints no longer use port 8443, which OKX retires on 2026-10-31
+* Bugfix: Bithumb no longer emits book or ticker updates for symbols that were not subscribed to that channel
+* Bugfix: Various data improvements across exchanges
+* Bugfix: connection hardening, improved retries, improved snapshot syncing
+* Bugfix: Poloniex trades corrected
+* Bugfix: Phemex spot values were scaled incorrectly
+* Bugfix: set Gate Futures decimal request header correctly
+* Bugfix: Gemini perpetual instruments resolved correctly
+* Bugfix: Hyperliquid spot instruments resolved correctly
+* Bugfix: Poloniex instruments resolved correctly
+* Bugfix: Bitfinex max_depth limited correctly when checksum validation is enabled
+* Bugfix: Bybit ticker subscription fixed
+* Bugfix: Binance Funding data correction
+* Bugfix: backends handle many feeds, single failure scenario correctly
+* Bugfix: Postgres backend retries through a PostgreSQL restart instead of dying
+* Bugfix: book snapshots serialized with numeric_type=Decimal were not valid JSON. price keys now strings
+* Bugfix: Redis incorrectly ignored `socket` path
+* Update: expiry dates in normalized symbols now zero padded for every exchange (eg. BTC-USD-26H05)
+* Bugfix: the shutdown enforced on backend writers
+* Bugfix: cancelling a backend writer no longer loses messages from the stats counters
+* Bugfix: a backend instance can be reused across runs
+* Bugfix: BookMongo stores deltas as book documents and accept numeric_type=float
+* Bugfix: Redis Stream and ZSet backends retry only rejected commands
+* Bugfix: Postgres backends render dict and list values as JSON
+* Feature: Postgres backends define table layouts and provide create_table_sql()
+* Update: Postgres backends default numeric_type to Decimal, so NUMERIC columns receive exact values
+
+### 3.0.1 (2026-09-27)
+ * Update: Gate.io -> Gate rebranding
+ * Bugfix: Binance Futures and Binance Delivery L2_BOOK with `depth_interval='250ms'` subscribed to `<symbol>@depth@250ms`, which Binance accepts but never sends data on. The default interval now uses the bare `<symbol>@depth` stream.
+ * Bugfix: `depth_interval=None` on Binance Futures and Binance Delivery produced an invalid subscription. `None` now resolves to the venue default
+ * Bugfix: Coinbase, OKX, Gate, Kraken data quality issues
+ * Bugfix: dYdX subscribe/reconnect connection issues
+
 ### 3.0.0 (2026-09-21)
  * Feature: New asyncio core
  * Update: REST endpoints removed (trading functionality moves to the cryptotrade project)
@@ -120,7 +166,7 @@
  * Update: Exchange name change OKEx -> OKX
  * Bugfix: OKX candle REST code was setting values incorrectly
  * Update: OKX now uses v5 for all connections (REST and WS). Update endpoints to new exchange name: okex.com -> okx.com
- 
+
 ### 2.2.0 (2021-02-16)
  * Feature: New exchange: Bit.com
  * Feature: Rework how exchanges that have multiple websocket endpoints are managed and configured.
@@ -147,7 +193,7 @@
  * Feature: Add ByBit sandbox endpoints.
  * Bugfix: Fix calculation in OrderInfo on Binance.
  * Feature: Support list of bootstrap servers for Kafka backend.
- * Feature: Add OrderInfo and Fills zmq callbacks 
+ * Feature: Add OrderInfo and Fills zmq callbacks
 
 ### 2.1.1 (2021-11-29)
  * Bugfix: Position data type missing side field.

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

@@ -1,16 +1,17 @@
 Metadata-Version: 2.4
 Name: cryptofeed
-Version: 3.0.0
+Version: 3.0.2
 Summary: Cryptocurrency Exchange Websocket Data Feed Handler
 Author-email: Bryant Moscon <bmoscon@gmail.com>
 License-Expression: AGPL-3.0-or-later
 Project-URL: Homepage, https://github.com/bmoscon/cryptofeed
-Keywords: cryptocurrency,bitcoin,btc,feed handler,market feed,market data,crypto assets,Trades,Tickers,BBO,Funding,Open Interest,Liquidation,Order book,Bid,Ask,Binance,Binance Delivery,Binance Futures,Binance US,Bitfinex,bitFlyer,Bitget,Bithumb,Bitstamp,Bybit,Coinbase,Crypto.com,Deribit,Gate.io,Gate.io Futures,dYdX,Gemini,Hyperliquid,HTX,HTX Swap,Independent Reserve,Kraken,Kraken Futures,KuCoin,MEXC,OKX,Phemex,Poloniex,Upbit
+Keywords: cryptocurrency,bitcoin,btc,feed handler,market feed,market data,crypto assets,Trades,Tickers,BBO,Funding,Open Interest,Liquidation,Order book,Bid,Ask,Binance,Binance Delivery,Binance Futures,Binance US,Bitfinex,bitFlyer,Bitget,Bithumb,Bitstamp,Bybit,Coinbase,Crypto.com,Deribit,Gate,Gate Futures,dYdX,Gemini,Hyperliquid,HTX,HTX Swap,Independent Reserve,Kraken,Kraken Futures,KuCoin,MEXC,OKX,Phemex,Poloniex,Upbit
 Classifier: Intended Audience :: Developers
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
 Classifier: Framework :: AsyncIO
 Classifier: Operating System :: POSIX :: Linux
@@ -70,8 +71,8 @@ Handles multiple cryptocurrency exchange data feeds and returns normalized and s
 * [Coinbase](https://www.coinbase.com/)
 * [Crypto.com](https://www.crypto.com)
 * [Deribit](https://www.deribit.com/)
-* [Gate.io](https://www.gate.io/)
-* [Gate.io Futures](https://www.gate.io/futures_center)
+* [Gate](https://www.gate.com/)
+* [Gate Futures](https://www.gate.com/futures)
 * [dYdX v4](https://dydx.trade/)
 * [Gemini](https://gemini.com/)
 * [Hyperliquid](https://hyperliquid.xyz/)
@@ -152,6 +153,27 @@ Cryptofeed supports the following public data channels from exchanges
 * INDEX
 * CANDLES - Candlestick / K-Line data.
 
+## Normalized data
+
+Every callback receives two arguments: a normalized object and `receipt_timestamp`, the time (float epoch seconds)
+cryptofeed received the message that produced the callback. The objects are defined in `cryptofeed/types.pyx` (`Trade`,
+`Ticker`, `OrderBook`, `L1Book`, `Candle`, `Funding`, `OpenInterest`, `Liquidation`, `Index`) and share these rules:
+
+* `exchange` is the venue id and `symbol` the normalized name: `BASE-QUOTE` for spot, `BASE-QUOTE-PERP` for
+  perpetuals, `BASE-QUOTE-<expiry>` for dated futures with the expiry as a two-digit year, a futures month code and
+  a zero-padded day (`BTC-USD-26H05`), and `BASE-QUOTE-<strike>-<expiry>-CALL|PUT` for options.
+* Prices, sizes, rates and volumes are `Decimal`. `numeric_type` on a backend or `to_dict()` converts them.
+* `timestamp` is the venue's event time in float epoch seconds. `timestamp` is `None` when the venue does not provide
+  a timestamp and backends then store the receipt time in its place.
+* `Trade.side` is the taker's side. `Trade.id` is the venue's id or `None`.
+* `OrderBook.book` holds the full local book (`.bids`, `.asks`). `delta` is `None` for a snapshot and otherwise lists
+  the levels that changed as `(price, size)` with size 0 for a removed level. `sequence_number` and `checksum` are
+  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`.
+
 ## Backends
 
 Cryptofeed supports `backend` callbacks that will write directly to storage or other interfaces.

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

@@ -21,8 +21,8 @@ Handles multiple cryptocurrency exchange data feeds and returns normalized and s
 * [Coinbase](https://www.coinbase.com/)
 * [Crypto.com](https://www.crypto.com)
 * [Deribit](https://www.deribit.com/)
-* [Gate.io](https://www.gate.io/)
-* [Gate.io Futures](https://www.gate.io/futures_center)
+* [Gate](https://www.gate.com/)
+* [Gate Futures](https://www.gate.com/futures)
 * [dYdX v4](https://dydx.trade/)
 * [Gemini](https://gemini.com/)
 * [Hyperliquid](https://hyperliquid.xyz/)
@@ -103,6 +103,27 @@ Cryptofeed supports the following public data channels from exchanges
 * INDEX
 * CANDLES - Candlestick / K-Line data.
 
+## Normalized data
+
+Every callback receives two arguments: a normalized object and `receipt_timestamp`, the time (float epoch seconds)
+cryptofeed received the message that produced the callback. The objects are defined in `cryptofeed/types.pyx` (`Trade`,
+`Ticker`, `OrderBook`, `L1Book`, `Candle`, `Funding`, `OpenInterest`, `Liquidation`, `Index`) and share these rules:
+
+* `exchange` is the venue id and `symbol` the normalized name: `BASE-QUOTE` for spot, `BASE-QUOTE-PERP` for
+  perpetuals, `BASE-QUOTE-<expiry>` for dated futures with the expiry as a two-digit year, a futures month code and
+  a zero-padded day (`BTC-USD-26H05`), and `BASE-QUOTE-<strike>-<expiry>-CALL|PUT` for options.
+* Prices, sizes, rates and volumes are `Decimal`. `numeric_type` on a backend or `to_dict()` converts them.
+* `timestamp` is the venue's event time in float epoch seconds. `timestamp` is `None` when the venue does not provide
+  a timestamp and backends then store the receipt time in its place.
+* `Trade.side` is the taker's side. `Trade.id` is the venue's id or `None`.
+* `OrderBook.book` holds the full local book (`.bids`, `.asks`). `delta` is `None` for a snapshot and otherwise lists
+  the levels that changed as `(price, size)` with size 0 for a removed level. `sequence_number` and `checksum` are
+  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`.
+
 ## Backends
 
 Cryptofeed supports `backend` callbacks that will write directly to storage or other interfaces.

{cryptofeed-3.0.0 → cryptofeed-3.0.2}/cryptofeed/backends/backend.py

@@ -35,11 +35,12 @@ class RetryPolicy:
     max_attempts: int = 5
     base: float = 0.5
     jitter: bool = True
+    max_delay: float = 60.0
 
     def delay(self, attempt: int) -> float:
-        d = self.base * (2 ** (attempt - 1))
+        d = min(self.base * (2 ** (attempt - 1)), self.max_delay)
         if self.jitter:
-            d *= random.uniform(0.5, 1.5)
+            d *= random.uniform(1.0, 1.5)
         return d
 
 
@@ -61,6 +62,24 @@ class BackendStats:
         return self.written + self.conflicts
 
 
+async def finish_writers(backends: list, deadline: float):
+    if not backends:
+        return
+    try:
+        async with asyncio.timeout(deadline):
+            for backend in backends:
+                await backend.signal()
+
+            pending = [backend.worker for backend in backends if not backend.worker.done()]
+            if pending:
+                await asyncio.wait(pending)
+    except TimeoutError:
+        pending = [backend for backend in backends if not backend.worker.done()]
+        LOG.warning('backend flush exceeded the %.1fs shutdown deadline - cancelling %d writer(s)', deadline, len(pending))
+        for backend in pending:
+            backend.worker.cancel()
+
+
 class BackendQueue:
     hand_off = False
     max_depth = 10_000
@@ -71,6 +90,7 @@ class BackendQueue:
     retry = RetryPolicy()
     retryable_exceptions: tuple = ()
     SENTINEL_TIMEOUT = 1.0
+    CLOSE_TIMEOUT = 0.25
     BLOCK_POLL = 0.25
     FAILURE_LEVEL = logging.ERROR
 
@@ -105,6 +125,7 @@ class BackendQueue:
             self._orphaned = False
             self._owners = 0
             self._owners_seen = []
+            self._shared = False
             self._inflight = []
 
     @property
@@ -117,17 +138,22 @@ class BackendQueue:
                             conflicts=self._conflicts, retries=self._retries, last_error=self._last_error,
                             last_write_ts=self._last_write_ts, hand_off=bool(getattr(self, 'hand_off', False)))
 
-    def start_writer(self, tg: asyncio.TaskGroup, name: str, owner=None):
+    def start_writer(self, tg: asyncio.TaskGroup, name: str, owner=None, shared: bool = False):
         self._init_state()
         self._owners += 1
-        if getattr(self, 'started', False):
+        worker = getattr(self, 'worker', None)
+
+        if worker is not None and not worker.done():
             if owner is not None and any(seen is owner for seen in self._owners_seen):
                 LOG.info('%s: one feed is using this backend instance for more than one channel', type(self).__name__)
-            else:
-                LOG.warning('%s: a second feed is sharing this backend instance', type(self).__name__)
+            elif not self._shared:
+                LOG.warning('%s: a second feed is sharing this backend instance - if the first feed fails, the writer stops with it', type(self).__name__)
             self._owners_seen.append(owner)
             return None
-        self._owners_seen.append(owner)
+
+        self._owners_seen = [owner]
+        self._shared = shared
+        self._orphaned = False
         self.queue = asyncio.Queue(maxsize=self.max_depth)
         self._stopping = asyncio.Event()
         self.worker = tg.create_task(self.writer(), name=name)
@@ -139,32 +165,39 @@ class BackendQueue:
         if stopping is not None:
             stopping.set()
 
-    async def stop(self):
+    def release_owner(self) -> bool:
         if not getattr(self, 'started', False):
             return False
-
         self._owners -= 1
         if self._owners_seen:
             self._owners_seen.pop()
-        if self._owners > 0:
-            return False
+        return self._owners <= 0
 
+    async def signal(self):
         self._stopping.set()
+        if self.worker.done():
+            return
         try:
             self.queue.put_nowait(SHUTDOWN_SENTINEL)
-            return True
         except asyncio.QueueFull:
-            pass
+            if self.overflow == 'block':
+                await self.queue.put(SHUTDOWN_SENTINEL)
+            else:
+                self.queue.get_nowait()
+                self._count_overflow_drop()
+                self.queue.put_nowait(SHUTDOWN_SENTINEL)
 
-        if self.overflow == 'block':
-            with suppress(TimeoutError):
-                await asyncio.wait_for(self.queue.put(SHUTDOWN_SENTINEL), self.SENTINEL_TIMEOUT)
-                return True
+    async def stop(self) -> bool:
+        if not self.release_owner():
+            return False
+        try:
+            async with asyncio.timeout(self.SENTINEL_TIMEOUT):
+                await self.signal()
+        except TimeoutError:
             LOG.warning('%s: did not drain within %.1fs of shutdown', type(self).__name__, self.SENTINEL_TIMEOUT)
-
-        self.queue.get_nowait()
-        self._count_overflow_drop()
-        self.queue.put_nowait(SHUTDOWN_SENTINEL)
+            self.queue.get_nowait()
+            self._count_overflow_drop()
+            self.queue.put_nowait(SHUTDOWN_SENTINEL)
         return True
 
     async def write(self, data):
@@ -219,12 +252,17 @@ class BackendQueue:
 
     async def writer(self):
         self.running = True
+        cancelled = False
+
         try:
             while self.running:
                 batch = await self._next_batch()
                 if batch:
                     await self._write_with_retry(batch)
             await self.flush(self.flush_deadline)
+        except asyncio.CancelledError:
+            cancelled = True
+            raise
         finally:
             self.running = False
             abandoned = len(self._inflight)
@@ -239,7 +277,14 @@ class BackendQueue:
                 LOG.warning('%s: writer stopped with %d message(s) undelivered - counted as dropped',
                             type(self).__name__, abandoned)
             try:
-                await self.close()
+                if cancelled:
+                    async with asyncio.timeout(self.CLOSE_TIMEOUT):
+                        await self.close()
+                else:
+                    await self.close()
+            except TimeoutError:
+                self._last_error = 'close() timed out'
+                LOG.warning('%s: close() did not return within %.2fs of cancellation', type(self).__name__, self.CLOSE_TIMEOUT)
             except Exception as e:
                 self._last_error = f'{type(e).__name__}: {e}'
                 LOG.exception('%s: close() failed - data not yet flushed may be lost', type(self).__name__)
@@ -251,6 +296,7 @@ class BackendQueue:
             return []
 
         batch = [first]
+        self._inflight = batch
         loop = asyncio.get_running_loop()
         deadline = loop.time() + self.batch_interval
 
@@ -351,10 +397,11 @@ class BackendQueue:
                     await self._write_with_retry(batch)
                     del pending[:len(batch)]
         except TimeoutError:
-            self._inflight = []
-            self._dropped_failed += len(pending)
             LOG.warning('%s: flush deadline (%.1fs) hit - %d messages dropped',
                         type(self).__name__, deadline, len(pending))
+        finally:
+            self._inflight = []
+            self._dropped_failed += len(pending)
 
     async def connect(self):
         pass

{cryptofeed-3.0.0 → cryptofeed-3.0.2}/cryptofeed/backends/mongo.py

@@ -38,7 +38,7 @@ class MongoCallback(BackendQueue):
         none_to: any
             if not None, convert None values to this value before inserting into MongoDB
         numeric_type: type
-            type to convert numeric values to before inserting into MongoDB. Defaults to str
+            type to convert numeric values to before inserting into MongoDB. Defaults to str, but can be float
         client_options: dict
             passed straight to pymongo's AsyncMongoClient - username/password, tls,
             connectTimeoutMS, serverSelectionTimeoutMS and anything else the driver accepts.
@@ -80,21 +80,26 @@ class MongoCallback(BackendQueue):
             return value
         return dt.fromtimestamp(value, tz=timezone.utc)
 
+    @staticmethod
+    def _side(levels) -> bytes:
+        pairs = levels.items() if isinstance(levels, dict) else levels
+        return bson.encode({str(price): size for price, size in pairs})
+
     def _document(self, update: dict) -> dict:
         update['timestamp'] = self._datetime(update['timestamp'])
         update['receipt_timestamp'] = self._datetime(update['receipt_timestamp'])
 
-        if 'book' in update:
-            delta = 'delta' in update
-            source = update['delta'] if delta else update['book']
+        if 'book' in update or 'delta' in update:
+            snapshot = 'book' in update
+            source = update['book'] if snapshot else update['delta']
             return {
                 'exchange': update['exchange'],
                 'symbol': update['symbol'],
                 'timestamp': update['timestamp'],
                 'receipt_timestamp': update['receipt_timestamp'],
-                'delta': delta,
-                'bid': bson.encode(source['bid']),
-                'ask': bson.encode(source['ask']),
+                'delta': not snapshot,
+                'bid': self._side(source['bid']),
+                'ask': self._side(source['ask']),
             }
         return update
 

{cryptofeed-3.0.0 → cryptofeed-3.0.2}/cryptofeed/backends/postgres.py

@@ -5,6 +5,7 @@ Please see the LICENSE file for the terms and conditions
 associated with this software.
 '''
 import re
+from decimal import Decimal
 from collections import defaultdict
 from datetime import datetime as dt, timezone
 
@@ -16,6 +17,7 @@ from cryptofeed.defines import CANDLES, FUNDING, OPEN_INTEREST, TICKER, TRADES,
 
 
 _COMMON_FIELDS = frozenset({'exchange', 'symbol', 'timestamp', 'receipt_timestamp', 'receipt'})
+_COMMON_COLUMNS = (('timestamp', 'TIMESTAMPTZ'), ('receipt_timestamp', 'TIMESTAMPTZ'), ('exchange', 'TEXT'), ('symbol', 'TEXT'))
 _REJECTED = (asyncpg.exceptions.DataError, asyncpg.exceptions.IntegrityConstraintViolationError)
 
 
@@ -30,6 +32,8 @@ def _render(value):
         return None
     if isinstance(value, bool):
         return 'true' if value else 'false'
+    if isinstance(value, (dict, list)):
+        return json.dumps(value)
     return str(value)
 
 
@@ -47,10 +51,16 @@ def _ident(data: dict) -> str:
 
 
 class PostgresCallback(BackendQueue):
-    retryable_exceptions = (OSError, asyncpg.PostgresConnectionError)
+    retryable_exceptions = (OSError, asyncpg.PostgresConnectionError, asyncpg.OperatorInterventionError)
     fields = frozenset()
+    COLUMNS = (('data', 'JSONB'),)
 
-    def __init__(self, host='127.0.0.1', user=None, pw=None, db=None, port=None, table=None, custom_columns: dict = None, none_to=None, numeric_type=float, **kwargs):
+    @classmethod
+    def create_table_sql(cls, table: str = None) -> str:
+        columns = ', '.join(f'"{name}" {sql_type}' for name, sql_type in _COMMON_COLUMNS + cls.COLUMNS)
+        return f'CREATE TABLE IF NOT EXISTS {table or cls.default_table} (id serial PRIMARY KEY, {columns})'
+
+    def __init__(self, host='127.0.0.1', user=None, pw=None, db=None, port=None, table=None, custom_columns: dict = None, none_to=None, numeric_type=Decimal, **kwargs):
         """
         host: str
             Database host address
@@ -68,6 +78,8 @@ class PostgresCallback(BackendQueue):
             Note: to store BOOK data in a JSONB column, include a 'data' field, e.g. {'symbol': 'symbol', 'data': 'json_data'}
             Both halves are checked when the backend first connects: an unknown column name
             or a field this callback never produces is an error, not a column of NULLs.
+        numeric_type: type
+            cast numerics to this value. Decimal (default) for NUMERIC columns
         """
         super().__init__(**kwargs)
         self.pool = None
@@ -189,6 +201,7 @@ class PostgresCallback(BackendQueue):
 
 class TradePostgres(PostgresCallback, BackendCallback):
     default_table = TRADES
+    COLUMNS = (('side', 'TEXT'), ('amount', 'NUMERIC'), ('price', 'NUMERIC'), ('trade_id', 'TEXT'), ('order_type', 'TEXT'))
     fields = _COMMON_FIELDS | {'side', 'amount', 'price', 'id', 'type'}
 
     def _default_row(self, data, ts, rts):
@@ -197,6 +210,7 @@ class TradePostgres(PostgresCallback, BackendCallback):
 
 class FundingPostgres(PostgresCallback, BackendCallback):
     default_table = FUNDING
+    COLUMNS = (('mark_price', 'NUMERIC'), ('rate', 'NUMERIC'), ('next_funding_time', 'TIMESTAMPTZ'), ('predicted_rate', 'NUMERIC'))
     fields = _COMMON_FIELDS | {'mark_price', 'rate', 'next_funding_time', 'predicted_rate'}
 
     def _prepare(self, data):
@@ -208,6 +222,7 @@ class FundingPostgres(PostgresCallback, BackendCallback):
 
 class TickerPostgres(PostgresCallback, BackendCallback):
     default_table = TICKER
+    COLUMNS = (('bid', 'NUMERIC'), ('ask', 'NUMERIC'))
     fields = _COMMON_FIELDS | {'bid', 'ask'}
 
     def _default_row(self, data, ts, rts):
@@ -216,6 +231,7 @@ class TickerPostgres(PostgresCallback, BackendCallback):
 
 class OpenInterestPostgres(PostgresCallback, BackendCallback):
     default_table = OPEN_INTEREST
+    COLUMNS = (('open_interest', 'NUMERIC'),)
     fields = _COMMON_FIELDS | {'open_interest'}
 
     def _default_row(self, data, ts, rts):
@@ -224,6 +240,7 @@ class OpenInterestPostgres(PostgresCallback, BackendCallback):
 
 class IndexPostgres(PostgresCallback, BackendCallback):
     default_table = INDEX
+    COLUMNS = (('price', 'NUMERIC'),)
     fields = _COMMON_FIELDS | {'price'}
 
     def _default_row(self, data, ts, rts):
@@ -232,6 +249,7 @@ class IndexPostgres(PostgresCallback, BackendCallback):
 
 class LiquidationsPostgres(PostgresCallback, BackendCallback):
     default_table = LIQUIDATIONS
+    COLUMNS = (('side', 'TEXT'), ('quantity', 'NUMERIC'), ('price', 'NUMERIC'), ('trade_id', 'TEXT'), ('status', 'TEXT'))
     fields = _COMMON_FIELDS | {'side', 'quantity', 'price', 'id', 'status'}
 
     def _default_row(self, data, ts, rts):
@@ -240,6 +258,7 @@ class LiquidationsPostgres(PostgresCallback, BackendCallback):
 
 class BookPostgres(PostgresCallback, BackendBookCallback):
     default_table = 'book'
+    COLUMNS = (('data', 'JSONB'),)
     fields = _COMMON_FIELDS | {'data', 'book', 'delta'}
 
     def __init__(self, *args, snapshots_only=False, snapshot_interval=1000, **kwargs):
@@ -261,6 +280,7 @@ class BookPostgres(PostgresCallback, BackendBookCallback):
 
 class CandlesPostgres(PostgresCallback, BackendCallback):
     default_table = CANDLES
+    COLUMNS = (('candle_start', 'TIMESTAMPTZ'), ('candle_stop', 'TIMESTAMPTZ'), ('interval', 'TEXT'), ('trades', 'INTEGER'), ('open', 'NUMERIC'), ('close', 'NUMERIC'), ('high', 'NUMERIC'), ('low', 'NUMERIC'), ('volume', 'NUMERIC'), ('closed', 'BOOLEAN'))
     fields = _COMMON_FIELDS | {'start', 'stop', 'interval', 'trades', 'open', 'close', 'high', 'low', 'volume', 'closed'}
 
     def _prepare(self, data):