Qubx 0.7.4__cp312-cp312-manylinux_2_39_x86_64.whl → 0.7.6__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/runner.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, cast
 
 import numpy as np
 import pandas as pd
@@ -19,6 +19,7 @@ from qubx.core.interfaces import (
     IMetricEmitter,
     IStrategy,
     IStrategyContext,
+    IStrategyNotifier,
     ITimeProvider,
     StrategyState,
 )
@@ -59,6 +60,7 @@ class SimulationRunner:
     portfolio_log_freq: str
     ctx: IStrategyContext
     logs_writer: InMemoryLogsWriter
+    notifier: IStrategyNotifier | None
 
     account: CompositeAccountProcessor
     channel: CtrlChannel
@@ -85,6 +87,7 @@ class SimulationRunner:
         emitter: IMetricEmitter | None = None,
         strategy_state: StrategyState | None = None,
         initializer: BasicStrategyInitializer | None = None,
+        notifier: IStrategyNotifier | None = None,
         warmup_mode: bool = False,
     ):
         """
@@ -101,11 +104,12 @@ class SimulationRunner:
         """
         self.setup = setup
         self.data_config = data_config
-        self.start = pd.Timestamp(start)
-        self.stop = pd.Timestamp(stop)
+        self.start = cast(pd.Timestamp, pd.Timestamp(start))
+        self.stop = cast(pd.Timestamp, pd.Timestamp(stop))
         self.account_id = account_id
         self.portfolio_log_freq = portfolio_log_freq
         self.emitter = emitter
+        self.notifier = notifier
         self.strategy_state = strategy_state if strategy_state is not None else StrategyState()
         self.initializer = initializer
         self.warmup_mode = warmup_mode
@@ -282,7 +286,7 @@ class SimulationRunner:
         else:
             _run = self._process_strategy
 
-        start, stop = pd.Timestamp(start), pd.Timestamp(stop)
+        start, stop = cast(pd.Timestamp, pd.Timestamp(start)), cast(pd.Timestamp, pd.Timestamp(stop))
         total_duration = stop - start
         update_delta = total_duration / 100
         prev_dt = np.datetime64(start)
@@ -474,6 +478,7 @@ class SimulationRunner:
             aux_data_provider=self._aux_data_reader,
             emitter=self.emitter,
             strategy_state=self.strategy_state,
+            notifier=self.notifier,
             initializer=self.initializer,
         )
 

qubx/connectors/xlighter/account.py

@@ -202,15 +202,6 @@ class LighterAccountProcessor(BasicAccountProcessor):
                 # Add fee to position's commission tracking
                 position.commissions += deal.fee_amount
 
-                self.__debug(
-                    f"Tracked fee for {instrument.symbol}: {deal.fee_amount:.6f} {deal.fee_currency} "
-                    f"(total commissions: {position.commissions:.6f})"
-                )
-
-        self.__debug(
-            f"Processed {len(deals)} deal(s) for {instrument.symbol} - fees tracked, positions synced from account_all"
-        )
-
     def process_order(self, order: Order, update_locked_value: bool = True) -> None:
         """
         Override process_order to handle Lighter's server-assigned order IDs.
@@ -228,8 +219,7 @@ class LighterAccountProcessor(BasicAccountProcessor):
         if order.client_id and order.client_id in self._active_orders:
             # Get the existing order stored under client_id
             existing_order = self._active_orders[order.client_id]
-
-            self.__debug(f"Migrating order: client_id={order.client_id} → server_id={order.id}")
+            # self.__debug(f"Migrating order: client_id={order.client_id} → server_id={order.id}")
 
             # Remove from old location
             self._active_orders.pop(order.client_id)
@@ -383,10 +373,13 @@ class LighterAccountProcessor(BasicAccountProcessor):
                 if position.last_update_price == 0 or np.isnan(position.last_update_price):
                     position.last_update_price = pos_state.avg_entry_price
 
-                self.__debug(
-                    f"Synced position: {instrument.symbol} = {pos_state.quantity:+.4f} "
-                    f"@ avg_price={pos_state.avg_entry_price:.4f}"
-                )
+            updated_positions_str = "\n\t".join(
+                [
+                    f"{instrument.symbol} --> {pos_state.quantity:+.4f} @ {pos_state.avg_entry_price:.4f}"
+                    for instrument, pos_state in position_states.items()
+                ]
+            )
+            self.__debug(f"Updated positions:\n\t{updated_positions_str}")
 
             if not self._account_positions_initialized:
                 self._account_positions_initialized = True
@@ -399,10 +392,10 @@ class LighterAccountProcessor(BasicAccountProcessor):
                 # False means not a snapshot
                 self.channel.send((instrument, "deals", [deal], False))
 
-                self.__debug(
-                    f"Sent deal: {instrument.symbol} {deal.amount:+.4f} @ {deal.price:.4f} "
-                    f"fee={deal.fee_amount:.6f} (id={deal.id})"
-                )
+                # self.__debug(
+                #     f"Sent deal: {instrument.symbol} {deal.amount:+.4f} @ {deal.price:.4f} "
+                #     f"fee={deal.fee_amount:.6f} (id={deal.id})"
+                # )
 
             # Funding payments are handled by the data provider, so I commented them here to avoid double sending
             # Send funding payments through channel
@@ -419,27 +412,19 @@ class LighterAccountProcessor(BasicAccountProcessor):
             logger.exception(e)
 
     async def _handle_account_all_orders_message(self, message: dict):
-        """
-        Handle account_all_orders WebSocket messages.
-
-        Parses order updates and sends Order objects through channel.
-
-        Follows CCXT pattern: parse → send through channel → framework handles rest.
-        """
         try:
-            # Parse message into list of (Instrument, Order) tuples
             orders = parse_account_all_orders_message(message, self.instrument_loader)
 
-            # Send each order through channel (CCXT pattern)
-            for instrument, order in orders:
-                # Send: (instrument, "order", order, False)
-                # False means not a snapshot
-                self.channel.send((instrument, "order", order, False))
+            _d_msg = "\n\t".join([f"{order.id} ({order.instrument.symbol})" for order in orders])
+            logger.debug(f"Received {len(orders)} orders: \n\t{_d_msg}")
+
+            for order in orders:
+                self.channel.send((order.instrument, "order", order, False))
 
-                self.__debug(
-                    f"Sent order: {instrument.symbol} {order.side} {order.quantity:+.4f} @ {order.price:.4f} "
-                    f"[{order.status}] (order_id={order.id})"
-                )
+                # self.__debug(
+                #     f"Sent order: {instrument.symbol} {order.side} {order.quantity:+.4f} @ {order.price:.4f} "
+                #     f"[{order.status}] (order_id={order.id})"
+                # )
 
         except Exception as e:
             self.__error(f"Error handling account_all_orders message: {e}")
@@ -459,10 +444,13 @@ class LighterAccountProcessor(BasicAccountProcessor):
             for currency, balance in balances.items():
                 self.update_balance(currency, balance.total, balance.locked)
 
-                self.__debug(
-                    f"Updated balance - {currency}: total={balance.total:.2f}, "
-                    f"free={balance.free:.2f}, locked={balance.locked:.2f}"
-                )
+            updated_balances_str = "\n\t".join(
+                [
+                    f"{currency} --> {balance.total:.2f} (free={balance.free:.2f}, locked={balance.locked:.2f})"
+                    for currency, balance in balances.items()
+                ]
+            )
+            self.__debug(f"Updated balances:\n\t{updated_balances_str}")
 
             if not self._account_stats_initialized:
                 self._account_stats_initialized = True

qubx/connectors/xlighter/broker.py

@@ -255,11 +255,6 @@ class LighterBroker(IBroker):
                 else:
                     price = mid_price * (1 - max_slippage)
 
-                logger.debug(
-                    f"Market order slippage protection: mid={mid_price:.4f}, "
-                    f"slippage={max_slippage * 100:.1f}%, protected_price={price:.4f}"
-                )
-
             except Exception as e:
                 raise InvalidOrderParameters(
                     f"Failed to calculate market order price for {instrument.symbol}: {e}"
@@ -329,7 +324,6 @@ class LighterBroker(IBroker):
             # This makes it available for cancellation before WebSocket updates arrive
             self.account.process_order(order)
 
-            logger.info(f"Order submitted via WebSocket: {order_id} ({client_id})")
             return order
 
         except Exception as e:
@@ -370,7 +364,7 @@ class LighterBroker(IBroker):
             return abs(hash(order.id)) % (2**56)
 
     async def _cancel_order(self, order: Order) -> bool:
-        logger.info(f"Canceling order: {order.id}")
+        logger.info(f"[{order.instrument}] Canceling order @ {order.price} {order.side} {order.quantity} [{order.id}]")
 
         try:
             market_id = self.instrument_loader.get_market_id(order.instrument.symbol)
@@ -388,7 +382,6 @@ class LighterBroker(IBroker):
                 return False
 
             await self.ws_manager.send_tx(tx_type=TX_TYPE_CANCEL_ORDER, tx_info=tx_info, tx_id=f"cancel_{order.id}")
-            logger.info(f"Order cancellation submitted via WebSocket: {order.id}")
             return True
 
         except Exception as e:
@@ -408,7 +401,9 @@ class LighterBroker(IBroker):
             base_amount_int = int(amount * (10**instrument.size_precision))
             price_int = int(price * (10**instrument.price_precision))
 
-            logger.debug(f"Modify order {order.id}: amount={order.quantity} → {amount}, price={order.price} → {price}")
+            logger.debug(
+                f"[{order.instrument.symbol}] :: Modifying order {order.id}: amount={order.quantity} → {amount}, price={order.price} → {price}"
+            )
 
             # Step 1: Sign modification transaction locally
             signer = self.client.signer_client
@@ -442,7 +437,6 @@ class LighterBroker(IBroker):
                 options=order.options,
             )
 
-            logger.info(f"Order modification submitted via WebSocket: {order.id}")
             return updated_order
 
         except Exception as e:
@@ -572,10 +566,10 @@ class LighterBroker(IBroker):
                         else:
                             price = mid_price * (1 - max_slippage)
 
-                        logger.debug(
-                            f"Market order slippage protection (batch): mid={mid_price:.4f}, "
-                            f"slippage={max_slippage * 100:.1f}%, protected_price={price:.4f}"
-                        )
+                        # logger.debug(
+                        #     f"Market order slippage protection (batch): mid={mid_price:.4f}, "
+                        #     f"slippage={max_slippage * 100:.1f}%, protected_price={price:.4f}"
+                        # )
 
                     except Exception as e:
                         raise InvalidOrderParameters(

qubx/connectors/xlighter/parsers.py

@@ -185,7 +185,7 @@ def parse_account_tx_message(
 
 def parse_account_all_orders_message(
     message: dict[str, Any], instrument_loader: LighterInstrumentLoader
-) -> list[tuple[Instrument, Order]]:
+) -> list[Order]:
     """
     Parse account_all_orders WebSocket message into list of Orders.
 
@@ -220,24 +220,8 @@ def parse_account_all_orders_message(
       }
     }
     ```
-
-    Args:
-        message: Raw WebSocket message from account_all_orders channel
-        instrument_loader: Loader with market_id -> Instrument mapping
-
-    Returns:
-        List of (Instrument, Order) tuples. Empty list if:
-        - Message is subscription confirmation (type="subscribed/account_all_orders")
-        - No orders in message
-        - Orders dict is empty
-
-    Note:
-        - Order.quantity is signed: positive for BUY, negative for SELL
-        - Order.quantity represents the original order size (initial_base_amount)
-        - Filled/remaining amounts are stored in Order.options dict
-        - Lighter order statuses map to Qubx OrderStatus literals
     """
-    orders: list[tuple[Instrument, Order]] = []
+    orders = []
 
     # Get orders dict (keyed by market_index)
     orders_by_market = message.get("orders", {})
@@ -262,7 +246,7 @@ def parse_account_all_orders_message(
         for order_data in market_orders:
             try:
                 order = _parse_lighter_order(order_data, instrument)
-                orders.append((instrument, order))
+                orders.append(order)
             except Exception as e:
                 logger.error(f"Failed to parse order: {e}")
                 continue
@@ -291,9 +275,9 @@ def _parse_lighter_order(order_data: dict[str, Any], instrument: Instrument) ->
         client_order_id = str(client_order_id)
 
     # Amounts
-    initial_amount = float(order_data.get("initial_base_amount", "0"))
-    remaining_amount = float(order_data.get("remaining_base_amount", "0"))
-    filled_amount = float(order_data.get("filled_base_amount", "0"))
+    initial_amount = abs(float(order_data.get("initial_base_amount", "0")))
+    remaining_amount = abs(float(order_data.get("remaining_base_amount", "0")))
+    filled_amount = abs(float(order_data.get("filled_base_amount", "0")))
 
     # Price (may be "0.0000" for market orders)
     price_str = order_data.get("price", "0")
@@ -343,10 +327,6 @@ def _parse_lighter_order(order_data: dict[str, Any], instrument: Instrument) ->
     # Use updated_at as order time (most recent)
     timestamp = pd.Timestamp(updated_at, unit="s").asm8
 
-    # Calculate cost (filled_amount * avg_price)
-    # For simplicity, use order price as avg price
-    cost = filled_amount * price if price > 0 else 0
-
     # Build options dict with additional info
     options = {
         "initial_amount": initial_amount,
@@ -363,21 +343,17 @@ def _parse_lighter_order(order_data: dict[str, Any], instrument: Instrument) ->
     if trigger_price_str and trigger_price_str != "0.0000":
         options["trigger_price"] = float(trigger_price_str)
 
-    # Signed quantity: positive for BUY, negative for SELL
-    quantity = initial_amount if side == "BUY" else -initial_amount
-
     return Order(
         id=order_id,
         type=order_type,
         instrument=instrument,
         time=timestamp,
-        quantity=quantity,
+        quantity=remaining_amount,
         price=price,
         side=side,
         status=status,
         time_in_force=time_in_force,
         client_id=client_order_id,
-        cost=cost,
         options=options,
     )
 

qubx/connectors/xlighter/websocket.py

@@ -148,7 +148,6 @@ class LighterWebSocketManager(BaseWebSocketManager):
             "data": {"id": tx_id, "tx_type": tx_type, "tx_info": tx_info_dict},
         }
 
-        logger.debug(f"Sending transaction via WebSocket: type={tx_type}, id={tx_id}")
         await self.send(message)
 
         # Wait for response (next message should be the tx response)
@@ -202,7 +201,6 @@ class LighterWebSocketManager(BaseWebSocketManager):
             "data": {"id": batch_id, "tx_types": tx_types, "tx_infos": tx_infos_dicts},
         }
 
-        logger.info(f"Sending transaction batch via WebSocket: count={len(tx_types)}, id={batch_id}")
         await self.send(message)
 
         # Return confirmation

qubx/core/account.py

@@ -246,9 +246,10 @@ class BasicAccountProcessor(IAccountProcessor):
                 else:
                     self._active_orders[order.id] = order
 
-            # - calculate amount locked by this order
-            if update_locked_value and order.type == "LIMIT":
-                self._lock_limit_order_value(self._active_orders[order.id])
+            if order.id in self._active_orders:
+                # - calculate amount locked by this order
+                if update_locked_value and order.type == "LIMIT":
+                    self._lock_limit_order_value(self._active_orders[order.id])
 
         if _closed or _cancel:
             # TODO: (LIVE) WE NEED TO THINK HOW TO CLEANUP THIS COLLECTION !!!! -> @DM

qubx/core/context.py

@@ -314,6 +314,10 @@ class StrategyContext(IStrategyContext):
         logger.info(f"[StrategyContext] :: Received {sig_name} signal - initiating graceful shutdown")
         self.stop()
 
+    @property
+    def strategy_name(self) -> str:
+        return self._strategy_name or self.strategy.__class__.__name__
+
     def start(self, blocking: bool = False):
         if self._is_initialized:
             raise ValueError("Strategy is already started !")
@@ -333,17 +337,6 @@ class StrategyContext(IStrategyContext):
             self._atexit_registered = True
             logger.debug("[StrategyContext] :: Registered atexit handler")
 
-        # Notify strategy start
-        if self._notifier:
-            try:
-                self._notifier.notify_start(
-                    {
-                        "Instruments": [str(i) for i in self._initial_instruments],
-                    },
-                )
-            except Exception as e:
-                logger.error(f"[StrategyContext] :: Failed to notify strategy start: {e}")
-
         # - run cron scheduler
         self._scheduler.run()
 
@@ -365,6 +358,21 @@ class StrategyContext(IStrategyContext):
         open_positions = {k: p for k, p in self.get_positions().items() if p.is_open()}
         self._initial_instruments = list(set(open_positions.keys()) | set(self._initial_instruments))
 
+        # Notify strategy start
+        if self._notifier and not self.is_simulation:
+            try:
+                self._notifier.notify_start(
+                    {
+                        "Exchanges": "|".join(self.exchanges),
+                        "Total Capital": f"${self.get_total_capital():,.0f}",
+                        "Net Leverage": f"{self.get_net_leverage():.1%}",
+                        "Open Positions": len(open_positions),
+                        "Instruments": len(self._initial_instruments),
+                    },
+                )
+            except Exception as e:
+                logger.error(f"[StrategyContext] :: Failed to notify strategy start: {e}")
+
         # - update universe with initial instruments after the strategy is initialized
         self.set_universe(self._initial_instruments, skip_callback=True)
 
@@ -402,7 +410,7 @@ class StrategyContext(IStrategyContext):
         # These are the most important callbacks that must always run
 
         # Notify strategy stop
-        if self._notifier:
+        if self._notifier and not self.is_simulation:
             try:
                 self._notifier.notify_stop(
                     {
@@ -444,7 +452,9 @@ class StrategyContext(IStrategyContext):
                         data_provider.close()
                         logger.debug(f"[StrategyContext] :: Closed data provider: {type(data_provider).__name__}")
                     except Exception as e:
-                        logger.error(f"[StrategyContext] :: Failed to close data provider {type(data_provider).__name__}: {e}")
+                        logger.error(
+                            f"[StrategyContext] :: Failed to close data provider {type(data_provider).__name__}: {e}"
+                        )
             except Exception as e:
                 logger.error(f"[StrategyContext] :: Error iterating data providers: {e}")
 

qubx/core/interfaces.py

@@ -942,8 +942,7 @@ class ITradingManager:
 
         Args:
             instrument: The instrument to get the minimum size for
-            amount: The amount to get the minimum size for
-            price: The price to get the minimum size for
+            amount: The amount to be traded to determine if it's position reducing or not
         """
         ...
 
@@ -1453,6 +1452,7 @@ class IStrategyContext(
     emitter: "IMetricEmitter"
     health: "IHealthReader"
     notifier: "IStrategyNotifier"
+    strategy_name: str
 
     _strategy_state: StrategyState
 
@@ -2352,6 +2352,16 @@ class IStrategy(metaclass=Mixable):
         """
         return None
 
+    def on_deals(self, ctx: IStrategyContext, deals: list[Deal]) -> None:
+        """
+        Called when deals are received.
+
+        Args:
+            ctx: Strategy context.
+            deals: The deals.
+        """
+        return None
+
     def on_error(self, ctx: IStrategyContext, error: BaseErrorEvent) -> None:
         """
         Called when an error occurs.

qubx/core/mixins/processing.py

@@ -940,6 +940,10 @@ class ProcessingManager(IProcessingManager):
                     account=self._account,
                 )
 
+            # - notify strategy about deals
+            if deals:
+                self._strategy.on_deals(self._context, deals)
+
             # - process active targets: if we got 0 position after executions remove current position from active
             if not self._context.get_position(instrument).is_open():
                 self._active_targets.pop(instrument, None)

qubx/core/mixins/trading.py

@@ -464,9 +464,12 @@ class TradingManager(ITradingManager):
         size_adj = instrument.round_size_down(abs(amount))
         min_size = self._get_min_size(instrument, amount)
         if abs(size_adj) < min_size:
-            raise InvalidOrderSize(
-                f"[{instrument.symbol}] Attempt to trade size {abs(amount)} less than minimal allowed {min_size} !"
-            )
+            # Try just in case to round up to avoid too small orders
+            size_adj = instrument.round_size_up(abs(amount))
+            if abs(size_adj) < min_size:
+                raise InvalidOrderSize(
+                    f"[{instrument.symbol}] Attempt to trade size {abs(amount)} less than minimal allowed {min_size} !"
+                )
         return size_adj
 
     def _adjust_price(self, instrument: Instrument, price: float | None, amount: float) -> float | None:

qubx/core/series.pyi

@@ -169,6 +169,7 @@ class OHLCV(TimeSeries):
     def to_records(self) -> dict: ...
     def to_series(self, length: int | None = None) -> pd.DataFrame: ...
     def pd(self, length: int | None = None) -> pd.DataFrame: ...
+    def resample(self, timeframe: str, max_series_length=np.inf) -> "OHLCV": ...
     @staticmethod
     def from_dataframe(df_p: pd.DataFrame, name: str = "ohlc") -> "OHLCV": ...
 

qubx/core/series.pyx

@@ -311,9 +311,20 @@ cdef class TimeSeries:
 
     def resample(self, timeframe: str, max_series_length=INFINITY, process_every_update=True) -> TimeSeries:
         """
-        Returns resampled series.
+        Returns resampled series object. This object is linked to original series so all updates in original series will be propagated to resampled one.
         """
-        return Resample(self, timeframe, max_series_length, process_every_update)
+
+        # - check resampling timeframe
+        r_timeframe = recognize_timeframe(timeframe)
+        if r_timeframe < self.timeframe:
+            raise ValueError("Can't resample to lower timeframe !")
+
+        # - check if series already has this resampler
+        name = self.name + "." + time_delta_to_str(r_timeframe).lower()
+        if name in self.indicators:
+            return self.indicators[name]
+
+        return Resampler(name, self, timeframe, max_series_length, process_every_update)
 
     def diff(self, int period=1):
         """
@@ -520,19 +531,14 @@ cdef class IndicatorOHLC(Indicator):
         raise ValueError("Indicator must implement calculate() method")
 
 
-cdef class Resample(TimeSeries):
+cdef class Resampler(TimeSeries):
     """
-    Derived resampled timeseries - convert all updates from underlying series into higher timeframe (apply 'last' aggreagation logic)
+    Resampled timeseries helper - convert all updates from underlying series into higher timeframe series (applying 'last' aggreagation logic)
     """
 
     def __init__(
-        self, TimeSeries series, timeframe, max_series_length=INFINITY, process_every_update=True
+        self, str name, TimeSeries series, timeframe, max_series_length=INFINITY, process_every_update=True
     ):
-        r_timeframe = recognize_timeframe(timeframe)
-        if r_timeframe < series.timeframe:
-            raise ValueError("Can't resample to lower timeframe !")
-
-        name = series.name + "." + time_delta_to_str(r_timeframe).lower()
         super().__init__(name, timeframe, max_series_length, process_every_update)
 
         # - attach as indicator - it should receive updates from underlying series
@@ -1230,7 +1236,10 @@ cdef class OHLCV(TimeSeries):
 
         return self._is_new_item
 
-    cpdef short update_by_bar(self, long long time, double open, double high, double low, double close, double vol_incr=0.0, double b_vol_incr=0.0, double volume_quote=0.0, double bought_volume_quote=0.0, int trade_count=0, short is_incremental=1):
+    cpdef short update_by_bar(
+        self, long long time, double open, double high, double low, double close, 
+        double vol_incr=0.0, double b_vol_incr=0.0, double volume_quote=0.0, double bought_volume_quote=0.0, int trade_count=0, short is_incremental=1
+    ):
         cdef Bar b
         cdef Bar l_bar
         bar_start_time = floor_t64(time, self.timeframe)
@@ -1426,7 +1435,17 @@ cdef class OHLCV(TimeSeries):
         """
         Returns resampled OHLCV series.
         """
-        return ResampleOHLC(self, timeframe, max_series_length)
+        # - check resampling timeframe
+        r_timeframe = recognize_timeframe(timeframe)
+        if r_timeframe < self.timeframe:
+            raise ValueError("Can't resample OHLCV series to lower timeframe !")
+
+        # - check if series already has this resampler
+        name = self.name + "." + time_delta_to_str(r_timeframe).lower() + "_wrapper"
+        if name in self.indicators:
+            return self.indicators[name]
+
+        return ResamplerOHLC(name, self, timeframe, max_series_length)
 
     def to_series(self, length: int | None = None) -> pd.DataFrame:
         df = pd.DataFrame({
@@ -1452,14 +1471,15 @@ cdef class OHLCV(TimeSeries):
             ValueError(f"Input must be a pandas DataFrame, got {type(df_p).__name__}")
 
         _ohlc = OHLCV(name, infer_series_frequency(df_p).item())
+        _has_count = "count" in df_p.columns
         for t in df_p.itertuples():
             _ohlc.update_by_bar(
-                t.Index.asm8, t.open, t.high, t.low, t.close, 
-                getattr(t, "volume", 0.0), 
-                getattr(t, "taker_buy_volume", 0.0), 
-                getattr(t, "quote_volume", 0.0), 
-                getattr(t, "taker_buy_quote_volume", 0.0), 
-                getattr(t, "count", 0.0)
+                time=t.Index.asm8, open=t.open, high=t.high, low=t.low, close=t.close, 
+                vol_incr=getattr(t, "volume", 0.0), 
+                b_vol_incr=getattr(t, "taker_buy_volume", 0.0), 
+                volume_quote=getattr(t, "quote_volume", 0.0), 
+                bought_volume_quote=getattr(t, "taker_buy_quote_volume", 0.0), 
+                trade_count=t.count if _has_count else 0,
             )
         return _ohlc
 
@@ -1469,7 +1489,7 @@ cdef class OHLCV(TimeSeries):
         return dict(zip(ts, bs))
 
 
-cdef class ResampleOHLC(OHLCV):
+cdef class ResamplerOHLC(OHLCV):
     """
     Derived resampled OHLCV timeseries - convert all updates from underlying series into higher timeframe (apply 'last' aggregation logic)
 
@@ -1477,13 +1497,8 @@ cdef class ResampleOHLC(OHLCV):
     """
 
     def __init__(
-        self, OHLCV ohlc, timeframe, max_series_length=INFINITY
+        self, str name, OHLCV ohlc, timeframe, max_series_length=INFINITY
     ):
-        r_timeframe = recognize_timeframe(timeframe)
-        if r_timeframe < ohlc.timeframe:
-            raise ValueError("Can't resample OHLCV series to lower timeframe !")
-
-        name = ohlc.name + "." + time_delta_to_str(r_timeframe).lower()
         super().__init__(name, timeframe, max_series_length)
 
         # - attach a wrapper indicator that will forward Bar updates to this series
@@ -1502,9 +1517,9 @@ cdef class _ResampleOHLCWrapper:
     """
     cdef public str name
     cdef public OHLCV source
-    cdef public ResampleOHLC target
+    cdef public ResamplerOHLC target
 
-    def __init__(self, str name, OHLCV source, ResampleOHLC target):
+    def __init__(self, str name, OHLCV source, ResamplerOHLC target):
         self.name = name
         self.source = source
         self.target = target
@@ -1520,6 +1535,7 @@ cdef class _ResampleOHLCWrapper:
             value.trade_count
         )
 
+
 cdef class GenericSeries(TimeSeries):
     """
     Generic series for storing any Timestamped data type (Quote, Trade, FundingRate, etc.).