1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

from AlgoAPI import AlgoAPIUtil, AlgoAPI_Backtest


class AlgoEvent:
    def __init__(self):
        self.gold = "XAUUSD"
        self.silver = "XAGUSD"
        self.volume = 0.01

        self.last_week = None
        self.target = None

    def start(self, mEvt):
        self.evt = AlgoAPI_Backtest.AlgoEvtHandler(self, mEvt)
        self.evt.start()

    def on_bulkdatafeed(self, isSync, bd, ab):
        if not isSync:
            return

        timestamp = bd[self.gold]["timestamp"]
        week = timestamp.isocalendar()[:2]

        # Run once every calendar week
        if week == self.last_week:
            return

        gold_momentum = self.momentum(self.gold, timestamp)
        silver_momentum = self.momentum(self.silver, timestamp)

        if gold_momentum is None or silver_momentum is None:
            return

        self.last_week = week

        self.evt.consoleLog(
            "Weekly rebalance:",
            timestamp,
            "XAUUSD momentum=",
            round(gold_momentum, 6),
            "XAGUSD momentum=",
            round(silver_momentum, 6)
        )

        # Both weak: target is cash
        if gold_momentum <= 0 and silver_momentum <= 0:
            self.target = None

        # Hold the stronger metal
        elif gold_momentum > silver_momentum:
            self.target = self.gold

        elif silver_momentum > gold_momentum:
            self.target = self.silver

        else:
            return

        self.rebalance()

    def momentum(self, instrument, timestamp):
        bars = self.evt.getHistoricalBar(
            contract={"instrument": instrument},
            numOfBar=25,
            interval="D",
            timestamp=timestamp
        )

        if bars is None or len(bars) < 25:
            return None

        close = [bars[t]["c"] for t in bars]

        if close[-20] == 0:
            return None

        return (close[-1] - close[-20]) / close[-20]

    def rebalance(self):
        """
        Requires Position Netting = False.

        Close all unwanted trades first.
        Once each close is completed, on_orderfeed() calls rebalance()
        again until the portfolio matches self.target.
        """
        pos, orders, pending = self.evt.getSystemOrders()

        # Close positions when target is cash,
        # or close positions in the non-target metal.
        for tradeID in orders:
            instrument = orders[tradeID]["instrument"]

            if self.target is None or instrument != self.target:
                self.close_order(tradeID)
                return

        # No target means all positions have been closed.
        if self.target is None:
            self.evt.consoleLog("Portfolio is in cash.")
            return

        # Do nothing if already holding the target instrument.
        for tradeID in orders:
            if orders[tradeID]["instrument"] == self.target:
                self.evt.consoleLog("Already holding:", self.target)
                return

        # Portfolio is flat: open the selected metal.
        self.open_order(self.target)

    def open_order(self, instrument):
        order = AlgoAPIUtil.OrderObject(
            instrument=instrument,
            orderRef="momentum",
            openclose="open",
            buysell=1,
            ordertype=0,
            volume=self.volume
        )

        self.evt.consoleLog("Opening long position:", instrument)
        self.evt.sendOrder(order)

    def close_order(self, tradeID):
        order = AlgoAPIUtil.OrderObject(
            tradeID=tradeID,
            openclose="close"
        )

        self.evt.consoleLog("Closing tradeID:", tradeID)
        self.evt.sendOrder(order)

    def on_orderfeed(self, of):
        self.evt.consoleLog(
            "Order update:",
            of.status,
            of.openclose,
            of.instrument,
            of.tradeID
        )

        # After an old trade is closed, continue the rotation.
        if of.status == "success" and of.openclose == "close":
            self.rebalance()

    def on_marketdatafeed(self, md, ab):
        pass

    def on_openPositionfeed(self, op, oo, uo):
        pass

    def on_dailyPLfeed(self, pl):
        pass