def load_level_from_Data(self, data):
"""
загружаем предобработанные данные, сгрупированные по дням.
Параметры:
filename: str Путь до файла с уровнем.
verbose: bool
"""
self.Arch_Data = data
self.Data = self.Arch_Data
self.DaysCount = len(self.Data)
self.days_steps = [len(day[1]) for day in self.Data]
self.total_steps = sum(self.days_steps)
self.current_day_vectors = self.Data[self.current_day]
self.current_day_candles = self.Data[self.current_day][2]
self.strategy = strat.Strategy(self.current_day_candles)
self.check_point_ind = -1
self.check_points = {}
self.level_finished = False
self.global_index = []
for i in range(len(self.Data)):
for j in range(len(self.Data[i][1])):
self.global_index.append((i, j))
self.level_loaded = True
return
def load_level(self, filename, verbose=True, day_len=-1):
"""
Функция, загружающая файл с уровнем. Уровень должен быть загружен до начала игры.
Параметры:
filename: str Путь до файла с уровнем.
verbose: bool
"""
if verbose:
print(u'Открываем файл ', filename)
self.Arch_Data = dataIO.load_by_Dates(filename)
self.Data = self.Arch_Data
self.DaysCount = len(self.Data)
if day_len != -1:
self.apply_data_len(len=day_len)
self.days_steps = [len(day[1]) for day in self.Data]
self.total_steps = sum(self.days_steps)
self.current_day_vectors = self.Data[self.current_day]
self.current_day_candles = self.Data[self.current_day][2]
self.strategy = strat.Strategy(self.current_day_candles)
self.check_point_ind = -1
self.check_points = {}
self.level_finished = False
self.global_index = []
for i in range(len(self.Data)):
for j in range(len(self.Data[i][1])):
self.global_index.append((i, j))
self.level_loaded = True
if verbose:
print('Done: ', self.DaysCount, " days")
return
def __init__(self):
self.accountNumber = ''
self.optionExpiry = '20121221' # This needs manual updating!
self.maxAskBidRatio = 1.25
self.maxAskLastPriceRatio = 1.02
self.maxOrderQueueLength = 3
# Create a file for TWS logging
self.twslog_fh = open('/home/mchan/git/Artemis/twslog.txt', 'a', 0)
self.twslog_fh.write("Session Started " +
str(datetime.datetime.now()) + "\n")
self.callback = ArtemisIBWrapperSilent.ArtemisIBWrapper()
self.tws = EPosixClientSocket(self.callback)
self.orderIdCount = 1 # This will be updated automatically
self.requestIdCount = 1
self.invested = False
self.maxLimitPriceFactor = 1.02 # No limit orders above 2% of current ask price
# Connect the socket
self.socketnum = 30
self.tws.eConnect("", 7496, self.socketnum, poll_interval=1)
# Strategy Generic object, has methods for interpreting consensus out/under performance
self.Strat = strategy.Strategy()
# Queue for orders
self.orderQueue = []
# Setup DB connector
self.db = dbutil.db(h='127.0.0.1', schema='mchan')
# Query Cash Account Balance
self.updateBuyingPowerNextId()
def test_strategy():
s = strategy.Strategy('2 0.1 0.0 1.0 1.0 0.0 1.0 0.9 0.1 0.9 0.1')
assert s._h == 2
assert np.array_equal(s._p, [0.1, 1.0])
assert np.array_equal(s._a, [[0.0, 1.0], [0.9, 0.1]])
assert np.array_equal(s._b, [[1.0, 0.0], [0.9, 0.1]])
def loadStrategies(self,
league="all",
matchType="all",
edge=3,
size=10000000000000000,
duration=tools.MINUTE * 10,
quoter=False,
hitter=False):
"""Loads strategies in league specified of type specified
"""
for m in self.gateway.matches:
match = self.gateway.matches[m]
if match.details["expiry"] < tools.curTime():
continue
if match.details["league"] != league and league != "all":
continue
if match.details["type"] != matchType and matchType != "all":
continue
if match.matchName in self.strategiesByMatch:
if len(self.strategiesByMatch[
match.matchName]) >= self.maxStrategiesPerMatch:
continue
else:
self.strategiesByMatch[match.matchName] = []
#if we've made it this far, we want to add this match
self.logger.info(
"Adding strategy for {0} with edge {1}, size {2}, quoter status {3}, hitter status {4}"
.format(match.matchName, edge, size, quoter, hitter))
s = strategy.Strategy(match, edge, size, duration, quoter, hitter)
idx = len(self.strategies)
self.strategies.append(s)
self.strategiesByMatch[match.matchName].append(idx)
def setUp(self):
self.player = player.Player(1, [], 0)
self.strat = strategy.Strategy()
self.carnivore = species.Species(0, 1, 1, [])
self.carnivore.setTraits([trait.Trait.carnivore])
self.fat_carnivore = species.Species(0, 1, 1, [])
self.fat_carnivore.setTraits([trait.Trait.carnivore])
self.fat_carnivore.setBodySize(5)
self.herbavore = species.Species(0, 1, 1, [])
self.fat_herbavore = species.Species(0, 1, 1, [])
self.fat_herbavore.setBodySize(4)
self.fat_tissue = species.Species(0, 1, 1, [])
self.fat_tissue.setBodySize(3)
self.fat_tissue.setTraits([trait.Trait.fat_tissue])
self.fat_fat_tissue = species.Species(0, 1, 1, [])
self.fat_fat_tissue.setBodySize(6)
self.fat_fat_tissue.setTraits([trait.Trait.fat_tissue])
self.opherb = species.Species(0, 1, 1, [])
self.opfatherb = species.Species(0, 1, 1, [])
self.opfatherb.setBodySize(4)
self.opponent1 = player.Player(1, [], 0)
self.opponent1.setSpeciesBoards([self.opherb, self.opfatherb])
self.opponents = [self.opponent1]
self.dealer = dealer.Dealer()
self.dealer.setListOfPlayers([self.player, self.opponent1])
self.dealer.setWateringHole(4)
def test_strategy_prob_for_state():
s = strategy.Strategy('2 0.1 0.0 1.0 1.0 0.0 1.0 0.9 0.1 0.9 0.1')
assert np.array_equal(s._prob_for_state(0, 0), [1.0, 0.0])
assert np.array_equal(s._prob_for_state(0, 1), [0.0, 1.0])
assert np.array_equal(s._prob_for_state(1, 0), [0.9, 0.1])
assert np.array_equal(s._prob_for_state(1, 1), [0.9, 0.1])
def trade_mock(curr_date, insts=[['IF1412', 'IF1503']]):
logging.basicConfig(
filename="ctp_trade_mock.log",
level=logging.INFO,
format=
'%(name)s:%(funcName)s:%(lineno)d:%(asctime)s %(levelname)s %(message)s'
)
instruments = list(set(itertools.chain(*insts)))
data_func = [
('d', BaseObject(name = 'ATR_20', sfunc=fcustom(data_handler.ATR, n=20), rfunc=fcustom(data_handler.atr, n=20))), \
('d', BaseObject(name = 'DONCH_L10', sfunc=fcustom(data_handler.DONCH_L, n=10), rfunc=fcustom(data_handler.donch_l, n=10))),\
('d', BaseObject(name = 'DONCH_H10', sfunc=fcustom(data_handler.DONCH_H, n=10), rfunc=fcustom(data_handler.donch_h, n=10))),\
('d', BaseObject(name = 'DONCH_L20', sfunc=fcustom(data_handler.DONCH_L, n=20), rfunc=fcustom(data_handler.donch_l, n=20))),\
('d', BaseObject(name = 'DONCH_H20', sfunc=fcustom(data_handler.DONCH_H, n=20), rfunc=fcustom(data_handler.donch_h, n=20))),\
('1m',BaseObject(name = 'EMA_3', sfunc=fcustom(data_handler.EMA, n=3), rfunc=fcustom(data_handler.ema, n=3))), \
('1m',BaseObject(name = 'EMA_30', sfunc=fcustom(data_handler.EMA, n=30), rfunc=fcustom(data_handler.ema, n=30))) \
]
test_strat = strat.Strategy('TestStrat', [insts], None, data_func,
[[1, -1]])
strat_cfg = {'strategies': [test_strat], \
'folder': 'C:\\dev\\src\\ktlib\\pythonctp\\pyctp\\', \
'daily_data_days':25, \
'min_data_days':2 }
agent_name = "Test"
tday = curr_date
my_agent, my_trader = create_agent_with_mocktrader(agent_name, instruments,
strat_cfg, tday)
my_user = MarketDataMock(my_agent)
req = BaseObject(InstrumentID='cu1502')
my_agent.resume()
my_user.play_tick(tday)
def main(argv):
back_mode = False
# Either we run in real-time mode with current market data feed
# or we can force a back-test mode where we give the algorithm the number of days
# in the past where it should start
if len(argv) == 0:
LogPrint("Trader Started Running in Real-Time Mode\n")
elif len(argv) != 1:
LogPrint(
"Usage : Start without Args for Real-Time or -b for backtesting for a number of previous days\n"
)
sys.exit(2)
elif argv[0] != '-b':
LogPrint(
"Usage : Start without Args for Real-Time or -b for backtesting for a number of previous days\n"
)
sys.exit(2)
else:
back_mode = True
xreader = xr.XChangeReader() # init Exchange Data Reader
strategy = stg.Strategy(
currency, granularity) # init strategy with the target currency
if not back_mode:
run_realtime(xreader, strategy)
else:
run_backtest(xreader, strategy)
def next(self):
"""
сдвинуть все счетчики на 1
если переместились в след. день - поменять стратегию
если находимся в последнем баре, никуда не смещаемся
"""
if self.current_global_step >= self.total_steps - 1: # никуда не смещаемся, если дошли до последнего бара
self.level_finished = True
return
_before_day = self.current_day # запоминаем текущий день
self.current_global_step += 1 # увеличиваем глобальный шаг на день
# обновляем счетики дня счетчик бара внутри дня
self.current_day, self.current_day_step = self.get_day_step(
self.current_global_step)
# если мы переместились в следующий день, то надо поменять стратегию на след день
if _before_day < self.current_day:
self.score_without_curr_strat += self.score_by_curr_strat
self.score_by_curr_strat = 0.0
self.current_day_candles = self.Data[self.current_day][2]
self.strategy = strat.Strategy(
self.current_day_candles) # создаем новую стратегию
# print "next day : ", self.current_day
# так как стратегия поменялась - надо о обновить профиты
else:
self.strategy.bar += 1
return
def test_time():
ref = ai.Strategy()
board, player, moves = cases[30]
tic = time.time()
for i in range(10000):
ref.get_valid_moves(board, player)
toc = time.time()
print(toc-tic)
def __init__(self, agent, policy=None, K=None):
self.agent = agent
self.strategy = strategy.Strategy(self.agent.numactions, policy)
if K is not None:
self.K = np.array(K)
else:
self.K = np.random.rand(self.agent.opp_numactions)
def test_all():
ref = ai.Strategy()
for i in cases:
board, player, moves = i
#assert(ref.get_valid_moves(board,player) == i)
my_moves = ref.get_valid_moves(board, player)
print(sorted(my_moves), sorted(moves))
assert(set(my_moves) == set(moves))
def test_bollinger():
myst = st.Strategy()
mySQL = mysql.MySql()
# tickers = mySQL.get_tickers_id()
tickers = ['WPRT', 'WPRTT', 'WELL']
# exclude = tickers
# tickers = mySQL.get_tickers_id()
# tickers = [ticker for ticker in tickers if ticker not in exclude]
# tickers = [ticker for ticker in tickers if ticker > 'TCS']
myst.bollinger_short_trend_back(
tickers, dt.datetime.strptime("2019-01-01", "%Y-%m-%d"))
def from_genes(genes):
num_genes = len(genes)
assert num_genes % 3 == 0
# H
h = int(num_genes / 3)
# P
p = np.array(genes[:h]).reshape(h)
# A
a = np.array(genes[h:2 * h])
# B
b = np.array(genes[2 * h:3 * h])
return Individual(strategy.Strategy((h, p, a, b)))
def reset_level(self):
'''
Сбрасываем бота в начальне состояние.
'''
self.current_day_step = 0
self.current_day = 0
self.current_global_step = 0
self.current_day_candles = self.Data[self.current_day][2]
self.strategy = strat.Strategy(self.current_day_candles)
self.score = 0.0
self.score_by_curr_strat = 0.0
self.score_without_curr_strat = 0.0
self.level_finished = False
return
def _random_strategy(h):
# Create random p vector
p = np.random.uniform(size=h)
logging.debug('P:\n%s\n', p)
# Create random A transition matrix where rows sum to 1.0
a = np.random.dirichlet(np.ones(h), size=h)
logging.debug('A (sum=%s):\n%s\n', a.sum(axis=1), a)
assert np.allclose(a.sum(axis=1), np.ones(h))
# Create random B transition matrix where rows sum to 1.0
b = np.random.dirichlet(np.ones(h), size=h)
logging.debug('B (sum=%s):\n%s\n', b.sum(axis=1), b)
assert np.allclose(b.sum(axis=1), np.ones(h))
return strategy.Strategy((h, p, a, b))
def semi_mock(curr_date, user_cfg, insts=[['IF1412', 'IF1503']]):
''' 半模拟
实际行情，mock交易
'''
logging.basicConfig(
filename="ctp_semi_mock.log",
level=logging.INFO,
format=
'%(name)s:%(funcName)s:%(lineno)d:%(asctime)s %(levelname)s %(message)s'
)
instruments = list(set(itertools.chain(*insts)))
data_func = [
('d', BaseObject(name = 'ATR_20', sfunc=fcustom(data_handler.ATR, n=20), rfunc=fcustom(data_handler.atr, n=20))), \
('d', BaseObject(name = 'DONCH_L10', sfunc=fcustom(data_handler.DONCH_L, n=10), rfunc=fcustom(data_handler.donch_l, n=10))),\
('d', BaseObject(name = 'DONCH_H10', sfunc=fcustom(data_handler.DONCH_H, n=10), rfunc=fcustom(data_handler.donch_h, n=10))),\
('d', BaseObject(name = 'DONCH_L20', sfunc=fcustom(data_handler.DONCH_L, n=20), rfunc=fcustom(data_handler.donch_l, n=20))),\
('d', BaseObject(name = 'DONCH_H20', sfunc=fcustom(data_handler.DONCH_H, n=20), rfunc=fcustom(data_handler.donch_h, n=20))),\
('1m',BaseObject(name = 'EMA_3', sfunc=fcustom(data_handler.EMA, n=3), rfunc=fcustom(data_handler.ema, n=3))), \
('1m',BaseObject(name = 'EMA_30', sfunc=fcustom(data_handler.EMA, n=30), rfunc=fcustom(data_handler.ema, n=30))) \
]
test_strat = strat.Strategy('TestStrat', [insts], None, data_func,
[[1, -1]])
strat_cfg = {'strategies': [test_strat], \
'folder': 'C:\\dev\\src\\ktlib\\pythonctp\\pyctp\\', \
'daily_data_days':25, \
'min_data_days':2 }
agent_name = "Test"
tday = curr_date
my_agent, my_trader = create_agent_with_mocktrader(agent_name, instruments,
strat_cfg, tday)
ctp_api.make_user(my_agent, user_cfg)
req = BaseObject(InstrumentID='cu1502')
my_trader.ReqQryInstrumentMarginRate(req)
my_trader.ReqQryInstrument(req)
my_trader.ReqQryTradingAccount(req)
my_agent.resume()
try:
while 1:
time.sleep(1)
except KeyboardInterrupt:
my_agent.mdapis = []
my_agent.trader = None
pass
def __init__(self, ahk, c_model):
self.controller = controls.Control(ahk)
self.gold = 1
self.round = 1
self.char_model = c_model
self.exp = 0
self.level = 1
self.check_levelup()
self.bag_items = 0
self.deployed_chars = 0
self.chars_on_bench = 0
self.bench_full = False
self.board_list = []
self.bench_list = []
self.store = Store(c_model)
self.init_lists()
self.strategy = strategy.Strategy()
self.strategy.set_strategy(strategy.WARRIORS)
def set_sample_days(self, days_to_sample=1):
self.Data = random.sample(self.Arch_Data, days_to_sample)
self.DaysCount = len(self.Data)
self.days_steps = [len(day[1]) for day in self.Data]
self.total_steps = sum(self.days_steps)
self.current_day_vectors = self.Data[self.current_day]
self.current_day_candles = self.Data[self.current_day][2]
self.strategy = strat.Strategy(self.current_day_candles)
self.check_point_ind = -1
self.check_points = {}
self.level_finished = False
self.global_index = []
for i in range(len(self.Data)):
for j in range(len(self.Data[i][1])):
self.global_index.append((i, j))
self.level_loaded = True
return
def getPathToFollow(problem, initPoint, finalPoint):
startT = time.time()
prob = strategy.Problem(problem, problem[initPoint], problem[finalPoint])
srh = strategy.Search()
final = srh.ngraphSearch(prob, strategy.Strategy(strategy.Strategy.STRATEGY['A*']))
endT = time.time()
pathFollowed = []
if final is False:
print("Position unreachable")
return
while final is not None:
pathFollowed.append(final.getTail().name)
final = final.getParentPath()
pathFollowed.reverse()
print(pathFollowed)
print("Search time", endT - startT)
return pathFollowed
import strategy as ai
ref = ai.Strategy()
next_board = ref.get_starting_board()
infile = open("moves.txt", "r")
counter = 0
for line in infile.readlines():
counter += 1
board, player, move = line.strip().split(" ")
print("testing line %i" % counter)
assert(board == next_board)
next_board = ref.make_move(board, player, int(move))
if counter == 60: print("All Tests Pass!")
infile.close()
def main():
'''main method that prompts the user for input'''
global ai
global gameBoard
global playerColor
# print("\nWelcome to Kyle's Gomoku AI!")
os.system("") # allows colored terminal to work on Windows OS
printAsciiTitleArt()
boardDimension = input(
"What is the dimension of the board? (Default is 13x13)\nEnter a single odd number:\t"
).strip()
if boardDimension.isdigit(
) and int(boardDimension) % 2 == 1 and 6 < int(boardDimension) < 100:
print("The board will be %sx%s!" % (boardDimension, boardDimension))
else:
boardDimension = 13
print("Invalid input. The board will be 13x13!")
createGameBoard(int(boardDimension))
playerColorInput = input(
"Would you like to be BLACK ('b') or WHITE ('w')? (black goes first!):\t"
).strip().lower()
if playerColorInput == 'b':
playerColor = BLACK
print("You will be black!")
else:
playerColor = WHITE
if playerColorInput == 'w':
print("You will be white!")
else:
print("Invalid input. You'll be white!")
ai = strategy.Strategy(int(boardDimension), playerColor)
print(f"\nYou: {MY_COLOR}%s{NO_COLOR}\tAI: {ENEMY_COLOR}%s{NO_COLOR}" %
(playerColor, ai.opponentOf(playerColor)))
print(
"Press 'q' at any prompt to quit.\nOr, press 'p' to end the game and receive Python code for recreating the gameBoard."
)
turn = BLACK
columnLabels = list(map(chr, range(65, 65 + len(gameBoard))))
mostRecentMove = None
while not ai.GAME_OVER:
printGameBoard(mostRecentMove)
if turn == playerColor:
mostRecentMove = getPlayerMove()
else:
userInput = input(
"It's the AI's turn, press enter for it to play.\t").strip(
).lower()
while userInput == 'q' or userInput == 'p':
if userInput == 'q':
print("\nThanks for playing!\n")
exit(0)
else:
givePythonCodeForBoardInput()
userInput = input(
"Press enter for the AI to play, or press 'q' to quit:\t"
).strip().lower()
startTime = time.time()
ai_move_row, ai_move_col = ai.playBestMove(gameBoard)
endTime = time.time()
minutesTaken, secondsTaken = int(endTime - startTime) // 60, (
endTime - startTime) % 60
print("Time taken: %s %.2fs" %
('' if minutesTaken == 0 else '%dm' % minutesTaken,
secondsTaken))
ai_move_formatted = columnLabels[ai_move_col] + str(ai_move_row +
1)
print("AI played in spot %s\n" % ai_move_formatted)
mostRecentMove = [ai_move_row, ai_move_col]
turn = ai.opponentOf(turn) # switch the turn
printGameBoard(mostRecentMove)
boardCompletelyFilled = True
for row in gameBoard:
for spot in row:
if spot == EMPTY:
boardCompletelyFilled = False
break
if boardCompletelyFilled:
print("Nobody wins, it's a tie!")
else:
winner = "BLACK" if ai.opponentOf(turn) == BLACK else "WHITE"
print("%s wins!\n" % winner)
def __init__(self, ident, loSpeciesBoard, bag):
self.species_boards = loSpeciesBoard
self.food_bag = bag
self.hand = []
self.player_id = ident
self.strat = strategy.Strategy()
def start(self):
while True:
task = strategy.Strategy(self.queue, self.batch_size)
task.start()
time.sleep(5)
for x in range(1, idDiff):
intList.addInterval(Interval(intList.intList[-1],
True))
intList.printIntervalAt(-1)
intList.addInterval(curInterval)
else:
curInterval.addTrade(curTrade)
print "Complete!"
mtgox = GoxAPI()
mtgox.connect()
mtgoxThread = GoxAPI()
mtgoxThread.connect()
tradeStrategy = strategy.Strategy(intList)
thread.start_new_thread(tradeStrategy.run, (mtgoxThread, ))
while True:
"""Main program loop
Will keep recieving trade data until process dies
"""
if (args.testMode):
time.sleep(5)
mtTrade = {
'date': time.time(),
'price': random.uniform(88, 98),
'amount': random.uniform(0.01, 3.0)
}
if restart == True:
spot = pickle.load(open("spot.p", "rb"))
elif restart == False:
spot = {'block': 0, 'val': 0}
else:
restart = True
spot = {'block': 0, 'val': 0}
pickle.dump(spot, open("spot.py", "wb"))
HardLogic = lg.HardLogic(restart)
SoftLogic = lg.SoftLogic(restart)
SplittingLogic = lg.SplittingLogic(restart)
FirstCardLogic = lg.FirstCardLogic(restart)
RandomGen = rg.RandomGenerator(randomNumberSeed)
Strategy = st.Strategy(SplittingLogic.splittingTest, SoftLogic.softTest,
HardLogic.hardTest, FirstCardLogic.firstTest)
starttime = time.time()
payOff = []
for q in range(1, games):
payOff.append(g.game(hands, decks, Strategy, RandomGen))
incumbent = sum(payOff) / len(payOff)
print(
"intial incumbent established " + str(time.time() - starttime) + " value=",
str(incumbent))
if spot['block'] < 1:
if spot['val'] == 0:
i = 6
else:
# TJHSST
#
# change the following one line to your strategy file name
import strategy as ai
import Othello_human as human
import Othello_Core as core ## to access constants directly
## in my client, I will import MY core file to run the game, but for testing you can just
## use your own
import time
from multiprocessing import Process, Value
import os, signal
ai1 = ai.Strategy() ### your strategy object
ai2 = human.Strategy(
) ## make this different to play 2 different strategy files
def tournament_player(black_choice,
white_choice,
black_name="Black",
white_name="White",
time_limit=5):
""" runs a tournament of an even number of games, alternating black/white with each strategy
and returns the results """
ai1_wins = 0
rounds = 1
for i in range(2 * rounds):
try:
def create_primary_strategy(self):
# primary strategy
s3 = strategy.Strategy(self.db,
self.tele,
name='primary',
color='teal',
order=1)
# BUY
c1 = condition.Condition(function='percentage_to_last',
operator='>',
value=0.01)
c2 = condition.Condition(function='trend_of_last_seconds',
param=70,
operator='<',
value=-0.24)
s3.add_should_buy([c1, c2], text='percentage to last is positive')
c1 = condition.Condition(function='percentage_to_last',
operator='>',
value=0)
c2 = condition.Condition(function='trend_of_last_seconds',
param=70,
operator='<',
value=0.4)
s3.add_should_buy([c1, c2], text='percentage to last is positive')
# c = condition.Condition(function='percentage_to_last', operator='<', value=-0.03)
# s3.add_should_buy([c], text='high loss in cur tick')
# SELL
c1 = condition.Condition(function='percentage_to_last',
operator='<',
value=-0.01)
c2 = condition.Condition(function='trade.percentage',
operator='>=',
value=0)
s3.add_should_sell([c1, c2],
text='high loss in cur tick and has profit')
c1 = condition.Condition(function='percentage_to_last',
operator='<',
value=0)
c2 = condition.Condition(function='trade.percentage',
operator='<',
value=-0.4)
s3.add_should_sell(
[c1, c2],
text='percentage to last is negative and profit is lower than -0.4%'
)
# c = condition.Condition(function='trend_of_last_seconds', param=30, operator='<', value=0.005)
# s3.add_should_sell([c], text='no significant change in last 30 seconds')
c = condition.Condition(function='trade.percentage',
operator='>=',
value=1)
s3.add_should_sell([c], text='enough profit (>0.1%)')
# c = condition.Condition(function='trend_of_last_seconds', param=10, operator='<', value=0)
# s3.add_should_sell([c], text='no positive trend in last 10 seconds')
c1 = condition.Condition(function='trade.percentage',
operator='>=',
value=0)
c2 = condition.Condition(function='trade.last_percentage',
operator='<',
value=0)
s3.add_should_sell([c1, c2], text='has profit, after no profit')
self.strategies.append(s3)
YELLOW_COLOR = "\u001b[38;5;226m" # yellow
RED_COLOR = '\033[91m' # red
BLUE_COLOR = "\u001b[38;5;39m" # blue
NO_COLOR = '\033[0m' # white
EMPTY, RED, YELLOW = '.', 'o', '@'
gameBoard = [
[EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY], # bottom row
[EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY]
] # top row
playerColor = YELLOW
ai = strategy.Strategy()
def printBoard(board):
'''Prints the given game board'''
print("\n 1 2 3 4 5 6 7")
for rowNum in range(len(board) - 1, -1, -1):
print(f"{BLUE_COLOR}|{NO_COLOR} ", end='')
for spot in board[rowNum]:
if spot == RED:
pieceColor = RED_COLOR
elif spot == YELLOW:
pieceColor = YELLOW_COLOR
else:
pieceColor = NO_COLOR
print(f"{pieceColor}%s{NO_COLOR} " % spot, end='')
