Update tests and docs across core, lib, and contrib modules

examples/sample_app/bot.py

@@ -8,7 +8,7 @@ logging.basicConfig(level=logging.INFO)
 
 
 def x_bot():
-    syms = ["LTCUSD", "ETHUSD", "SOLUSD", "BTCUSD"]
+    syms = ["LTCUSD", "ETHUSD", "SOLUSD", "BTCUSD", "ADAUSD"]
     symbols = [ForexSymbol(name=sym) for sym in syms]
     strategies = [EMAXOver(symbol=symbol) for symbol in symbols]
     bot = Bot()
@@ -18,4 +18,5 @@ def x_bot():
     bot.execute()
 
 
-x_bot()
+if __name__ == '__main__':
+    x_bot()

examples/sample_app/emaxover.py

@@ -14,7 +14,7 @@ class EMAXOver(Strategy):
     # default parameters for the strategy
     # they are set as attributes. You can override them in the constructor via the params argument.
     parameters = {'ttf': TimeFrame.M10, 'tcc': 3000, 'fast_ema': 34, 'slow_ema': 55, 'interval': TimeFrame.M5,
-                  'timeout': 120}
+                  'timeout': 120, "macd": 87, "sma": 90}
 
     def __init__(self, *, symbol: ForexSymbol, params: dict | None = None, trader: Trader = None,
                  sessions: Sessions = None, name: str = "EMAXOver"):

examples/sample_app/trackers/__init__.py

@@ -1 +1 @@
-from .track import close_after
+from .track import close_after, hedge_position, track_hedges

examples/sample_app/trackers/track.py

@@ -1,3 +1,4 @@
+import asyncio
 from logging import getLogger
 from datetime import datetime
 
@@ -16,3 +17,27 @@ async def close_after(open_pos: OpenPosition, /, *, duration: int, start: float
         _, res = await open_pos.close_position()
         if res.retcode == 10009:
             logger.info("%s, %d closed", pos.symbol, pos.ticket)
+
+
+async def hedge_position(pos: OpenPosition, /, *, hedge_amount: float = -2, close_hedge_amount: float = 0,
+                         order_params: dict = None):
+    is_open = await pos.update_position()
+    position = pos.position
+    if not (is_open and pos.is_hedged is False and position.profit < 0):
+        return
+
+    if position.profit <= hedge_amount:
+        ok, order = await pos.hedge_position(order_params=order_params)
+        if not ok:
+            logger.error("Could not hedge %s:%d", pos.symbol, pos.ticket)
+
+
+async def track_hedges(pos: OpenPosition, close_hedge_amount: float = -10):
+    res = await pos.update_position()
+    if not res:
+        return
+    hedges = list(pos.hedges.values())
+    await asyncio.gather(*[hedge.update_position() for hedge in hedges], return_exceptions=True)
+    hedges = [hedge for hedge in hedges if hedge.is_open]
+    await asyncio.gather(*[hedge.close_position() for hedge in hedges if hedge.position.profit <= close_hedge_amount],
+                         return_exceptions=True)

examples/sample_app/traders/test_trader.py

@@ -1,8 +1,8 @@
 from logging import getLogger
 from datetime import datetime
-from aiomql import Trader, OrderType, OpenPosition, Positions, PositionTracker, Store
+from aiomql import Trader, OrderType, OpenPosition, Positions, PositionTracker, Store, exit_at_profit, round_off
 
-from ..trackers import close_after
+from ..trackers import close_after, track_hedges, hedge_position
 
 logger = getLogger(__name__)
 
@@ -25,7 +25,7 @@ class TestTrader(Trader):
             """
             try:
                 self.parameters |= parameters or {}
-                volume = volume or self.symbol.volume_min
+                volume = volume or self.symbol.volume_min * 20
                 await self.create_order_no_stops(order_type=order_type, volume=volume)
                 if not await self.check_order():
                     return
@@ -33,10 +33,28 @@ class TestTrader(Trader):
                 res = await self.send_order()
                 if res is not None and res.retcode == 10009:
                     position = await self.positions.get_position_by_ticket(ticket=res.order)
-                    open_position = OpenPosition(ticket=res.order, symbol=self.symbol, position=position)
-                    kwargs = {"duration": 40, "start": datetime.now().timestamp()}
-                    ca = PositionTracker(close_after, **kwargs)
-                    open_position.add_tracker(tracker=ca)
+                    open_position = OpenPosition(ticket=res.order, symbol=self.symbol, position=position,
+                                                 close_hedges_on_close=True, close_stacks_on_close=True)
+                    kwargs = {"duration": 3600, "start": datetime.now().timestamp()}
+                    PositionTracker(open_position, hedge_position)
+                    PositionTracker(open_position, track_hedges)
+                    PositionTracker(open_position, close_after, function_params=kwargs)
+                    PositionTracker(open_position, exit_at_profit, function_params={"tp": 10, "sl": -12})
+                    price_to_hedge = await open_position.profit_to_price(profit=-10)
+                    price_to_stack = await open_position.profit_to_price(profit=5)
+                    price_to_stack = round_off(price_to_stack, self.symbol.digits)
+                    price_to_hedge = round_off(price_to_hedge, self.symbol.digits)
+                    # await open_position.stack_order(price=price_to_stack, open_pos_params={"close_stacks_on_close": True})
+                    # await open_position.hedge_order(price=price_to_hedge,
+                    #                                 open_pos_params={"close_hedges_on_close": True})
+                    price_to_hedge2 = await open_position.profit_to_price(profit=-8)
+                    price_to_hedge2 = round_off(price_to_hedge2, self.symbol.digits)
+                    price_to_stack2 = await open_position.profit_to_price(profit=7)
+                    price_to_stack2 = round_off(price_to_stack2, self.symbol.digits)
+                    await open_position.hedge_order(price=price_to_hedge2,
+                                                    open_pos_params={"close_hedges_on_close": True})
+                    await open_position.stack_order(price=price_to_stack2,
+                                                    open_pos_params={"close_stacks_on_close": True})
                     await self.record_trade(result=res, parameters=self.parameters)
             except Exception as err:
                 logger.error(f"{err} in {self.__class__.__name__}.place_trade for {self.symbol.name}")

examples/sample_app/utils/update_trade_records.py

@@ -0,0 +1,17 @@
+import asyncio
+from aiomql import ResultDB, Result, TradeRecords
+
+async def update_sql_records():
+    tr = TradeRecords()
+    # await tr.update_sql_records()
+    # await tr.update_csv_records()
+    await tr.update_json_records()
+
+
+def to_csv():
+    ResultDB.dump_to_csv()
+
+
+if __name__ == "__main__":
+    asyncio.run(update_sql_records())
+    # to_csv()