Тестирование

import time
import json
import requests
import urllib, http.client
import hmac, hashlib
import mysql.connector
import sys

# Если нет нужных пакетов - читаем тут: https://bablofil.ru/python-indicators/
import numpy
import talib

from datetime import datetime

#Установим дату и время начала тестирования
time_start = (2018, 2, 28, 0, 0, 0, 0, 0, 0)
timestampstart = time.mktime(time_start)
#print(timestampstart)
print('Начало тестирования', datetime.fromtimestamp(timestampstart))
#Установим дату и время завершения тестирования
time_end = (2018, 3, 4, 0, 0, 0, 0, 0, 0)
timestampend = time.mktime(time_end)
#print(timestampend)
print('Завершение тестирования',datetime.fromtimestamp(timestampend))

#y=int(time.time()) - 3600*24*2
y=int(timestampstart)

#print(datetime.fromtimestamp(y))
PERIOD = 5 # Период в минутах для построения свечей краткосрочного MACD
BEAR_PERC = 100  # % что считаем поворотом при медведе (подробности - https://bablofil.ru/macd-python-stock-bot/
BULL_PERC = 0  # % что считаем поворотом при быке (поймать максимум 99)
BUY=True
PROFIT = 1

# ключи API, которые предоставила exmo
#API_KEY = 'K-            кей'
# обратите внимание, что добавлена 'b' перед строкой
#API_SECRET = b'S-секрет'

# Список пар, на которые торгуем
MARKETS = [
    'BTC_USD'
]

CAN_SPEND = 20 # Сколько USD готовы вложить в бай
MARKUP = 0.001 # 0.001 = 0.1% - Какой навар со сделки хотим получать

STOCK_FEE = 0.002 # Какую комиссию берет биржа
#PERIOD = 4 # Период в минутах для построения свечей
ORDER_LIFE_TIME = 0.5 # Через сколько минут отменять неисполненный ордер на покупку 0.5 = 30 сек.

USE_MACD = True # True - оценивать тренд по MACD, False - покупать и продавать невзирая ни на что



API_URL = 'api.exmo.me'
API_VERSION = 'v1'

#USE_LOG = False
USE_LOG = True

DEBUG = False # True - выводить отладочную информацию, False - писать как можно меньше

numpy.seterr(all='ignore')

curr_pair = None

# Свой класс исключений
class ScriptError(Exception):
    pass
class ScriptQuitCondition(Exception):
    pass
    
# все обращения к API проходят через эту функцию
def call_api(api_method, http_method="POST", **kwargs):
    
    payload = {'nonce': int(round(time.time()*1000))}

    if kwargs:
        payload.update(kwargs)
    payload =  urllib.parse.urlencode(payload)

    H = hmac.new(key=API_SECRET, digestmod=hashlib.sha512)
    H.update(payload.encode('utf-8'))
    sign = H.hexdigest()
    
    headers = {"Content-type": "application/x-www-form-urlencoded",
           "Key":API_KEY,
           "Sign":sign}
    conn = http.client.HTTPSConnection(API_URL, timeout=90)
    conn.request(http_method, "/"+API_VERSION + "/" + api_method, payload, headers)
    response = conn.getresponse().read()
    
    conn.close()

    try:
        obj = json.loads(response.decode('utf-8'))

        if 'error' in obj and obj['error']:
            raise ScriptError(obj['error'])
        return obj
    except json.decoder.JSONDecodeError:
        raise ScriptError('Ошибка анализа возвращаемых данных, получена строка', response)

# Получаем с биржи данные, необходимые для построения индикаторов
#def get_ticks(pair):
def get_ticks(pair, PER):
    global y
    #print('PER =', PER)
    #resource = requests.get('https://api.exmo.me/v1/trades/?pair=%s&limit=10000' % pair)
    #data = json.loads(resource.text)
    #_SQL = """select * from trade"""
    #x=int(time.time())
    print(datetime.fromtimestamp(y))
    pr = PER * 60
    x= y - pr*100
    #_SQL = """select * from trade where date between 1519318790 and 1519318800; """
    _SQL = """SELECT
                    FLOOR(MIN(`date`)/%s)*%s AS date,
                    SUBSTRING_INDEX(MIN(CONCAT(`date`, '_', id, '_', price)), '_', -1) AS `open`,
                    MAX(price) AS high,
                    MIN(price) AS low,
                    SUBSTRING_INDEX(MAX(CONCAT(`date`, '_', id, '_', price)), '_', -1) AS `close`
              FROM trade
              WHERE date >= %s and date <= %s
              GROUP BY FLOOR(`date`/%s)
              ORDER BY date"""
    db = mysql.connector.connect(host="localhost", user="u", passwd="secret", db="exmo")
    cur = db.cursor()
    cur.execute(_SQL,(pr,pr,x,y,pr))
    chart_data = {} # сформируем словарь с ценой закрытия по PERIOD минут
    #s=int(float(data[pair][1]['date'])/(PERIOD*60))*(PERIOD*60) #Время последней свечи, которая все время  меняется
    for item in cur.fetchall():
        d = item[0] # Округляем время сделки до PERIOD минут
        if not d in chart_data:
            chart_data[d] = {'open':0, 'close':0, 'high':0, 'low':0}
        chart_data[d]['close'] = float(item[4])
        chart_data[d]['open'] = float(item[1])
        chart_data[d]['high'] = float(item[2])
        chart_data[d]['low'] = float(item[3])
    cur.close()
    db.close()
    return chart_data
# С помощью MACD делаем вывод о целесообразности торговли в данный момент (https://bablofil.ru/macd-python-stock-bot/)

def get_macd_advice(chart_data):  
    quotes = {}
    quotes['open']=numpy.asarray([chart_data[item]['open'] for item in sorted(chart_data)])
    quotes['close']=numpy.asarray([chart_data[item]['close'] for item in sorted(chart_data)])
    quotes['high']=numpy.asarray([chart_data[item]['high'] for item in sorted(chart_data)])
    quotes['low']=numpy.asarray([chart_data[item]['low'] for item in sorted(chart_data)])
    #print(quotes['close'][-1])

    macd, macdsignal, macdhist = talib.MACD(quotes['close'], fastperiod=12, slowperiod=26, signalperiod=9)
    slowk, slowd = talib.STOCH(quotes['high'], quotes['low'], quotes['close'], fastk_period=21, slowk_period=1, slowk_matype=0, slowd_period=3, slowd_matype=0)
    #macd, macdsignal, macdhist = talib.MACD(numpy.asarray([chart_data[item] for item in sorted(chart_data)]), fastperiod=12, slowperiod=26, signalperiod=9)
    #real  = talib.RSI(numpy.asarray([chart_data[item] for item in sorted(chart_data)]), timeperiod=14)
    real = talib.AROONOSC(quotes['high'], quotes['low'], timeperiod=14)
    idx = numpy.argwhere(numpy.diff(numpy.sign(macd - macdsignal)) != 0).reshape(-1) + 0
    inters = []
    for offset, elem in enumerate(macd):
        if offset in idx:
            inters.append(elem)
        else:
            inters.append(numpy.nan)
    trand = 'BULL' if macd[-1] > macdsignal[-1] else 'BEAR'
    max_v = 0
    growing = False
    for offset, elem in enumerate(macdhist):
        growing = False      
        curr_v = macd[offset] - macdsignal[offset]
        if abs(curr_v) > abs(max_v):
            max_v = curr_v
        perc = curr_v/max_v        
        if      (macd[offset] > macdsignal[offset]): # восходящий тренд
            v = 1
            growing = True
            mc = macd[offset]
        else:
            v = 0
        if offset in idx and not numpy.isnan(elem):
            # тренд изменился
            max_v = curr_v = 0 # обнуляем пик спреда между линиями
        #hist_data.append(v*1000)
    #hist_data2 = []
    for offset, elem in enumerate(slowk):
        a=20
        p_a=float(slowk[offset-1])
        p_b=float(slowd[offset-1])
        p_c=float(slowd[offset])
        p_d=float(slowk[offset])
        try:
            if (p_a<a and p_b<a and p_c<a and p_d<a) and (p_a==p_b and p_a==p_d):
                av_point=a/2
            elif (p_a>100-a and p_b>100-a and p_c>100-a and p_d>100-a) and (p_a==p_b and p_a==p_d):
                av_point=100-a/2
            else:
                av_point=((p_c-p_b)*(p_a-p_b)/((p_c-p_b)+(p_a-p_d)))+p_b
        except:
            print('деление на 0?')
        v=0
        if (slowk[offset-1] < slowd[offset-1] and slowk[offset] >= slowd[offset] and av_point<a):
            v = -1 # Покупать!
        if (slowk[offset-1] > slowd[offset-1] and slowk[offset] <= slowd[offset] and av_point>80):
            #activity_time = True
            v= 1 # Продовать!
        #hist_data2.append(v)
    #return ({'curr':(macd[-1] -  macdsignal[-1]),'macd':mc,  'trand':trand, 'growing':growing,'stoch':v, 'close':quotes['close'][-1],'rsi':real[-1]})
    return ({'trand':trand, 'growing':growing,'stoch':v, 'close':quotes['close'][-1]})
# Выводит всякую информацию на экран, самое важное скидывает в Файл log.txt
def log(*args):
    
    if USE_LOG:
        l = open("./tester.txt", 'a', encoding='utf-8')
        #print(datetime.now(), *args, file=l)
        print(datetime.fromtimestamp(y), *args, file=l)
        l.close()
    #print(datetime.now(),' ', *args)
    print(datetime.fromtimestamp(y),' ', *args)

# Ф-ция для создания ордера на покупку
def create_buy(pair):
    #global USE_LOG
    #USE_LOG = True
    log(pair, "Создаем ордер на покупку")
    #USE_LOG = False  
    
# Ф-ция для создания ордера на продажу
def create_sell(pair):
    #global USE_LOG
    #USE_LOG = True
    log(pair, "Создаем ордер на продажу")
# Ф-ция для определения падения  цены покупки
def good_price(pair): # Возвращает True при  цене продажи > 1.005 цены покупки
    drop = True
    return(drop)
# Бесконечный цикл процесса - основная логика
while True:
    try:
        for pair in MARKETS: # Проходим по каждой паре из списка в начале\           
            try:
                macd_advice = get_macd_advice(chart_data=get_ticks(pair,PERIOD))
                print("Ситуация на рынке:", macd_advice)
                if BUY:
                    #if macd_advice['growing'] and macd_advice['stoch']==-1:
                    if macd_advice['growing']:
                        BUY = False
                        log(pair, "Ситуация на рынке:", macd_advice)
                        PRICE = macd_advice['close']
                        log(pair, "цена покупки:", PRICE)
                        PRICE1 = PRICE *1.005
                        #log(pair, "Продажа не дешевле:", PRICE1)
                        log(pair, "Покупаем")
                        log(pair, "-------------------------------------------")
                else:
                #if False:
                    #if macd_advice['growing'] and macd_advice['stoch']==1:
                    if not macd_advice['growing']:
                        if macd_advice['close'] >= PRICE1:
                            log(pair, "Ситуация на рынке:", macd_advice)
                            #log(pair, "Продажа не дешевле:", PRICE1)
                            PRICE2 = macd_advice['close']     
                            log(pair, "Цена продажи:", PRICE2)
                            BUY =  True
                            PROF = PRICE2/PRICE - 0.004
                            log(pair, "Профит от продажи:", PROF)
                            PROFIT = PROFIT*PROF
                            log(pair, "Профит от начала:", PROFIT)
                            log(pair, "Продаем")
                            log(pair, "-------------------------------------------")
                        #else:
                            #log(pair, "цена покупки:", PRICE)
                            #log(pair, "Ситуация на рынке:", macd_advice)
                            #log(pair, "не продаем дешевле!")
            except ScriptError as e:
                    print(e)
            except ScriptQuitCondition as e:
                print(e)
            except Exception as e:
                print("!!!!",e)
        #time.sleep(1)
        y=y+10 # Прибавляем 10 с.
        if y > timestampend:
            log(pair, "Завершение тестирования!")
            sys.exit()
    except Exception as e:
        print(e)