[Orders] fix partially fill channel notification

Author: GuillaumeDSM

octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -949,7 +949,7 @@ def get_ccxt_order_type(self, order_type: enums.TraderOrderType):
             return enums.TradeOrderType.MARKET.value
         raise RuntimeError(f"Unknown order type: {order_type}")
 
-    def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker):
+    def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker) -> dict:
         fees = self.calculate_fees(symbol, order_type, quantity, price, taker_or_maker)
         fees[enums.FeePropertyColumns.IS_FROM_EXCHANGE.value] = False
         fees[enums.FeePropertyColumns.COST.value] = decimal.Decimal(

octobot_trading/exchanges/types/rest_exchange.py

@@ -808,7 +808,7 @@ async def cancel_order(
     ) -> enums.OrderStatus:
         return await self.connector.cancel_order(exchange_order_id, symbol, order_type, **kwargs)
 
-    def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker):
+    def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker) -> dict:
         return self.connector.get_trade_fee(symbol, order_type, quantity, price, taker_or_maker)
 
     def get_fees(self, symbol):

octobot_trading/personal_data/orders/order.py

@@ -931,8 +931,9 @@ def update_from_raw(self, raw_order):
         )
         filled_price = decimal.Decimal(str(price))
         # set average price with real average price if available, use filled_price otherwise
-        average_price = decimal.Decimal(str(raw_order.get(enums.ExchangeConstantsOrderColumns.AVERAGE.value, 0.0)
-                                            or filled_price))
+        average_price = decimal.Decimal(str(
+            raw_order.get(enums.ExchangeConstantsOrderColumns.AVERAGE.value, 0.0) or filled_price
+        ))
 
         return self.update(
             symbol=str(raw_order.get(enums.ExchangeConstantsOrderColumns.SYMBOL.value, None)),
@@ -1187,12 +1188,13 @@ def to_string(self):
         )
         trailing_profile = f"Trailing profile : {self.trailing_profile} | " if self.trailing_profile else ""
         cancel_policy = f"Cancel policy : {self.cancel_policy} | " if self.cancel_policy else ""
+        filled_quantity = f" ({self.filled_quantity} Filled)" if self.filled_quantity else ""
         return (
             f"{inactive}{self.symbol} | "
             f"{chained_order}"
             f"{self.order_type.name if self.order_type is not None else 'Unknown'} | "
             f"Price : {str(self.origin_price)} | "
-            f"Quantity : {str(self.origin_quantity)}{' (Reduce only)' if self.reduce_only else ''} | "
+            f"Quantity : {str(self.origin_quantity)}{filled_quantity}{' (Reduce only)' if self.reduce_only else ''} | "
             f"State : {self.state.state.value if self.state is not None else 'Unknown'} | "
             f"{trailing_profile}"
             f"{cancel_policy}"

octobot_trading/personal_data/orders/order_state.py

@@ -76,7 +76,7 @@ def get_logger(self):
         """
         :return: the order logger
         """
-        return logging.get_logger(self.order.get_logger_name() if self.order is not None else
+        return logging.get_logger(f"[{self.__class__.__name__}] {self.order.get_logger_name()}" if self.order is not None else
                                   f"{self.__class__.__name__}_without_order")
 
     def log_event_message(self, state_message, error=None):

octobot_trading/personal_data/orders/states/fill_order_state.py

@@ -74,9 +74,13 @@ async def on_refresh_successful(self):
         can also be still pending
         or be fully filled
         """
-        if self.order.status is enums.OrderStatus.PARTIALLY_FILLED:
-            # TODO manage partially filled
-            await self.update()
+        self.get_logger().info(f"on_refresh_successful [{self.order.status}] for {self.order}")
+        if self.order.is_partially_filled():
+            self.get_logger().info(f"Partially filled order: {str(self.order)}")
+            # notify order partially filled
+            await self.order.exchange_manager.exchange_personal_data.handle_order_update_notification(
+                self.order, enums.OrderUpdateType.STATE_CHANGE
+            )
         elif self.order.status in constants.FILL_ORDER_STATUS_SCOPE:
             self.state = enums.OrderStates.FILLED
             await self.update()

octobot_trading/personal_data/orders/states/open_order_state.py

@@ -18,6 +18,7 @@
 import octobot_trading.enums as enums
 import octobot_trading.personal_data.orders.order_state as order_state
 import octobot_trading.personal_data.orders.states.order_state_factory as order_state_factory
+import octobot_trading.personal_data.portfolios.portfolio_util as portfolio_util
 
 
 class OpenOrderState(order_state.OrderState):
@@ -55,11 +56,16 @@ async def initialize_impl(self, forced=False) -> None:
             # update the availability of the currency in the portfolio if order is not
             # from exchange initialization (otherwise it's already taken into account in portfolio)
             portfolio_manager = self.order.exchange_manager.exchange_personal_data.portfolio_manager
-            before_order_details = str(portfolio_manager.portfolio)
+            before_order_details = portfolio_util.filter_empty_values(
+                portfolio_util.portfolio_to_float(portfolio_manager.portfolio.portfolio)
+            )
             portfolio_manager.refresh_portfolio_available_from_order(self.order, True)
+            after_order_details = portfolio_util.filter_empty_values(
+                portfolio_util.portfolio_to_float(portfolio_manager.portfolio.portfolio)
+            )
             self.get_logger().debug(
-                f"Updated portfolio available after new open order. "
-                f"Before order: {before_order_details}. After order: {portfolio_manager.portfolio}"
+                f"Updated [{self.order.exchange_manager.exchange_name}] portfolio available after new open order. "
+                f"Before order: {before_order_details}. After order: {after_order_details}"
             )
 
         return await super().initialize_impl()

octobot_trading/personal_data/portfolios/history/historical_asset_value.py

@@ -33,7 +33,7 @@ def __contains__(self, item):
 
     def __repr__(self):
         return f"{self.__class__.__name__} " \
-               f"[timestamp: {HistoricalAssetValue}, _value_by_currency{self._value_by_currency}]"
+               f"[timestamp: {self._timestamp}, _value_by_currency{self._value_by_currency}]"
 
     def get(self, currency):
         return self._value_by_currency[currency]

tests/exchanges/test_exchange_builder.py

@@ -39,16 +39,17 @@ async def test_build_trading_modes_if_required(exchange_manager):
 
     # with trader simulator: will attempt to create a trading mode and fail (because of the None arg)
     builder.is_simulated()
-    trading_mode_class = mock.Mock(
-        get_is_using_trading_mode_on_exchange=mock.Mock(return_value=True),
-        get_supported_exchange_types=mock.Mock(return_value=[]),
-        return_value=mock.Mock(
-            initialize=mock.AsyncMock(),
-        ),
-    )
     with mock.patch.object(
         commons_authentication.Authenticator, "has_open_source_package", mock.Mock(return_value=False)
     ) as has_open_source_package_mock:
+        # get_is_using_trading_mode_on_exchange returns True
+        trading_mode_class = mock.Mock(
+            get_is_using_trading_mode_on_exchange=mock.Mock(return_value=True),
+            get_supported_exchange_types=mock.Mock(return_value=[]),
+            return_value=mock.Mock(
+                initialize=mock.AsyncMock(),
+            ),
+        )
         with pytest.raises(AttributeError):
             await builder._build_trading_modes_if_required(None, tentacles_setup_config)
         has_open_source_package_mock.assert_not_called()
@@ -57,7 +58,21 @@ async def test_build_trading_modes_if_required(exchange_manager):
         trading_mode_class.get_supported_exchange_types.assert_called_once()
         trading_mode_class.return_value.initialize.assert_awaited_once()
         has_open_source_package_mock.assert_called_once()
+        trading_mode_class.reset_mock()
+        trading_mode_class.get_is_using_trading_mode_on_exchange.reset_mock()
+        trading_mode_class.get_supported_exchange_types.reset_mock()
+        trading_mode_class.return_value.initialize.reset_mock()
+
+        # get_is_using_trading_mode_on_exchange returns False
+        trading_mode_class.get_is_using_trading_mode_on_exchange.return_value = False
+        await builder._build_trading_modes_if_required(trading_mode_class, tentacles_setup_config)
+        trading_mode_class.get_is_using_trading_mode_on_exchange.assert_called_once_with(builder.exchange_name, tentacles_setup_config)
+        trading_mode_class.get_supported_exchange_types.assert_not_called()
+        trading_mode_class.return_value.initialize.assert_not_called()
+        has_open_source_package_mock.assert_called_once()
+
     # raised by default has_open_source_package (which should be overriden)
+    trading_mode_class.get_is_using_trading_mode_on_exchange.return_value = True
     with pytest.raises(NotImplementedError):
         await builder._build_trading_modes_if_required(trading_mode_class, tentacles_setup_config)