OctoBot-Trading 2.4.127__tar.gz → 2.4.129__tar.gz

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.129] - 2023-12-03
+### Updated
+[Futures] fix simulation numbers and update api
+### Fixed
+[Exchanges] fix cancelled order status error
+
+## [2.4.128] - 2023-`12-03
+###` Updated
+[OHLCVUpdater] prevent missing candles spam
+
 ## [2.4.127] - 2023-11-28
 ### Updated
 [MarketStatus] fix min cost overriding

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.127
+Version: 2.4.129
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.127](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.129](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.127/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.127
+Version: 2.4.129
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.127](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.129](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.127](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.129](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/__init__.py

@@ -15,4 +15,4 @@
 #  License along with this library.
 
 PROJECT_NAME = "OctoBot-Trading"
-VERSION = "2.4.127"  # major.minor.revision
+VERSION = "2.4.129"  # major.minor.revision

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/api/__init__.py

@@ -201,12 +201,17 @@ from octobot_trading.api.orders import (
 from octobot_trading.api.positions import (
     get_positions,
     close_position,
+    set_is_exclusively_using_exchange_position_details,
+    update_position_mark_price,
 )
 from octobot_trading.api.contracts import (
     is_inverse_future_contract,
     is_perpetual_future_contract,
     get_pair_contracts,
     is_handled_contract,
+    has_pair_future_contract,
+    load_pair_contract,
+    create_default_future_contract,
 )
 from octobot_trading.api.storage import (
     clear_trades_storage_history,
@@ -380,6 +385,11 @@ __all__ = [
     "is_perpetual_future_contract",
     "get_pair_contracts",
     "is_handled_contract",
+    "has_pair_future_contract",
+    "load_pair_contract",
+    "create_default_future_contract",
+    "set_is_exclusively_using_exchange_position_details",
+    "update_position_mark_price",
     "clear_trades_storage_history",
     "clear_candles_storage_history",
     "clear_database_storage_history",

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/api/contracts.py

@@ -13,8 +13,10 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
-import octobot_trading.exchange_data as exchange_data
+import decimal
 
+import octobot_trading.enums as enums
+import octobot_trading.exchange_data as exchange_data
 
 def is_inverse_future_contract(contract_type):
     return exchange_data.FutureContract(None, None, contract_type).is_inverse_contract()
@@ -30,3 +32,17 @@ def get_pair_contracts(exchange_manager) -> dict:
 
 def is_handled_contract(contract) -> bool:
     return contract.is_handled_contract()
+
+
+def has_pair_future_contract(exchange_manager, pair: str) -> bool:
+    return exchange_manager.exchange.has_pair_future_contract(pair)
+
+
+def load_pair_contract(exchange_manager, contract_dict: dict):
+    exchange_data.update_future_contract_from_dict(exchange_manager, contract_dict)
+
+
+def create_default_future_contract(
+    pair: str, leverage: decimal.Decimal, contract_type: enums.FutureContractType
+) -> exchange_data.FutureContract:
+    return exchange_data.create_default_future_contract(pair, leverage, contract_type)

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/api/positions.py

@@ -34,3 +34,20 @@ async def close_position(exchange_manager, symbol: str, side: enums.PositionSide
                 emit_trading_signals=emit_trading_signals
             ) else 0
     return 0
+
+
+def set_is_exclusively_using_exchange_position_details(
+    exchange_manager, is_exclusively_using_exchange_position_details: bool
+):
+    exchange_manager.exchange_personal_data.positions_manager.is_exclusively_using_exchange_position_details = (
+        is_exclusively_using_exchange_position_details
+    )
+
+
+async def update_position_mark_price(
+    exchange_manager, symbol: str, side: enums.PositionSide, mark_price: decimal.Decimal
+):
+    for position in exchange_manager.exchange_personal_data.positions_manager.get_symbol_positions(symbol):
+        if position.side is side:
+            await position.update(mark_price=mark_price)
+            return position

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/constants.py

@@ -224,6 +224,10 @@ WEBSOCKET_FEEDS_TO_TRADING_CHANNELS = {
     FUNDING_CHANNEL: [enums.WebsocketFeeds.FUNDING]
 }
 
+ALWAYS_STARTED_REST_PRODUCER_CHANNELS = [
+    TICKER_CHANNEL, # use to force mark price update when necessary: should always be reachable
+]
+
 FILL_ORDER_STATUS_SCOPE = [enums.OrderStatus.CLOSED,
                            enums.OrderStatus.FILLED,
                            enums.OrderStatus.PARTIALLY_FILLED]

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/enums.py

@@ -342,6 +342,7 @@ class TradeExtraConstants(enum.Enum):
 
 class ExchangeConstantsPositionColumns(enum.Enum):
     ID = "id"
+    LOCAL_ID = "local_id"
     TIMESTAMP = "timestamp"
     SYMBOL = "symbol"
     ENTRY_PRICE = "entry_price"
@@ -355,6 +356,7 @@ class ExchangeConstantsPositionColumns(enum.Enum):
     SIZE = "size"
     NOTIONAL = "notional"
     INITIAL_MARGIN = "initial_margin"
+    AUTO_DEPOSIT_MARGIN = "auto_deposit_margin"
     COLLATERAL = "collateral"
     LEVERAGE = "leverage"
     MARGIN_TYPE = "margin_type"
@@ -366,6 +368,23 @@ class ExchangeConstantsPositionColumns(enum.Enum):
     SIDE = "side"
 
 
+class ExchangeConstantsMarginContractColumns(enum.Enum):
+    PAIR = "pair"
+    MARGIN_TYPE = "margin_type"
+    CONTRACT_SIZE = "contract_size"
+    MAXIMUM_LEVERAGE = "maximum_leverage"
+    CURRENT_LEVERAGE = "current_leverage"
+    RISK_LIMIT = "risk_limit"
+
+
+class ExchangeConstantsFutureContractColumns(enum.Enum):
+    CONTRACT_TYPE = "contract_type"
+    MINIMUM_TICK_SIZE = "minimum_tick_size"
+    POSITION_MODE = "position_mode"
+    MAINTENANCE_MARGIN_RATE = "maintenance_margin_rate"
+    TAKE_PROFIT_STOP_LOSS_MODE = "take_profit_stop_loss_mode"
+
+
 class ExchangeConstantsLiquidationColumns(enum.Enum):
     ID = "id"
     TIMESTAMP = "timestamp"

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/__init__.py

@@ -91,6 +91,8 @@ from octobot_trading.exchange_data.contracts import (
     MarginContract,
     FutureContract,
     update_contracts_from_positions,
+    update_future_contract_from_dict,
+    create_default_future_contract,
 )
 from octobot_trading.exchange_data import exchange_symbol_data
 from octobot_trading.exchange_data.exchange_symbol_data import (
@@ -193,6 +195,8 @@ __all__ = [
     "MarginContract",
     "FutureContract",
     "update_contracts_from_positions",
+    "update_future_contract_from_dict",
+    "create_default_future_contract",
     "ExchangeSymbolsData",
     "ExchangeSymbolData",
     "UNAUTHENTICATED_UPDATER_PRODUCERS",

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/contracts/__init__.py

@@ -27,10 +27,14 @@ from octobot_trading.exchange_data.contracts.future_contract import (
 from octobot_trading.exchange_data.contracts import contract_factory
 from octobot_trading.exchange_data.contracts.contract_factory import (
     update_contracts_from_positions,
+    update_future_contract_from_dict,
+    create_default_future_contract,
 )
 
 __all__ = [
     "MarginContract",
     "FutureContract",
     "update_contracts_from_positions",
+    "update_future_contract_from_dict",
+    "create_default_future_contract",
 ]

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/contracts/contract_factory.py

@@ -13,10 +13,13 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import decimal
+
 import octobot_commons.logging as logging
 
 import octobot_trading.enums as enums
 import octobot_trading.constants as constants
+import octobot_trading.exchange_data.contracts.future_contract as future_contract
 
 
 def update_contracts_from_positions(exchange_manager, positions) -> bool:
@@ -51,5 +54,44 @@ def update_contracts_from_positions(exchange_manager, positions) -> bool:
     return updated
 
 
+def update_future_contract_from_dict(exchange_manager, contract: dict) -> bool:
+    return exchange_manager.exchange.create_pair_contract(
+        pair=contract[enums.ExchangeConstantsMarginContractColumns.PAIR.value],
+        current_leverage=decimal.Decimal(str(
+            contract[enums.ExchangeConstantsMarginContractColumns.CURRENT_LEVERAGE.value]
+        )),
+        contract_size=decimal.Decimal(str(
+            contract[enums.ExchangeConstantsMarginContractColumns.CONTRACT_SIZE.value]
+        )),
+        margin_type=enums.MarginType(contract[enums.ExchangeConstantsMarginContractColumns.MARGIN_TYPE.value]),
+        contract_type=enums.FutureContractType(contract[enums.ExchangeConstantsFutureContractColumns.CONTRACT_TYPE.value]),
+        position_mode=enums.PositionMode(contract[enums.ExchangeConstantsFutureContractColumns.POSITION_MODE.value])
+            if contract[enums.ExchangeConstantsFutureContractColumns.POSITION_MODE.value]
+            else contract[enums.ExchangeConstantsFutureContractColumns.POSITION_MODE.value],
+        maintenance_margin_rate=decimal.Decimal(str(
+            contract[enums.ExchangeConstantsFutureContractColumns.MAINTENANCE_MARGIN_RATE.value]
+        )),
+        maximum_leverage=None if contract[enums.ExchangeConstantsMarginContractColumns.MAXIMUM_LEVERAGE.value] is None
+            else decimal.Decimal(str(
+                contract[enums.ExchangeConstantsMarginContractColumns.MAXIMUM_LEVERAGE.value]
+            ))
+    )
+
+
+def create_default_future_contract(
+    pair: str, leverage: decimal.Decimal, contract_type: enums.FutureContractType
+) -> future_contract.FutureContract:
+    return future_contract.FutureContract(
+        pair=pair,
+        contract_size=constants.DEFAULT_SYMBOL_CONTRACT_SIZE,
+        margin_type=constants.DEFAULT_SYMBOL_MARGIN_TYPE,
+        contract_type=contract_type,
+        maximum_leverage=constants.DEFAULT_SYMBOL_MAX_LEVERAGE,
+        current_leverage=leverage,
+        position_mode=constants.DEFAULT_SYMBOL_POSITION_MODE,
+        maintenance_margin_rate=constants.DEFAULT_SYMBOL_MAINTENANCE_MARGIN_RATE
+    )
+
+
 def _get_logger():
     return logging.get_logger("contract_factory")

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/contracts/future_contract.py

@@ -111,3 +111,19 @@ class FutureContract(margin_contract.MarginContract):
             logging.get_logger(str(self)).debug(f"Changed position mode to {pos_mode}")
             changed = True
         return changed
+
+    def to_dict(self):
+        return {
+            **super().to_dict(),
+            **{
+                enums.ExchangeConstantsFutureContractColumns.CONTRACT_TYPE.value:
+                    self.contract_type.value if self.contract_type else self.contract_type,
+                enums.ExchangeConstantsFutureContractColumns.MINIMUM_TICK_SIZE.value: self.minimum_tick_size,
+                enums.ExchangeConstantsFutureContractColumns.POSITION_MODE.value:
+                    self.position_mode.value if self.position_mode else self.position_mode,
+                enums.ExchangeConstantsFutureContractColumns.MAINTENANCE_MARGIN_RATE.value:
+                    self.maintenance_margin_rate,
+                enums.ExchangeConstantsFutureContractColumns.TAKE_PROFIT_STOP_LOSS_MODE.value:
+                    self.take_profit_stop_loss_mode,
+            }
+        }

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/contracts/margin_contract.py

@@ -82,3 +82,13 @@ class MarginContract:
             logging.get_logger(str(self)).debug(f"Changed margin type to {margin_type}")
             changed = True
         return changed
+
+    def to_dict(self):
+        return {
+            enums.ExchangeConstantsMarginContractColumns.PAIR.value: self.pair,
+            enums.ExchangeConstantsMarginContractColumns.MARGIN_TYPE.value: self.margin_type.value,
+            enums.ExchangeConstantsMarginContractColumns.CONTRACT_SIZE.value: self.contract_size,
+            enums.ExchangeConstantsMarginContractColumns.MAXIMUM_LEVERAGE.value: self.maximum_leverage,
+            enums.ExchangeConstantsMarginContractColumns.CURRENT_LEVERAGE.value: self.current_leverage,
+            enums.ExchangeConstantsMarginContractColumns.RISK_LIMIT.value: self.risk_limit,
+        }

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/kline/channel/kline_updater.py

@@ -78,7 +78,7 @@ class KlineUpdater(kline_channel.KlineProducer):
             except errors.FailedRequest as e:
                 self.logger.warning(str(e))
                 # avoid spamming on disconnected situation
-                await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                await asyncio.sleep(constants.FAILED_NETWORK_REQUEST_RETRY_ATTEMPTS)
             except errors.NotSupported:
                 self.logger.warning(f"{self.channel.exchange_manager.exchange_name} is not supporting updates")
                 await self.pause()

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/ohlcv/channel/ohlcv_updater.py

@@ -35,7 +35,14 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
     OHLCV_OLD_LIMIT = constants.DEFAULT_CANDLE_HISTORY_SIZE  # should be <= to candle manager's MAX_CANDLES_COUNT
     OHLCV_ON_ERROR_TIME = 5
     OHLCV_MIN_REFRESH_TIME = 1
-    OHLCV_REFRESH_TIME_THRESHOLD = 1.5  # to prevent spamming at candle closing
+    OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT = [
+        2,      # retry 1: t+2
+        5,      # retry 2: t+7
+        8 ,     # retry 3: t+15
+        15,     # retry 4: t+30
+        15,     # retry 5: t+45
+        60      # retry N: every 60s
+    ] # to prevent spamming when missing closed candles
     OHLCV_MISSING_DATA_REFRESH_RETRY_MAX_DELAY = 30 * common_constants.MINUTE_TO_SECONDS
 
     OHLCV_INITIALIZATION_TIMEOUT = 60
@@ -206,11 +213,18 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
         time_frame_seconds: int = common_enums.TimeFramesMinutes[time_frame] * common_constants.MINUTE_TO_SECONDS
         time_frame_sleep: int = time_frame_seconds
         last_candle_timestamp: float = 0
-        missing_data_sleep_time = min(int(time_frame_seconds / 6), self.OHLCV_MISSING_DATA_REFRESH_RETRY_MAX_DELAY)
 
+        current_candle_start_time = 0
+        attempt = 1
         while not self.should_stop and not self.channel.is_paused:
+            start_update_time = time.time()
+            iteration_candle_start_time = start_update_time - (start_update_time % time_frame_seconds)
             try:
-                start_update_time = time.time()
+                if iteration_candle_start_time == current_candle_start_time:
+                    attempt += 1    # not working?
+                else:
+                    current_candle_start_time = iteration_candle_start_time
+                    attempt = 1
                 await self._ensure_candles_initialization(pair)
                 # skip uninitialized candles
                 if self.initialized_candles_by_tf_by_symbol[pair][time_frame]:
@@ -225,21 +239,37 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
 
                     if last_candle and len(candles) > 1:
                         last_candle_timestamp, sleep_time = await self._refresh_current_candle(
-                            time_frame, pair, candles, last_candle, last_candle_timestamp, time_frame_sleep
+                            time_frame, pair, candles, last_candle, last_candle_timestamp,
+                            iteration_candle_start_time, time_frame_seconds, attempt
+                        )
+                        updated_sleep_time = self._ensure_correct_sleep_time(
+                            sleep_time, iteration_candle_start_time, time_frame_seconds
                         )
-                        await asyncio.sleep(self._ensure_correct_sleep_time(sleep_time, time_frame_sleep))
+                        await asyncio.sleep(updated_sleep_time)
                     else:
                         # not enough candles: retry soon
+                        sleep_time = self._ensure_correct_sleep_time(
+                            self._get_missing_candle_retry_sleep_time(attempt),
+                            iteration_candle_start_time, time_frame_seconds
+                        )
                         self.logger.debug(f"Missing candles in request results for {pair} on {time_frame}, refreshing "
-                                          f"in {missing_data_sleep_time} seconds (available candles: {candles}).")
-                        await asyncio.sleep(missing_data_sleep_time)
+                                          f"in {sleep_time} seconds (available candles: {candles}).")
+                        await asyncio.sleep(sleep_time)
                 else:
                     # candles on this time frame have not been initialized: sleep until the next candle update
                     await asyncio.sleep(max(0.0, time_frame_sleep - (time.time() - start_update_time)))
-            except errors.FailedRequest as e:
-                self.logger.warning(str(e))
+            except errors.FailedRequest as err:
                 # avoid spamming on disconnected situation
-                await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                sleep_time = self._ensure_correct_sleep_time(
+                    self._get_missing_candle_retry_sleep_time(attempt),
+                    iteration_candle_start_time, time_frame_seconds
+                )
+                sleep_time = max(sleep_time, constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                self.logger.warning(
+                    f"Impossible to fetch {time_frame.value} {pair} candles. Retry in {sleep_time} seconds: "
+                    f"{html_util.get_html_summary_if_relevant(err)}"
+                )
+                await asyncio.sleep(sleep_time)
             except errors.NotSupported:
                 self.logger.warning(
                     f"{self.channel.exchange_manager.exchange_name} is not supporting updates")
@@ -253,36 +283,51 @@ class OHLCVUpdater(ohlcv_channel.OHLCVProducer):
                 )
                 await asyncio.sleep(self.OHLCV_ON_ERROR_TIME)
 
-    async def _refresh_current_candle(self, time_frame, pair, candles, last_candle,
-                                      last_candle_timestamp, time_frame_sleep):
+    async def _refresh_current_candle(
+        self, time_frame, pair, candles, last_candle, last_candle_timestamp,
+        iteration_candle_start_time, time_frame_seconds, attempt
+    ):
         current_candle_timestamp: float = last_candle[common_enums.PriceIndexes.IND_PRICE_TIME.value]
-        should_sleep_time: float = current_candle_timestamp + time_frame_sleep - time.time()
+        should_sleep_time: float = current_candle_timestamp + time_frame_seconds - time.time()
 
         # if we're trying to refresh the current candle => useless
         if last_candle_timestamp == current_candle_timestamp:
             if should_sleep_time < 0:
-                # up to date candle is not yet available on exchange: retry in a few seconds
+                # up-to-date candle is not yet available on exchange: retry in a few seconds
                 should_sleep_time = self._ensure_correct_sleep_time(
-                    self.OHLCV_REFRESH_TIME_THRESHOLD,
-                    time_frame_sleep
+                    self._get_missing_candle_retry_sleep_time(attempt),
+                    iteration_candle_start_time,
+                    time_frame_seconds
                 )
             else:
                 should_sleep_time = self._ensure_correct_sleep_time(
-                    should_sleep_time + time_frame_sleep + self.OHLCV_REFRESH_TIME_THRESHOLD,
-                    time_frame_sleep
+                    should_sleep_time + time_frame_seconds + self._get_missing_candle_retry_sleep_time(attempt),
+                    iteration_candle_start_time,
+                    time_frame_seconds
                 )
+            self.logger.debug(
+                f"Failed to fetch up-to-date candle for {pair} on {time_frame.value}. "
+                f"Retrying in {round(should_sleep_time, 2)} seconds"
+            )
+
         else:
             # A fresh candle happened
             last_candle_timestamp = current_candle_timestamp
             await self._push_complete_candles(time_frame, pair, candles)
         return last_candle_timestamp, should_sleep_time
 
-    def _ensure_correct_sleep_time(self, sleep_time_candidate, time_frame_sleep):
+    def _get_missing_candle_retry_sleep_time(self, attempt):
+        if attempt < len(self.OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT):
+            return self.OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT[attempt - 1]
+        return self.OHLCV_REFRESH_TIME_THRESHOLD_BY_RETRY_ATTEMPT[-1]
+
+    def _ensure_correct_sleep_time(self, sleep_time_candidate, iteration_candle_start_time, time_frame_seconds):
         if sleep_time_candidate < OHLCVUpdater.OHLCV_MIN_REFRESH_TIME:
             return OHLCVUpdater.OHLCV_MIN_REFRESH_TIME
-        elif sleep_time_candidate > time_frame_sleep:
-            return time_frame_sleep
-        return sleep_time_candidate
+        else:
+            max_sleep_time = max(iteration_candle_start_time + time_frame_seconds - time.time(), 0)
+            # ensure does not sleep more than missing time before next candle
+            return min(sleep_time_candidate, max_sleep_time)
 
     def _set_initialized(self, pair, time_frame, initialized):
         if pair not in self.initialized_candles_by_tf_by_symbol:

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/recent_trades/channel/recent_trade_updater.py

@@ -74,10 +74,14 @@ class RecentTradeUpdater(recent_trade_channel.RecentTradeProducer):
                         except TypeError:
                             pass
                 await asyncio.sleep(self.refresh_time)
-            except errors.FailedRequest as e:
-                self.logger.warning(str(e))
+            except errors.FailedRequest as err:
+                sleep_time = constants.FAILED_NETWORK_REQUEST_RETRY_ATTEMPTS
+                self.logger.warning(
+                    f"Impossible to fetch recent trades. Retry in {sleep_time} seconds: "
+                    f"{html_util.get_html_summary_if_relevant(err)}"
+                )
                 # avoid spamming on disconnected situation
-                await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+                await asyncio.sleep(sleep_time)
             except errors.NotSupported:
                 self.logger.warning(f"{self.channel.exchange_manager.exchange_name} is not supporting updates")
                 await self.pause()

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchange_data/ticker/channel/ticker_updater.py

@@ -23,6 +23,7 @@ import octobot_trading.errors as errors
 import octobot_trading.constants as constants
 import octobot_trading.exchange_data.ticker.channel.ticker as ticker_channel
 import octobot_trading.enums as enums
+import octobot_trading.exchanges.exchange_websocket_factory as exchange_websocket_factory
 
 
 class TickerUpdater(ticker_channel.TickerProducer):
@@ -39,17 +40,24 @@ class TickerUpdater(ticker_channel.TickerProducer):
         self.updating_pairs = set()
 
     async def start(self):
-        if self._should_use_future():
+        use_futures = self._should_use_future()
+        if use_futures:
             self.is_fetching_future_data = True
             self.refresh_time = self.TICKER_FUTURE_REFRESH_TIME
         if self.channel.is_paused:
             await self.pause()
         else:
-            # initialize ticker
-            await asyncio.gather(*[self._fetch_ticker(pair)
-                                   for pair in self._get_pairs_to_update()])
-            await asyncio.sleep(self.refresh_time)
-            await self.start_update_loop()
+            if use_futures or self._should_loop():
+                # initialize ticker
+                await asyncio.gather(*[self._fetch_ticker(pair)
+                                       for pair in self._get_pairs_to_update()])
+                await asyncio.sleep(self.refresh_time)
+                await self.start_update_loop()
+            else:
+                self.logger.debug(
+                    f"Ticker update loop disabled: update is managed by websocket. "
+                    f"Updater remains available for forced updates."
+                )
 
     async def start_update_loop(self):
         while not self.should_stop and not self.channel.is_paused:
@@ -74,7 +82,7 @@ class TickerUpdater(ticker_channel.TickerProducer):
         except errors.FailedRequest as e:
             self.logger.warning(html_util.get_html_summary_if_relevant(e))
             # avoid spamming on disconnected situation
-            await asyncio.sleep(constants.DEFAULT_FAILED_REQUEST_RETRY_TIME)
+            await asyncio.sleep(constants.FAILED_NETWORK_REQUEST_RETRY_ATTEMPTS)
 
     async def fetch_and_push_pair(self, pair: str):
         with self._single_pair_update(pair) as can_update:
@@ -88,6 +96,7 @@ class TickerUpdater(ticker_channel.TickerProducer):
                 self.logger.debug(f"Skipping {pair} ticker update request: an update is already processing")
 
     async def trigger_ticker_update(self, symbol: str):
+        self.logger.debug(f"Triggered ticker update for {symbol}")
         await self.fetch_and_push_pair(symbol)
 
     @contextlib.contextmanager
@@ -124,6 +133,14 @@ class TickerUpdater(ticker_channel.TickerProducer):
         return self.channel.exchange_manager.exchange_config.traded_symbol_pairs + self._added_pairs
 
 
+    def _should_loop(self):
+        """
+        Loop when websocket ticker channel not available
+        """
+        return not exchange_websocket_factory.is_channel_managed_by_websocket(
+            self.channel.exchange_manager, constants.TICKER_CHANNEL
+        )
+
     """
     Future data management
     """

{OctoBot-Trading-2.4.127 → OctoBot-Trading-2.4.129}/octobot_trading/exchanges/connectors/ccxt/ccxt_adapter.py

@@ -273,21 +273,36 @@ class CCXTAdapter(adapters.AbstractAdapter):
         # CCXT standard position parsing logic
         # if mode is enums.PositionMode.ONE_WAY:
         original_side = fixed.get(ccxt_enums.ExchangePositionCCXTColumns.SIDE.value)
-        position_side = enums.PositionSide.BOTH
-        # todo when handling cross positions
-        # side = fixed.get(ccxt_enums.ExchangePositionCCXTColumns.SIDE.value, enums.PositionSide.UNKNOWN.value)
-        # position_side = enums.PositionSide.LONG \
-        #     if side == enums.PositionSide.LONG.value else enums.PositionSide.
         symbol = fixed.get(ccxt_enums.ExchangePositionCCXTColumns.SYMBOL.value)
         contract_size = decimal.Decimal(str(fixed.get(ccxt_enums.ExchangePositionCCXTColumns.CONTRACT_SIZE.value, 0)))
         contracts = constants.ZERO if force_empty \
             else decimal.Decimal(str(fixed.get(ccxt_enums.ExchangePositionCCXTColumns.CONTRACTS.value, 0)))
         is_empty = contracts == constants.ZERO
+        position_mode = (
+            enums.PositionMode.HEDGE if fixed.get(ccxt_enums.ExchangePositionCCXTColumns.HEDGED.value, False)
+            else enums.PositionMode.ONE_WAY
+        )
+        if position_mode is enums.PositionMode.HEDGE:
+            # todo when handling hedge positions
+            side = fixed.get(ccxt_enums.ExchangePositionCCXTColumns.SIDE.value, enums.PositionSide.UNKNOWN.value)
+            position_side = enums.PositionSide.LONG \
+                if side == enums.PositionSide.LONG.value else enums.PositionSide.SHORT
+            log_func = self.logger.debug
+            if is_empty:
+                log_func = self.logger.error
+            log_func(f"Unhandled {symbol} position mode ({position_mode.value}). This position can't be traded.")
+        else:
+            # One way position use BOTH side as there is always only one position per symbol.
+            # This position can turn long and short
+            position_side = enums.PositionSide.BOTH
         liquidation_price = fixed.get(ccxt_enums.ExchangePositionCCXTColumns.LIQUIDATION_PRICE.value, 0)
-        if margin_type := fixed.get(ccxt_enums.ExchangePositionCCXTColumns.MARGIN_TYPE.value, None):
+        if margin_type := fixed.get(
+            ccxt_enums.ExchangePositionCCXTColumns.MARGIN_TYPE.value,
+            fixed.get(ccxt_enums.ExchangePositionCCXTColumns.MARGIN_MODE.value, None)   # can also be contained in margin mode
+        ):
             margin_type = enums.MarginType(margin_type)
         if force_empty or liquidation_price is None:
-            liquidation_price = constants.NaN
+            liquidation_price = constants.ZERO
         else:
             liquidation_price = decimal.Decimal(str(liquidation_price))
         try:
@@ -306,9 +321,7 @@ class CCXTAdapter(adapters.AbstractAdapter):
                 enums.ExchangeConstantsPositionColumns.LEVERAGE.value:
                     self.safe_decimal(fixed, ccxt_enums.ExchangePositionCCXTColumns.LEVERAGE.value,
                                       constants.DEFAULT_SYMBOL_LEVERAGE),
-                enums.ExchangeConstantsPositionColumns.POSITION_MODE.value: None if is_empty else
-                enums.PositionMode.HEDGE if fixed.get(ccxt_enums.ExchangePositionCCXTColumns.HEDGED.value, True)
-                else enums.PositionMode.ONE_WAY,
+                enums.ExchangeConstantsPositionColumns.POSITION_MODE.value: position_mode,
                 # next values are always 0 when the position empty (0 contracts)
                 enums.ExchangeConstantsPositionColumns.COLLATERAL.value: constants.ZERO if is_empty else
                 decimal.Decimal(
@@ -319,6 +332,7 @@ class CCXTAdapter(adapters.AbstractAdapter):
                 enums.ExchangeConstantsPositionColumns.INITIAL_MARGIN.value: constants.ZERO if is_empty else
                 decimal.Decimal(
                     f"{fixed.get(ccxt_enums.ExchangePositionCCXTColumns.INITIAL_MARGIN.value, 0) or 0}"),
+                enums.ExchangeConstantsPositionColumns.AUTO_DEPOSIT_MARGIN.value: False,    # default value
                 enums.ExchangeConstantsPositionColumns.UNREALIZED_PNL.value: constants.ZERO if is_empty else
                 decimal.Decimal(
                     f"{fixed.get(ccxt_enums.ExchangePositionCCXTColumns.UNREALISED_PNL.value, 0) or 0}"),