def update_tables_imperative(tns): ##CandleFetcher.update_tables(tns) ##perform normal update of any legit candles(replacing fake ones) for i, tn in enumerate(tns): sec_now = time.time() last_candle_date = CandleTable.get_last_date(tn) target_curr = CandleTable.get_target_currency(tn) period = int(CandleTable.get_period(tn)) curr_pair = "USDT_" + target_curr last_candle_date += period while (last_candle_date < sec_now): ##(top_bid, bottom_ask) = OrderMaker.get_spread(curr_pair) ##if curr_avail[target_curr]: ##means it is true, means it is available to be sold ##close = bottom_ask ##else: ##close = top_bid close = OrderMaker.get_last_trade_rate(curr_pair, last_candle_date) c = Candle(tn, last_candle_date, 0, 0, 0, close, 0, 0, 0) c.save() last_candle_date += period dbm = DBManager.get_instance() dbm.save_and_close()
def test_add_candle_puts_two_candles_in_list(): cat = Catalogue("2021 catalogue") candle1 = Candle("Beach", 54, "lavender", "square", "4 hours", "10cm by 10cm", "£100") candle2 = Candle("Beach", 2, "lavender", "square", "4 hours", "10cm by 10cm", "£100") cat.add_candle(candle1) cat.add_candle(candle2) assert cat.candles_list == [candle1, candle2]
def cut_table(orig_table_name, date_start, date_end=9999999999): ##print "Cutting table: ", orig_table_name, " candle data between: ", timestamp_to_date(date_start), " ---- ", timestamp_to_date(date_end) ##create new table curr_ref = CandleTable.get_ref_currency(orig_table_name) curr_target = CandleTable.get_target_currency(orig_table_name) period = CandleTable.get_period(orig_table_name) new_table = CandleTable(curr_ref, curr_target, date_start, date_end, period) new_table_name = new_table.table_name if DBManager.exists_table(new_table_name): DBManager.drop_table(new_table_name) new_table.save() ##populate new table with candles from orig_table that lie between the 2 dates candle_array = CandleTable.get_candle_array_by_date( orig_table_name, date_start, date_end) for c in candle_array: new_c = Candle(new_table_name, c.date, c.high, c.low, c.open, c.close, c.volume, c.quoteVolume, c.weightedAverage) new_c.save() dbm = DBManager.get_instance() return new_table_name
def is_morning_star(first_candle: Candle, second_candle: Candle, third_candle: Candle): """ Determines if the candles match a Morning Star bullish candlestick pattern. """ # First check if the first is red and the third is green if first_candle.is_bearish and third_candle.is_bullish: # Make sure the second candle's body does not overlap the first or third if second_candle.close < first_candle.close and second_candle.open < first_candle.close \ and second_candle.close < third_candle.open and second_candle.open < third_candle.open: # Then check if the second candle's body is much smaller than the first if (second_candle.get_body() / first_candle.get_body()) < 0.3: # Check if the third's body is also long (at least 60% of its size) if (third_candle.get_body() / first_candle.get_body()) >= 0.6: # Finally check that the third candle overlaps the first third_center = third_candle.get_body_center() if third_center > (first_candle.close * 1.05) and third_center < ( first_candle.open * 0.95): return True return False
def test_delete_candle_removes_the_candle_from_list(): cat = Catalogue("2021 catalogue") candle1 = Candle("Beach", 54, "lavender", "square", "4 hours", "10cm by 10cm", "£100") candle2 = Candle("Beach", 2, "lavender", "square", "4 hours", "10cm by 10cm", "£100") cat.add_candle(candle1) cat.add_candle(candle2) cat.delete_candle(54) assert cat.candles_list == [candle2]
def test_delete_both_candles_gives_empty_list(): cat = Catalogue("2021 catalogue") candle1 = Candle("Beach", 54, "lavender", "square", "4 hours", "10cm by 10cm", "£100") candle2 = Candle("Beach", 2, "lavender", "square", "4 hours", "10cm by 10cm", "£100") cat.add_candle(candle1) cat.add_candle(candle2) cat.delete_candle(54) cat.delete_candle(2) assert cat.candles_list == []
def getCandleHistoricalData(self): self.CandleData = self.conn.api_query( "returnChartData", { "currencyPair": self.pair, "start": self.startTime, "end": self.endTime, "period": self.period }) self.candles = Candle(self.CandleData)
def insert(self): for c in self.data['candleStick']: try: ct = Candle(self.table_name, c['date'], c['high'], c['low'], c['open'], c['close'], c['volume'], c['quoteVolume'], c['weightedAverage']) try: ct.save() except: "Duplicate candle, cannot insert" except: print("Candle cannot be parsed") dbm = DBManager.get_instance() dbm.save_and_close()
def test_delete_candle_gives_error_if_candle_not_in_list(): cat = Catalogue("2021 catalogue") candle1 = Candle("Beach", 54, "lavender", "square", "4 hours", "10cm by 10cm", "£100") candle2 = Candle("Beach", 2, "lavender", "square", "4 hours", "10cm by 10cm", "£100") candle3 = Candle("Beach", 3, "lavender", "square", "4 hours", "10cm by 10cm", "£100") cat.add_candle(candle1) cat.add_candle(candle2) with pytest.raises(ValueError): cat.delete_candle(candle3) assert cat.candles_list == [candle1, candle2] with pytest.raises(ValueError) as error: cat.delete_candle(candle3) assert str(error.value) == "Item not found"
def build_candles(ticker: str, trader: shift.Trader, state: Dict[str, Any], end_time): queue_size = 30 while trader.get_last_trade_time() < end_time: s = 0 price = trader.get_last_price(ticker) candle = Candle(price, price, price, price) while s < candle_size: price = trader.get_last_price(ticker) if price < candle.low: candle.setLow(price) if price > candle.high: candle.setHigh(price) sleep(1) s += 1 price = trader.get_last_price(ticker) candle.setClose(price) try: state[candles_key][ticker] += [candle] except KeyError: state[candles_key][ticker] = deque(maxlen=queue_size) sleep(0.5) state[candles_key][ticker] += [candle]
def make_graph_with_timeframe(self, interval): relative = interval / self.timeframe assert int(relative) == relative relative = int(relative) new_graph = Graph() new_graph.timeframe = interval new_graph.currency = self.currency for index in range(0, len(self.ask_candles) + 1 - relative, relative): new_graph.ask_candles.append( Candle.merge_candles(self.ask_candles[index:index + relative])) new_graph.bid_candles.append( Candle.merge_candles(self.bid_candles[index:index + relative])) new_graph.dates.append(self.dates[index]) new_graph.set_shortcuts() return new_graph
def candles_from_file(filename): with open(filename) as plik: linie = plik.read().split("\n")[1:-1] values = [l.split(";") for l in linie] dates = [v[0] for v in values] candles = [Candle([to_float(s) for s in v[1:5]]) for v in values] return dates, candles
def update_candles(self): self.candles.append( Candle(self.bar, self.ichimoku.Tenkan.Current.Value, self.ichimoku.Kijun.Current.Value, self.ichimoku.SenkouA.Current.Value, self.ichimoku.SenkouB.Current.Value, self.pattern_long, self.pattern_short))
def test_update_price_on_id_not_found_gives_error(): cat = Catalogue("2021 catalogue") candle1 = Candle("Beach", 54, "lavender", "square", "4 hours", "10cm by 10cm", "£100") cat.add_candle(candle1) with pytest.raises(ValueError) as e: cat.update_candle_price(2, "£80") assert str(e.value) == "Item not found"
def handle_message(msg): if msg['e'] == 'error': print(str(msg)) elif msg['e'] == 'kline': kline = msg['k'] handle_new_candle( msg['s'], Candle(kline['t'], float(kline['o']), float(kline['c']), float(kline['h']), float(kline['l'])))
def test_new_candle_correct(): candle1 = Candle("Beach", 54, "lavender", "square", "4 hours", "10cm by 10cm", "£100") assert candle1.name == "Beach" assert candle1.id == 54 assert candle1.fragrance == "lavender" assert candle1.candle_type == "square" assert candle1.burn_time == "4 hours" assert candle1.dimensions == "10cm by 10cm" assert candle1.price == "£100"
def tick(self, tick): # find candle to tick to for candle in reversed(self._candles): if candle.time <= tick['time'] and candle.close > tick['time']: candle.tick(tick) return if candle.time > tick['time']: break candle = Candle(self, tick=tick) self.candle_builder(candle)
def normalize_candle(self, candle, minVal, maxVal): ratio = (self.IMG_HEIGHT - self.CHART_MARGIN_BOTTOM - self.CHART_MARGIN_TOP - self.CHART_PADDING * 2.0) / (maxVal - minVal) # (320 - 30 -10) / 55-24 = 9 bottom = self.IMG_HEIGHT - self.CHART_MARGIN_BOTTOM - self.CHART_PADDING return Candle(bottom - (candle.open - minVal) * ratio, bottom - (candle.high - minVal) * ratio, bottom - (candle.low - minVal) * ratio, bottom - (candle.close - minVal) * ratio, candle.open_time, candle.close_time, candle.volume)
def detect_bullish_patterns(df: DataFrame): """ Finds all bullish candlestick patterns in a DataFrame with daily candlesticks. :param df: DataFrame with 3 days of candlestick data """ assert type(df) == DataFrame assert len(df) >= 3 symbol = df['symbol'][0] recent_candle1 = Candle(df.iloc[len(df) - 3]) recent_candle2 = Candle(df.iloc[len(df) - 2]) recent_candle3 = Candle(df.iloc[len(df) - 1]) pattern = '' # Search for each type of pattern if is_bullish_engulfing(recent_candle1, recent_candle2, recent_candle3): pattern = 'bullish_engulfing' elif is_three_white_knights(recent_candle1, recent_candle2, recent_candle3): pattern = 'three_white_knights' elif is_morning_star(recent_candle1, recent_candle2, recent_candle3): pattern = 'morning_star' # Confirm a bullish candlestick pattern with a bullish OBV # To prove it's not a false-positive if pattern != '': obv_df = obv(df).df obv_df['obv_ema'] = obv_df['obv'].ewm(span=20).mean() # Check to see if the OBV crossed above the EMA signal recent_obv_df = pd.DataFrame(obv_df.tail(2)) if recent_obv_df['obv'][0] <= recent_obv_df['obv_ema'][0] \ and recent_obv_df['obv'][1] > recent_obv_df['obv_ema'][1]: # print(f'{symbol} crossed the OBV EMA today') return pattern return ''
def load_chart(self, start): con = self.instrument.account.con pair = self.instrument.pair candles = con.get_instrument_history(pair, granularity=self.gran, count=5000, start=start) for candle in candles['candles']: candle['time'] = time_to_datetime(candle['time']) c = Candle(self, candle=candle) self.candle_builder(c) if (len(candles['candles']) == 5000): self.load_chart(candle['time'].isoformat('T') + 'Z')
def get_candle_array_by_date(table_name, date_low = 0, date_high = 9999999999): ##returns a cursor pointing to all candles linked to the table_name cursor = CandleTable.get_candle_cursor_by_date(table_name, date_low, date_high) candles = [] ##loop through cursor and add all candles to array row = cursor.fetchone() while row is not None: t = Candle.from_tuple(table_name, row) candles.append(t) row = cursor.fetchone() return candles
def main(): app.connect('127.0.0.1', 7496, 123) api_thread = threading.Thread(target=run_loop, daemon=True) api_thread.start() time.sleep(1) usdcad_contract = Contract() usdcad_contract.symbol = 'USD' usdcad_contract.secType = 'CASH' usdcad_contract.exchange = 'IDEALPRO' usdcad_contract.currency = 'CAD' requestID = 100 app.reqHistoricalData(requestID, usdcad_contract, '', '10 D', '1 hour', 'BID', 0, 2, True, []) try: while True: time.sleep(3) if app.isDirty(): candles = [] ts = datetime.fromtimestamp(int(app.data[1][0])) print('checking for big shadow for candle @', ts.strftime('%b %d %Y %H:%M:%S')) for i in range(1, config.BS_NUMCANDLES + 1): candles.append( Candle(app.data[i][1], app.data[i][2], app.data[i][3], app.data[i][4])) cg = CandleGroup(candles) if cg.bigShadow(maxBodyRatio=config.BS_BODYRATIO, wickPercent=config.BS_WICKPERCENTAGE): print('big shadow found for candle @', ts.strftime('%b %d %Y %H:%M:%S')) sendtext(('found big shadow on USDCAD 1H @', ts.strftime('%b %d %Y %H:%M:%S'))) except KeyboardInterrupt: pass app.disconnect()
def candle_sticks(ticker): """ return daily time series candle sticks and volumes for a certain ticker """ candles_json = load_json(ticker) time_series = json.loads(candles_json)["Time Series (Daily)"] candles = [] for key in time_series.keys(): candle_date = key candle_value = time_series[candle_date] volume = candle_value["5. volume"] open_ = candle_value["1. open"] close = candle_value["4. close"] high = candle_value["2. high"] low = candle_value["3. low"] candle_ = Candle(candle_date, volume, open_, close, high, low) candles.append(candle_) return sorted(candles)
def test_pearson(self): """ case: empty chart """ c = Chart( Instrument(4) ) self.assertRaises(Exception, c.pearson, 0, c.get_size() ) """ case: one candle """ # TODO """ case: straight line, positive slope """ c = Chart(in_instrument=Instrument(4), count=0) fake_candles = [] fake_timestamp = datetime.utcnow() fake_price = 100.1234 for i in range(0,10): fake_candles.append( Candle( timestamp=fake_timestamp + timedelta(seconds=i), high_ask=fake_price + i, low_bid=(fake_price + i / 2) ) ) c._candles = fake_candles pearson = c.pearson( 0, c.get_size() - 1, 'high_low_avg' ) # Allow some play for float arithmetic self.assertTrue( pearson > 0.99999 and pearson <= 1 ) """ case: straight line, negative slope """ c = Chart( in_instrument=Instrument(4), count=0 ) fake_candles = [] fake_timestamp = datetime.utcnow() fake_price = 100.1234 for i in range(0,10): fake_candles.append( Candle( timestamp=fake_timestamp - timedelta(seconds=i), high_ask=fake_price + i, low_bid=(fake_price + i / 2) ) ) c._candles = fake_candles pearson = c.pearson( 0, c.get_size() - 1, 'high_low_avg' ) # Allow some play for float arithmetic self.assertTrue( pearson < -0.99999 and pearson >= -1 ) """ case: V shape """ c = Chart( in_instrument=Instrument(4), count=0 ) fake_candles = [] fake_timestamp = datetime.utcnow() fake_price = 100.1234 seconds_elapsed = 0 for i in range(9,-1,-1): fake_candles.append( Candle( timestamp=fake_timestamp + timedelta(seconds=seconds_elapsed), high_ask=fake_price + i, low_bid=(fake_price + i / 2) ) ) seconds_elapsed += 1 for i in range(0,10): fake_candles.append( Candle( timestamp=fake_timestamp + timedelta(seconds=seconds_elapsed), high_ask=fake_price + i, low_bid=(fake_price + i / 2) ) ) seconds_elapsed += 1 c._candles = fake_candles pearson = c.pearson( 0, c.get_size() - 1, 'high_low_avg' ) # Allow some play for float arithmetic self.assertTrue( pearson > -0.000001 and pearson < 0.000001 ) """ case: random """ c = Chart( in_instrument=Instrument(4), count=0 ) fake_candles = [] fake_timestamp = datetime.utcnow() fake_price = 100 seconds_elapsed = 0 for i in range(0,10000): offset = random.randrange(1, fake_price) fake_candles.append( Candle( timestamp=fake_timestamp + timedelta(seconds=seconds_elapsed), high_ask=fake_price + offset, low_bid=(fake_price + offset / 2) ) ) seconds_elapsed += 1 c._candles = fake_candles pearson = c.pearson( 0, c.get_size() - 1, 'high_low_avg' ) # Allow some play for float rounding print('pearson of random chart: {}'.format(pearson) ) self.assertTrue( pearson > -0.02 and pearson < 0.02 )
def test_update_price_changes_to_new_price(): cat = Catalogue("2021 catalogue") candle1 = Candle("Beach", 54, "lavender", "square", "4 hours", "10cm by 10cm", "£100") cat.add_candle(candle1) cat.update_candle_price(54, "£80") assert candle1.price == "£80"
def __init__( self, in_instrument, # <Instrument> granularity='S5', # string - See Oanda's documentation count=None, # int - number of candles start=None, # datetime - UTC end=None, # datetime - UTC price='MBA', # string include_first=None, # bool daily_alignment=None, # int alignment_timezone=None, # string - timezone weekly_alignment=None ): self._candles = [] # verify instance of <Instrument> by accessing a member. if in_instrument.get_id() == 0: pass if not count in [0]: # do send None # get candles from broker instrument_history = Broker.get_instrument_history( instrument=in_instrument, granularity=granularity, count=count, from_time=start, to=end, price=price, include_first=include_first, daily_alignment=daily_alignment, alignment_timezone=alignment_timezone, weekly_alignment=weekly_alignment ) if instrument_history == None: Log.write('chart.py __init__(): Failed to get instrument history.') raise Exception else: candles_raw = instrument_history['candles'] for c_r in candles_raw: new_candle = Candle( timestamp=util_date.string_to_date(c_r['time']), volume=float(c_r['volume']), complete=bool(c_r['complete']), open_bid=float(c_r['bid']['o']), high_bid=float(c_r['bid']['h']), low_bid=float(c_r['bid']['l']), close_bid=float(c_r['bid']['c']), open_ask=float(c_r['ask']['o']), high_ask=float(c_r['ask']['h']), low_ask=float(c_r['ask']['l']), close_ask=float(c_r['ask']['c']) ) self._candles.append(new_candle) self._instrument = in_instrument self._granularity = granularity self._start_index = 0 # start self._price = price self.include_first = include_first self.daily_alignment = daily_alignment self._alignment_timezone = alignment_timezone self.weekly_alignment = weekly_alignment
def main(): app.connect('127.0.0.1', 7496, 123) api_thread = threading.Thread(target=run_loop, daemon=True) api_thread.start() time.sleep(1) for fc in pairs: app.reqHistoricalData(fc.requestId(), fc.contract(), '', '2 D', '1 hour', 'BID', 0, 2, True, []) try: lastTS = {} for cp in pairs: lastTS[cp.pair()] = -1 while True: time.sleep(10) for cp in pairs: data = app.data[cp.pair()] print( 'last close price for ', cp.pair(), 'is', data[0][4], '@', datetime.fromtimestamp(int( data[0][0])).strftime('%b %d %Y %H:%M:%S')) if lastTS[cp.pair()] == data[0][0]: continue lastTS[cp.pair()] = data[0][0] candles = [] cnt = 1 while len(candles) != config.BS_NUMCANDLES: candles.append( Candle(data[cnt][1], data[cnt][2], data[cnt][3], data[cnt][4])) if len(candles) == 1: ts = datetime.fromtimestamp(int(data[cnt][0])) print(cp.pair(), ': checking candle patterns @', ts.strftime('%b %d %Y %H:%M:%S')) cnt += 1 cg = CandleGroup(candles) found = False msgString = '' if candles[0].isHammer(): msgString += cp.pair( ) + ' : hammer found for candle @ ' + ts.strftime( '%b %d %Y %H:%M:%S\n') found = True if candles[0].isHangingMan(): msgString += cp.pair( ) + ' : hanging man found for candle @ ' + ts.strftime( '%b %d %Y %H:%M:%S\n') found = True if cg.bigShadow(maxBodyRatio=config.BS_BODYRATIO, wickPercent=config.BS_WICKPERCENTAGE): msgString += cp.pair( ) + ' : big shadow found for candle @ ' + ts.strftime( '%b %d %Y %H:%M:%S\n') found = True if found: print(msgString) sendtext(msgString) except KeyboardInterrupt: pass app.disconnect()
def get_candles(self): candles: list = self.api.get_realtime_candles(self.active.name, self.candle_size) return list(map(lambda key: Candle(candles[key]), candles))
from ichimoku import Ichimoku from candle import Candle symbols = ['BTCUSDT'] candles = {} ichimoku = {} client = Client('', '') bsm = BinanceSocketManager(client) for symbol in symbols: klines = client.get_klines(symbol=symbol, interval=KLINE_INTERVAL_1MINUTE) candles[symbol] = list( map( lambda candle: Candle(candle[0], float(candle[1]), float(candle[ 4]), float(candle[2]), float(candle[3])), klines[len(klines) - 53:])) # print(candles[symbol]) ichimoku[symbol] = Ichimoku(candles[symbol][:-1]) print('RESULT') print(ichimoku[symbol].result) def handle_message(msg): if msg['e'] == 'error': print(str(msg)) elif msg['e'] == 'kline': kline = msg['k'] handle_new_candle( msg['s'],
class Trader: def __init__(self, username, password, startTime, endTime, period): periodList = { '5': 300, '15': 900, '30': 1800, '120': 7200, '240': 14400, '1440': 86400 } self.period = periodList[period] self.pair = "USDT_BTC" self.onTop = "SimpleMM" self.order = 'IDLE' self.startTime = self.TimeToUnix(startTime) self.endTime = self.TimeToUnix(endTime) self.username = username self.password = password self.CandleData = None self.candles = [] # CANDLE LIST #NECESSIDADES PARA PLOTAR GRAFICO self.simple = [] self.exp20 = [] self.exp30 = [] self.lugares_compra = [] self.lugares_venda = [] self.BSPoints = ['', '', ''] self.conn = self.Connection() self.player1 = Player() self.player2 = Player() #Connects with Poloniex def Connection(self): counter = 0 while True: try: print('Trying connection') conn = poloniex(self.username, self.password) return conn except: wait(1) counter += 1 pass if counter == 10: print('fail connection please try again') break #Convert time format (Ymd to Unix) def TimeToUnix(self, date): return time.mktime( datetime.datetime.strptime(date, "%Y%m%d").timetuple()) #Convert time format (Unix to dmY) def UnixToTime(self, date): return datetime.datetime.utcfromtimestamp( float(date)).strftime('%d-%m-%Y') #Estructure for ticker def setTickerList(self, ticker): tickerListNames = [ 'last', 'lowestAsk', 'highestBid', 'percentChange', 'baseVolume', 'quoteVolume', 'isFrozen', '24hrHigh', '24hrLow' ] tickerList = dict() tickerList['currencyPair'] = [] for name in tickerListNames: tickerList[name] = [] for name in ticker: tickerList['currencyPair'].append(name) for label in tickerListNames: try: tickerList[label].append(ticker[name][label]) except: tickerList[label].append(False) return tickerList #Get all candles data def getCandleHistoricalData(self): self.CandleData = self.conn.api_query( "returnChartData", { "currencyPair": self.pair, "start": self.startTime, "end": self.endTime, "period": self.period }) self.candles = Candle(self.CandleData) def Get_Ticker(self): ticker = self.conn.returnTicker() tickerList = self.setTickerList(ticker) self.tickerList = pd.DataFrame(tickerList, columns=[ 'currencyPair', 'last', 'lowestAsk', 'highestBid', 'percentChange', 'baseVolume', 'quoteVolume', 'isFrozen', '24hrHigh', '24hrLow' ]) return self.tickerList # OBS :Poderia ter apenas dado pass nos 50 primeiros e usar slicing para controlar as janelas - mais facil def Backtest(self): strat1 = BacktestStrategy() strat2 = BacktestStrategy() player1 = Player() SimpleAvData = [] ExpAvData = [] prevExpAv20 = None prevExpAv30 = None ExpAvData20 = None ExpAvData30 = None firstCandle = True bank = 0 counter = 0 for x in range(0, len(self.candles)): #starting average vectors if x < 50: SimpleAvData.append(self.candles.close(x)) self.simple.append(self.candles.close(x)) self.exp20.append(self.candles.close(x)) self.exp30.append(self.candles.close(x)) if x < 30: ExpAvData.append(self.candles.close(x)) else: ExpAvData.append(self.candles.close(x)) ExpAvData.pop(0) else: if firstCandle == True: PrevSimpleAv20 = None PrevSimpleAv50 = None firstCandle = False else: SimpleAvData.append(self.candles.close(x)) SimpleAvData.pop(0) ExpAvData.append(self.candles.close(x)) ExpAvData.pop(0) #Momento de compra venda ou idle self.BSPoints = player1.OrderRules(self.candles.open(x), self.candles.date(x), self.order, x) if self.BSPoints[2] == 'BUY': self.lugares_compra.append(self.BSPoints) elif self.BSPoints[2] == 'SELL': self.lugares_venda.append(self.BSPoints) SimpleAv20, SimpleAv50 = self.MMS(SimpleAvData) ExpAvData30, prevExpAv30 = self.MME( ExpAvData30, self.candles.close(x), 30) ExpAvData20, prevExpAv20 = self.MME( ExpAvData20, self.candles.close(x), 20) self.simple.append(SimpleAv20) self.exp30.append(ExpAvData30) self.exp20.append(ExpAvData20) ''' Agora abaixo vao as estrategias chamadas da class Strategy, podemos instaciar um objeto de class para cada estrategia e ter todos os resultados do backtest ao final da apresentacao ''' if PrevSimpleAv20 == None: PrevSimpleAv20 = SimpleAv20 else: self.onTop, self.order = strat2.ExpSimpleAv( SimpleAv20, ExpAvData20, ExpAvData30, self.onTop) PrevSimpleAv20 = SimpleAv20 return player1 #Media Movel Simples def MMS(self, SimpleAvData): #print (len(SimpleAvData)) return np.average(SimpleAvData), np.average(SimpleAvData[30:]) #Media Movel Exponencial def MME(self, prevEMA, lastCandleValue, period): if prevEMA != None: multiplier = 2 / (period + 1) new_prevEMA = prevEMA mme = ((lastCandleValue - prevEMA)) * multiplier + prevEMA else: mme = lastCandleValue new_prevEMA = mme return mme, new_prevEMA def graphs(self): xdate = [] fig, ax = plt.subplots() ax.xaxis.set_major_locator(ticker.MaxNLocator(6)) for i in range(0, len(self.candles)): xdate.append(self.candles.getTime(i)) def nested_mydate(x, pos): try: return xdate[int(x)] except IndexError: return '' ax.xaxis.set_major_formatter(ticker.FuncFormatter(nested_mydate)) candlestick2_ohlc(ax, self.candles.open2(), self.candles.high2(), self.candles.low2(), self.candles.close2(), width=0.6) fig.autofmt_xdate() fig.tight_layout() #MMS e MME plt.plot(self.simple, 'b--') plt.plot(self.exp20, 'r--') plt.plot(self.exp30, 'r--') #pontos de compra xcompra_val = [x[0] for x in self.lugares_compra] ycompra_val = [x[1] for x in self.lugares_compra] #pontos de venda xvenda_val = [x[0] for x in self.lugares_venda] yvenda_val = [x[1] for x in self.lugares_venda] plt.plot(ycompra_val, xcompra_val, 'g^') plt.plot(yvenda_val, xvenda_val, 'y^') plt.show()