bbstrader 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

tests/metatrader/test_trade.py

@@ -0,0 +1,439 @@
+import unittest
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+
+from bbstrader.metatrader.trade import (
+    Trade,
+    TradeAction,
+    TradeSignal,
+    TradingMode,
+    create_trade_instance,
+    generate_signal,
+)
+from bbstrader.metatrader.utils import (
+    AccountInfo,
+    SymbolInfo,
+    TickInfo,
+    TradeOrder,
+    TradePosition,
+)
+
+
+class TestTrade(unittest.TestCase):
+    def setUp(self):
+        """Set up the test environment."""
+        self.mt5_patcher = patch("bbstrader.metatrader.trade.Mt5")
+        self.mock_mt5 = self.mt5_patcher.start()
+        self.addCleanup(self.mt5_patcher.stop)
+
+        self.logger_patcher = patch("bbstrader.metatrader.trade.log")
+        self.mock_logger = self.logger_patcher.start()
+        self.addCleanup(self.logger_patcher.stop)
+
+        patch(
+            "bbstrader.metatrader.risk.RiskManagement.__init__", return_value=None
+        ).start()
+        self.addCleanup(patch.stopall)
+
+        patch("bbstrader.metatrader.trade.check_mt5_connection").start()
+        patch("bbstrader.metatrader.trade.Trade.select_symbol").start()
+        patch("bbstrader.metatrader.trade.Trade.prepare_symbol").start()
+
+        self.account_info = AccountInfo(
+            login=12345,
+            balance=10000.0,
+            equity=10000.0,
+            currency="USD",
+            name="Test Account",
+            server="Test Server",
+            leverage=100,
+            trade_mode=0,
+            limit_orders=0,
+            margin_so_mode=0,
+            trade_allowed=True,
+            trade_expert=True,
+            margin_mode=0,
+            currency_digits=2,
+            fifo_close=False,
+            credit=0.0,
+            profit=0.0,
+            margin=0.0,
+            margin_free=10000.0,
+            margin_level=0.0,
+            margin_so_call=0.0,
+            margin_so_so=0.0,
+            margin_initial=0.0,
+            margin_maintenance=0.0,
+            assets=0.0,
+            liabilities=0.0,
+            commission_blocked=0.0,
+            company="MetaQuotes",
+        )
+        self.symbol_info = SymbolInfo(
+            name="EURUSD",
+            visible=True,
+            point=0.00001,
+            digits=5,
+            spread=10,
+            trade_tick_value=1.0,
+            trade_tick_size=0.00001,
+            trade_contract_size=100000,
+            volume_min=0.01,
+            volume_max=100.0,
+            volume_step=0.01,
+            bid=1.10000,
+            ask=1.10010,
+            time=datetime.now(),
+            custom=False,
+            chart_mode=0,
+            select=True,
+            session_deals=0,
+            session_buy_orders=0,
+            session_sell_orders=0,
+            volume=0,
+            volumehigh=0,
+            volumelow=0,
+            bidhigh=0,
+            bidlow=0,
+            askhigh=0,
+            asklow=0,
+            last=0,
+            lasthigh=0,
+            lastlow=0,
+            volume_real=0,
+            volumehigh_real=0,
+            volumelow_real=0,
+            option_strike=0,
+            trade_tick_value_profit=1.0,
+            trade_tick_value_loss=1.0,
+            trade_stops_level=0,
+            trade_freeze_level=0,
+            trade_exemode=0,
+            swap_mode=0,
+            swap_rollover3days=0,
+            margin_hedged_use_leg=False,
+            expiration_mode=0,
+            filling_mode=0,
+            order_mode=0,
+            order_gtc_mode=0,
+            option_mode=0,
+            option_right=0,
+            margin_initial=0,
+            margin_maintenance=0,
+            session_volume=0,
+            session_turnover=0,
+            session_interest=0,
+            session_buy_orders_volume=0,
+            session_sell_orders_volume=0,
+            session_open=0,
+            session_close=0,
+            session_aw=0,
+            session_price_settlement=0,
+            session_price_limit_min=0,
+            session_price_limit_max=0,
+            margin_hedged=0,
+            price_change=0,
+            price_volatility=0,
+            price_theoretical=0,
+            price_greeks_delta=0,
+            price_greeks_theta=0,
+            price_greeks_gamma=0,
+            price_greeks_vega=0,
+            price_greeks_rho=0,
+            price_greeks_omega=0,
+            price_sensitivity=0,
+            basis="",
+            category="",
+            currency_base="EUR",
+            currency_profit="USD",
+            currency_margin="EUR",
+            bank="",
+            description="Euro vs US Dollar",
+            exchange="",
+            formula="",
+            isin="",
+            page="",
+            path="Forex\\Majors\\EURUSD",
+            start_time=0,
+            expiration_time=0,
+            spread_float=True,
+            ticks_bookdepth=0,
+            trade_calc_mode=0,
+            trade_mode=0,
+            trade_accrued_interest=0.0,
+            trade_face_value=0.0,
+            trade_liquidity_rate=0.0,
+            volume_limit=0.0,
+            swap_long=0.0,
+            swap_short=0.0,
+        )
+        self.tick_info = TickInfo(
+            time=datetime.now(),
+            bid=1.10000,
+            ask=1.10010,
+            last=1.10005,
+            volume=100,
+            time_msc=int(datetime.now().timestamp() * 1000),
+            flags=6,
+            volume_real=100.0,
+        )
+
+        self.trade = Trade(symbol="EURUSD", expert_id=98181105, verbose=False)
+
+        # Manually set attributes from the patched RiskManagement parent class
+        self.trade.symbol_info = self.symbol_info
+        self.trade.account_leverage = True
+        self.trade.be = 10
+        self.trade.max_risk = 5.0
+        self.trade.rr = 2.0
+        self.trade.copy_mode = False
+
+        # Patch instance methods to return mock data
+        patch.object(
+            self.trade, "get_account_info", return_value=self.account_info
+        ).start()
+        patch.object(
+            self.trade, "get_symbol_info", return_value=self.symbol_info
+        ).start()
+        patch.object(self.trade, "get_tick_info", return_value=self.tick_info).start()
+        patch.object(self.trade, "get_lot", return_value=0.1).start()
+        patch.object(self.trade, "get_stop_loss", return_value=200).start()
+        patch.object(self.trade, "get_take_profit", return_value=300).start()
+        patch.object(
+            self.trade,
+            "send_order",
+            return_value=MagicMock(retcode=self.mock_mt5.TRADE_RETCODE_DONE, order=123),
+        ).start()
+        # This patch is crucial to prevent the UnboundLocalError in close_request
+        patch.object(self.trade, "check_order", return_value=True).start()
+
+    def tearDown(self):
+        """This method is no longer needed as addCleanup handles stopping patches."""
+        pass
+
+    def test_trade_signal_initialization(self):
+        """Test TradeSignal dataclass initialization and validation."""
+        signal = TradeSignal(id=1, symbol="EURUSD", action=TradeAction.BUY, price=1.2)
+        self.assertEqual(signal.id, 1)
+        self.assertEqual(signal.action, TradeAction.BUY)
+
+        with self.assertRaises(TypeError):
+            TradeSignal(id=1, symbol="EURUSD", action="BUY", price=1.2)
+
+        with self.assertRaises(ValueError):
+            TradeSignal(id=1, symbol="EURUSD", action=TradeAction.BUY, stoplimit=1.2)
+
+    def test_generate_signal(self):
+        """Test the generate_signal factory function."""
+        signal = generate_signal(
+            id=1, symbol="EURUSD", action=TradeAction.SELL, price=1.3
+        )
+        self.assertIsInstance(signal, TradeSignal)
+        self.assertEqual(signal.price, 1.3)
+
+    def test_trading_mode_enum(self):
+        """Test the TradingMode enum."""
+        self.assertTrue(TradingMode.BACKTEST.isbacktest())
+        self.assertFalse(TradingMode.LIVE.isbacktest())
+        self.assertTrue(TradingMode.LIVE.islive())
+        self.assertFalse(TradingMode.BACKTEST.islive())
+
+    @patch("bbstrader.metatrader.trade.tabulate")
+    @patch("builtins.print")
+    def test_summary(self, mock_print, mock_tabulate):
+        """Test the summary method."""
+        self.trade.summary()
+        mock_tabulate.assert_called_once()
+        mock_print.assert_called()
+
+    @patch("bbstrader.metatrader.trade.tabulate")
+    @patch("builtins.print")
+    def test_risk_management_summary(self, mock_print, mock_tabulate):
+        """Test the risk_managment method."""
+        with (
+            patch.object(
+                self.trade, "get_stats", return_value=({}, {"total_profit": 100})
+            ),
+            patch.object(
+                self.trade,
+                "currency_risk",
+                return_value={"trade_loss": 10, "trade_profit": 20},
+            ),
+            patch.object(self.trade, "get_currency_rates", return_value={"mc": "EUR"}),
+            patch.object(self.trade, "is_risk_ok", return_value=True),
+            patch.object(self.trade, "risk_level", return_value=1.0),
+            patch.object(self.trade, "get_leverage", return_value="1:100"),
+            patch.object(self.trade, "volume", return_value=0.1),
+            patch.object(self.trade, "get_currency_risk", return_value=100),
+            patch.object(self.trade, "expected_profit", return_value=200),
+            patch.object(self.trade, "get_break_even", return_value=50),
+            patch.object(self.trade, "get_deviation", return_value=20),
+            patch.object(self.trade, "get_minutes", return_value=60),
+            patch.object(self.trade, "max_trade", return_value=10),
+        ):
+            self.trade.risk_managment()
+            mock_tabulate.assert_called_once()
+            mock_print.assert_called()
+
+    @patch("pandas.DataFrame.to_csv")
+    @patch("os.makedirs")
+    def test_statistics(self, mock_makedirs, mock_to_csv):
+        """Test the statistics method."""
+        stats1 = {
+            "deals": 1,
+            "profit": 100,
+            "win_trades": 1,
+            "loss_trades": 0,
+            "total_fees": -10,
+            "average_fee": -10,
+            "win_rate": 100,
+        }
+        stats2 = {"total_profit": 90, "profitability": "Yes"}
+        with (
+            patch.object(self.trade, "get_stats", return_value=(stats1, stats2)),
+            patch.object(self.trade, "sharpe", return_value=1.5),
+            patch.object(self.trade, "get_currency_risk", return_value=100),
+            patch.object(self.trade, "expected_profit", return_value=200),
+        ):
+            self.trade.statistics(save=True, dir="test_stats")
+            mock_makedirs.assert_called_with("test_stats", exist_ok=True)
+            mock_to_csv.assert_called_once()
+
+    def test_open_buy_position(self):
+        """Test opening a buy position."""
+        with patch.object(self.trade, "check", return_value=True):
+            result = self.trade.open_buy_position(action="BMKT")
+            self.assertTrue(result)
+            self.trade.send_order.assert_called()
+
+    def test_open_sell_position(self):
+        """Test opening a sell position."""
+        with patch.object(self.trade, "check", return_value=True):
+            result = self.trade.open_sell_position(action="SMKT")
+            self.assertTrue(result)
+            self.trade.send_order.assert_called()
+
+    def test_open_position(self):
+        """Test the generic open_position method."""
+        with patch.object(self.trade, "open_buy_position") as mock_buy:
+            self.trade.open_position(action="BMKT")
+            mock_buy.assert_called_once()
+
+        with patch.object(self.trade, "open_sell_position") as mock_sell:
+            self.trade.open_position(action="SMKT")
+            mock_sell.assert_called_once()
+
+        with self.assertRaises(ValueError):
+            self.trade.open_position(action="INVALID_ACTION")
+
+    def test_close_position(self):
+        """Test closing a position."""
+        position = self._get_mock_position(ticket=123)
+        with patch.object(self.trade, "get_positions", return_value=[position]):
+            result = self.trade.close_position(ticket=123)
+            self.assertTrue(result)
+            self.trade.send_order.assert_called()
+
+    def test_close_order(self):
+        """Test closing an order."""
+        with patch.object(
+            self.trade, "close_request", return_value=True
+        ) as mock_close_request:
+            result = self.trade.close_order(ticket=456)
+            self.assertTrue(result)
+            mock_close_request.assert_called_once()
+
+    def test_modify_order(self):
+        """Test modifying an order."""
+        order = self._get_mock_order(ticket=789)
+        with (
+            patch.object(self.trade, "get_orders", return_value=[order]),
+            patch.object(self.trade, "check_order", return_value=True),
+        ):
+            self.trade.modify_order(ticket=789, price=1.15)
+            self.trade.send_order.assert_called()
+            call_args = self.trade.send_order.call_args[0][0]
+            self.assertEqual(call_args["price"], 1.15)
+
+    def test_create_trade_instance(self):
+        """Test the create_trade_instance factory function."""
+        with patch("bbstrader.metatrader.trade.Trade") as mock_trade:
+            params = {"expert_id": 123}
+            symbols = ["EURUSD", "GBPUSD"]
+            instances = create_trade_instance(symbols, params)
+            self.assertEqual(len(instances), 2)
+            self.assertIn("EURUSD", instances)
+            self.assertIn("GBPUSD", instances)
+            self.assertEqual(mock_trade.call_count, 2)
+
+    def _get_mock_position(
+        self,
+        ticket=1,
+        symbol="EURUSD",
+        volume=0.1,
+        price_open=1.1,
+        type=0,
+        magic=98181105,
+        profit=0.0,
+    ):
+        return TradePosition(
+            ticket=ticket,
+            time=int(datetime.now().timestamp()),
+            time_msc=0,
+            time_update=0,
+            time_update_msc=0,
+            type=type,
+            magic=magic,
+            identifier=0,
+            reason=0,
+            volume=volume,
+            price_open=price_open,
+            sl=0,
+            tp=0,
+            price_current=price_open + 0.001,
+            swap=0,
+            profit=profit,
+            symbol=symbol,
+            comment="test",
+            external_id="",
+        )
+
+    def _get_mock_order(
+        self,
+        ticket=1,
+        symbol="EURUSD",
+        price_open=1.1,
+        volume_initial=0.1,
+        type=0,
+        magic=98181105,
+    ):
+        return TradeOrder(
+            ticket=ticket,
+            time_setup=int(datetime.now().timestamp()),
+            time_setup_msc=0,
+            time_done=0,
+            time_done_msc=0,
+            time_expiration=0,
+            type=type,
+            type_time=0,
+            type_filling=0,
+            state=0,
+            magic=magic,
+            position_id=0,
+            position_by_id=0,
+            reason=0,
+            volume_initial=volume_initial,
+            volume_current=0.1,
+            price_open=price_open,
+            sl=0,
+            tp=0,
+            price_current=price_open,
+            price_stoplimit=0,
+            symbol=symbol,
+            comment="test",
+            external_id="",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

bbstrader-0.3.5.dist-info/RECORD

@@ -1,49 +0,0 @@
-bbstrader/__init__.py,sha256=-5f30lprSg-ufbPbmj1J3P63elB--NPXo9_G_QuhWF0,581
-bbstrader/__main__.py,sha256=RjUIJWaD2_Od8ZMSLL8dzc2ZuCkkzlvNaE7-LIu3RGU,2488
-bbstrader/compat.py,sha256=bHTPTalffQNVv7MNRPaimJ4d9rQEwQFLSovHlUbxNgA,647
-bbstrader/config.py,sha256=Q8xi6laFo-R-NNGotbHOgy8GLLuwvH6MaoiLhfTbYok,3548
-bbstrader/tseries.py,sha256=SM_LTQHJ3ZXVkVJyZ51CefUDzJDl2TkJqBKMp_uM8s4,43833
-bbstrader/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bbstrader/apps/_copier.py,sha256=z6GhLSmFjHc_oh7pYRTflH42Xmpe3Z7B2fUyedzDQPo,25387
-bbstrader/btengine/__init__.py,sha256=y1btjaEfhWsH8vuE7mBRpP9Tu-Azt9REhuVYsPCAfBU,2955
-bbstrader/btengine/backtest.py,sha256=o3eoCVzpjykDx-9VgkxK6DKZdGDAuLVeeWLCa2U_zeY,14652
-bbstrader/btengine/data.py,sha256=WcBLtabboZkQdtOQS3SjbiJD9BcWc75sdhZ2voQ_lUw,27061
-bbstrader/btengine/event.py,sha256=Ydl1avAXp9WAWOBXDAckcb9g1UkcnCO0rRzcJZwIq20,8714
-bbstrader/btengine/execution.py,sha256=4MytWjcKg8J_w14P43emHqsvKOElkQTfhVYNakU6euQ,11190
-bbstrader/btengine/performance.py,sha256=1ecWrTzHBQbk4ORvbTEKxwCzlL1brcXOEUwgbnjAwx4,12470
-bbstrader/btengine/portfolio.py,sha256=z98M65HQeCyma8gMZkAxspxBA9jtIhzxMyJUHPPj34c,16128
-bbstrader/btengine/scripts.py,sha256=8o66dq4Ex4DsH4s8xvJqUOFjLzZJSnbBvvNBzohtzoE,4837
-bbstrader/btengine/strategy.py,sha256=hDghr5sXNitWlWXXvgl8Vj-QHWaIuVlx54LUXAbQrHQ,36725
-bbstrader/core/__init__.py,sha256=GIFzFSStPfE0XM2j7mDeZZQeMTh_AwPsDOQXwMVJLgw,97
-bbstrader/core/data.py,sha256=5-ByClb-E3-iqDz8CBJ4om9wBIA7DmUWezu4A-tv5ys,25095
-bbstrader/core/scripts.py,sha256=7lNddfX7WaZfiE5dENEfzv3XrAPrwoE9FYSaTie3cwM,5524
-bbstrader/core/utils.py,sha256=tHXQimmmlYZHktNnYNKn_wVq6v-85pI7DXF6xlJV7ps,2780
-bbstrader/ibkr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bbstrader/ibkr/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bbstrader/metatrader/__init__.py,sha256=A5Ye9tpc2sp9Xk5qjKw-EfYsoRcZtAt8nqvC3tCtZs8,333
-bbstrader/metatrader/account.py,sha256=Ur0vKz_puUP9jmdJUpvdQq6W5ue0RfnhkL0JLPBQkOE,65200
-bbstrader/metatrader/analysis.py,sha256=ywETmG3qxZ7ms_DCjR1GcQoUrQ0es5-n-CPDYKBAm8Q,3614
-bbstrader/metatrader/copier.py,sha256=RxXm_NKpaad4sMT1kuJNjeJcbP368asXLaAVqmoRfmE,55553
-bbstrader/metatrader/rates.py,sha256=w9mr6FB6E1zLcHCDtDGt-oMnw6sakIU6Qe3455KDsSg,20782
-bbstrader/metatrader/risk.py,sha256=NhW8qtSg350Z6H9oLcDqOU_erqd_7Y7F5FwpfPN5Qso,27262
-bbstrader/metatrader/scripts.py,sha256=8meq6_zz6jPSibNgtYtaO8Ba-uJZOoLkpqYUIjidk-U,4010
-bbstrader/metatrader/trade.py,sha256=X6DNpPrHL0xQUAblJsCxmpSNWlFw8otEM1pWpgYTydE,81041
-bbstrader/metatrader/utils.py,sha256=PnFZ8EuBSZgsYlvwZDOxj4vUTtt-hUYnnwFBmu7gxxw,20738
-bbstrader/models/__init__.py,sha256=B-bn2h_SCK6gRAs2li6dDVnvV8jDT5suZimldk5xxcw,497
-bbstrader/models/factors.py,sha256=J7yxtDr1sCTw1AI59kluF89e2b9HkpEXfFyIcfPHUCQ,13008
-bbstrader/models/ml.py,sha256=NVN9zxRRDJn2S8KSgGBkiSHvdFjsDiaNsW2Y6rs51Io,50314
-bbstrader/models/nlp.py,sha256=hcvz9d_8j1cIC1h3oqa1DBjExRIEd6WSiZb95Vr3NPo,32638
-bbstrader/models/optimization.py,sha256=Fa4tdhynMmvKt5KHV9cH1TXmmJVJwU4QWpYkbeVq4aI,6395
-bbstrader/models/portfolio.py,sha256=r-47Zrn2r7iKCHm5YVtwkbBJXAZGM3QYy-rXCWY9-Bg,8079
-bbstrader/models/risk.py,sha256=MKCk53HtGIcivrNzH8Ikm5KMs1rXhFT5zkorUf30PyQ,506
-bbstrader/trading/__init__.py,sha256=ycLyuuxN5SujqtzR9X0Q74UQfK93q2va-GGAXdr-KS8,457
-bbstrader/trading/execution.py,sha256=CYt4fageoqcpMFvdRH-jX4hexAGUiG_wE94i1qg7BFM,41479
-bbstrader/trading/scripts.py,sha256=Tf5q33WqqygjpIv43_8nA82VZ3GM0qgb4Ggo3fHJ_wg,5744
-bbstrader/trading/strategies.py,sha256=RZ6P4SfIyRW72v0OnPnrc4Hv8X00FdxR-_sD23xe_Pg,11756
-bbstrader/trading/utils.py,sha256=57dKF9dcRu04oU2VRqydRrzW39dCW2wlDWhVt-sZdRw,1857
-bbstrader-0.3.5.dist-info/licenses/LICENSE,sha256=ZwC_RqqGmOPBUiMDKqLyJZ5HBeHq53LpL7TMRzrJY8c,1094
-bbstrader-0.3.5.dist-info/METADATA,sha256=-FeMRpGJTL9HvVnWmNbhLiHlu0kYfb7wqqANfLzVrew,26910
-bbstrader-0.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bbstrader-0.3.5.dist-info/entry_points.txt,sha256=0yDCbhbgHswOzJnY5wRSM_FjjyMHGvY7lJpSSVh0xtI,54
-bbstrader-0.3.5.dist-info/top_level.txt,sha256=Wwj322jZmxGZ6gD_TdaPiPLjED5ReObm5omerwlmZIg,10
-bbstrader-0.3.5.dist-info/RECORD,,

bbstrader-0.3.5.dist-info/top_level.txt

@@ -1 +0,0 @@
-bbstrader