def append(self, token):
# before appending the item, we complete it
completed_value = self.complete(token)
logger.info(f"Append triple item value: {completed_value}")
if self.value != "":
self.value = self.value + " "
self.value = f"{self.value}{completed_value}"
async def fast_change_detect(self):
if not self.instruments:
return False
lists = etoro.helpers.get_cache('watch_list', 10)
if not lists:
lists = await etoro.watch_list(self.session)
if 'Watchlists' in lists:
etoro.helpers.set_cache('watch_list', lists)
else:
return False
for watch_list in lists['Watchlists']:
for item_list in watch_list['Items']:
if item_list['ItemType'] == 'Instrument' and item_list['ItemId'] not in self.watch_instuments_id:
self.watch_instuments_id[item_list['ItemId']] = deque([])
if not self.instruments_rate:
self.instruments_rate = await etoro.instruments_rate(self.session)
if not self.instruments_rate:
return False
self.instruments_rate = {instrument['InstrumentID']: instrument for instrument in
self.instruments_rate['Rates']}
for key in self.instruments_rate:
if key in self.watch_instuments_id:
self.watch_instuments_id[key].append(self.instruments_rate[key]['LastExecution'])
if len(self.watch_instuments_id[key]) > 10:
changing = self.watch_instuments_id[key][0]/self.watch_instuments_id[key][-1]
if changing > 1:
changing = (1.0 - 1/changing)*-1
else:
changing = 1.0 - changing
if changing > settings.fast_grow_points or changing < (-1*settings.fast_grow_points):
logging.info('Changing for {} is {}'.format(self.instruments[key]['SymbolFull'], str(changing)))
await self.fast_deal(changing, key)
# self.message = 'Changing {} is {}'.format(self.instruments[key]['SymbolFull'],
# str(changing))
self.watch_instuments_id[key].popleft()
def prepend(self, token):
# before prepending the item, we complete it
completed_value = self.complete(token)
logger.info(f"Prepend triple item value: {completed_value}")
if self.value != "":
self.value = " " + self.value
self.value = f"{completed_value}{self.value}"
def __init__(self, loop):
ABCMessenger.__init__(self, loop)
logger.info('Connect with {}:{}'.format(settings.smtp_host,
settings.smtp_port))
self.smtp = smtplib.SMTP(host=settings.smtp_host,
port=settings.smtp_port,
timeout=5)
self.smtp.starttls()
self.smtp.login(settings.smtp_login, settings.smtp_password)
self.smtp.debuglevel = 0
def pars_img() -> None:
"""Скачивает картинку с сайта"""
try:
image = soup.find(
class_="page_raspis_block_img").find("img").get("src")
urlretrieve(image, filename="schedule/schedule.png")
logger.info("Скачивание успешно завершено!")
except NotSchedule:
logger.warning("NOT schedule")
raise NotSchedule
def cropped_img():
"""Обрезает изображение"""
try:
image = Image.open('schedule/schedule.png')
if not os.path.exists('schedule/schedule.png'):
logger.error('NO img schedule')
cropped = image.crop((568, 543, 681, 711))
cropped.save('schedule/schedule2.png')
logger.info("Изображение успешно обрезано")
except NotCroppedImg:
raise NotCroppedImg("not cropped image")
def finish(self, finish_asc, finish_bid, finish_date):
self.class_strategy.finish(self, finish_date)
logger.info(
'Finish Date: {} Balance: {}. Total: {} Buy: {} Sell: {} Orders: {} Marg: {}'
.format(finish_date, self._balance, self._counter['total'],
self._counter['buy'], self._counter['sell'],
self._count_item, self._balance - self._start_balance))
if self.parent is not None:
self.parent.total_marg += self._balance - self._start_balance
self.balance_change.append(self._balance)
plt.plot(self.balance_change, color='red')
plt.savefig("temp/mybalance/my_balance{}.png".format(uuid.uuid4()),
dpi=200)
plt.close()
def wrapper_f(*args, **kwargs):
logger.info(f"Execute: {f.__name__}")
# class that is requesting
cls = args[0]
dependency_trace = ()
if "dependency_trace" in kwargs:
dependency_trace = kwargs['dependency_trace']
if "token_head" in kwargs:
logger.info(f"> token_head: {kwargs['token_head']}")
kwargs['dependency_trace'] = dependency_trace + (kwargs['token_head'].dep_,)
logger.info(f"> token: {kwargs['token']}")
proceed_requested = f(*args, **kwargs)
if proceed_requested:
# proceed to call dependency functions on next children
kwargs["token_head"] = kwargs["token"]
for next_child in kwargs["token"].children:
next_dependency = next_child.dep_.split(":")[0]
proceed_method = getattr(cls, next_dependency, None)
if proceed_method is not None:
logger.info(f"> Next method: {next_dependency}")
kwargs["token"] = next_child
proceed_method(**kwargs)
def buy(self, count):
if self.buy_method is None:
if count * self.asc > self._balance and self._count_item >= 0:
logger.info(
'Buy. Not enough money! Need: {}. Balance: {}'.format(
count * self.asc, self._balance))
self._counter['total'] += 1
self._counter['buy'] += 1
if self.asc > 0:
tmp_count = self._count_item + count
self._balance -= count * self.asc
self._count_item = tmp_count
logger.debug('Buy asc: {}'.format(self.asc))
else:
self.buy_method(count)
def sell(self, count):
if self.sell_method is None:
if count * self.asc > self._balance and self._count_item <= 0:
logger.info(
'Sell. Not enough money! Need: {}. Balance: {}'.format(
count * self.asc, self._balance))
return False
self._counter['total'] += 1
self._counter['sell'] += 1
if self.asc > 0:
tmp_count = self._count_item - count
self._balance += count * self.asc
self._count_item = tmp_count
logger.debug('Sell asc: {}'.format(self.asc))
else:
self.sell_method(count)
async def schedule_buying(call: CallbackQuery):
try:
time.sleep(2)
pars_img()
cropped_img()
with open('schedule/schedule2.png', 'rb') as f:
if not os.path.isdir('schedule'):
os.mkdir('schedule')
if os.path.isfile('schedule/schedule2.png'):
os.remove('schedule/schedule2.png')
os.remove('schedule/schedule.png')
logger.info("Удалил расписание")
contents = f.read()
await bot.send_photo(call.from_user.id, photo=contents)
logger.info("Расписание успешно отправлено")
except Exception:
logger.error("no png file")
msg_error = "Упс.. У меня нет расписания 😱"
await call.answer(msg_error, show_alert=True)
async def photo_command(message: types.Message):
"""Отсылает фото расписания"""
try:
time.sleep(1)
pars_img()
cropped_img()
with open('schedule/schedule2.png', 'rb') as f:
if not os.path.isdir('schedule'):
os.mkdir('schedule')
if os.path.isfile('schedule/schedule2.png'):
os.remove('schedule/schedule2.png')
os.remove('schedule/schedule.png')
logger.info("Удалил расписание")
contents = f.read()
await bot.send_photo(message.from_user.id, photo=contents)
logger.info("Расписание успешно отправлено")
except Exception:
logger.error("no png file")
msg_error = "Упс.. У меня нет расписания 😱 \n" \
"Напиши: /download и я скачаю его 💾\n" \
"Или нажми на кнопку - Скачать расписание 🕹"
await message.answer(msg_error, parse_mode=ParseMode.MARKDOWN)
def __init__(self, noun1=None, verb=None, noun2=None):
logger.info(f"Initiate new triple")
assert(type(noun1).__name__ == "TripleItem" or noun1 is None)
assert(type(verb).__name__ == "TripleItem" or verb is None)
assert(type(noun2).__name__ == "TripleItem" or noun2 is None)
self.noun1 = TripleItem()
self.verb = TripleItem()
self.noun2 = TripleItem()
if noun1 is not None:
logger.info(f"> init with noun1: {noun1.value}")
self.noun1 = copy(noun1)
if verb is not None:
logger.info(f"> init with verb (case): {verb.value} ({verb.case})")
self.verb = copy(verb)
if noun2 is not None:
logger.info(f"> init with noun2: {noun2.value}")
self.noun2 = copy(noun2)
def run(self):
"""Стартует"""
text = self.load_page()
self.parse_page(text=text)
logger.info(f'Получили {len(self.result)} элементов')
self.save_result()
def set(self, token):
# before adding the item, we complete it
completed_value = self.complete(token)
logger.info(f"Set triple item value: {completed_value}")
self.value = completed_value
def start(self, start_asc=None, start_bid=None, start_date=None):
logger.info('Start Date: {} Start balance: {}!'.format(
start_date, self._balance))
self.class_strategy.start(self, start_date)
def set_cop(self, token):
completed_value = self.complete(token)
logger.info(f"Set triple item cop: {completed_value}")
self.cop = completed_value
def set_obj(self, token):
completed_value = self.complete(token)
logger.info(f"Set triple item obj: {completed_value}")
self.obj = completed_value
def set_case(self, token):
completed_value = self.complete(token)
logger.info(f"Set triple item case: {completed_value}")
self.case = completed_value
executor = ThreadPoolExecutor(2)
loop = asyncio.get_event_loop()
# loop.set_default_executor(executor)
messenger = MessageManager(loop)
messenger.clients = []
etoro = EtoroAdvisor(loop, messenger=messenger)
yahoo = YahooAdvisor(loop, messenger=messenger)
strategy = StrategyAdvisor(loop, messenger=messenger)
while is_running:
tasks = [
loop.create_task(etoro.loop()),
loop.create_task(yahoo.loop()),
loop.create_task(strategy.loop()),
loop.create_task(strategy.fast_change_detect()),
# loop.create_task(strategy.check_fast_orders()),
]
asyncio.ensure_future(
loop.run_in_executor(executor, messages_listen))
loop.run_until_complete(asyncio.wait(tasks))
except KeyboardInterrupt:
logging.info('Exit')
is_running = False
try:
# loop._default_executor.shutdown(wait=True)
loop.close()
except:
pass
def complete(self, token):
value = token.text
logger.info(f"Start completion for token: {value}")
for token_child in token.children:
dependency = token_child.dep_.split(":")[0]
if dependency == "compound":
logger.info(f"> Compound completion: {value}")
# "Zij lopen en rennen precies in de maat"
# compound(in, de), compound(in, maat) -> in de maat
value = f"{value} {self.complete(token_child)}"
if dependency == "flat":
logger.info(f"> Flat completion: {value}")
# "webkit is ontwikkeld door Intel, aan de Intel Open Source Technology Center."
# flat(Intel, Open), flat(Intel, Source), etc.
value = f"{value} {self.complete(token_child)}"
if dependency == "amod":
logger.info(f"> Amod completion: {value}")
# adjective modifier = toevoeging van bijvoeglijk naamwoord
# "De langdurige zorg blijkt zeer goed te werken"
# amod(zorg, langdurige)
value = f"{self.complete(token_child)} {value}"
if dependency == "advmod":
# adverb = bijwoord, this relation may not be highly important to include
# however, in some cases it is very important, e.g. Dementie is echter nog niet verholpen, now:
# advmod(verholpen, niet), advmod(verholpen, echter), advmod(niet, nog)
# in this case, "niet verholpen" is very important to retrieve! However, echter and nog, seem redudant
# Todo:
# We thus may need a removal of stopwords!
# "De langdurige zorg blijkt zeer goed te werken"
# advmod(zeer, goed)
if token_child.pos_ == "ADV":
logger.info(f"> Advmod completion: {value}")
# We only include the adverb if it contains an important value, such as denials
adv_value = self.complete(token_child)
has_important_adv = adv_value in ["niet", "geen"]
if has_important_adv:
value = f"{adv_value} {value}"
if dependency == "aux":
if token.pos_ == "VERB":
logger.info(f"> Aux completion: {value}")
# "webkit is ontwikkeld door Intel, aan de Intel Open Source Technology Center."
# aux(ontwikkeld, is)
value = f"{self.complete(token_child)} {value}"
if dependency == "mark":
# "De langdurige zorg blijkt zeer goed te werken"
# mark(werken, te)
logger.info(f"> Mark completion: {value}")
value = f"{self.complete(token_child)} {value}"
if dependency == "appos":
if token_child.pos_ == "NUM":
# text = "Afwisselende democratische en autocratische regeringen volgden elkaar op tot in de jaren
# 80 van de twintigste eeuw"
# appos(jaren, 80)
value = f"{value} {self.complete(token_child)}"
if dependency == "case":
# We need to handle a special case here:
# 1. text = "Brazilië is met zijn 8,5 miljoen vierkante kilometer het grootste land van Zuid-Amerika,
# het beslaat bijna de helft van dit continent."
# > Here a triple is (brazilie, grootste land van, zuid-amerika)
# 2. text = "De oorspronkelijke bevolking van Brazilië bestond uit indianen die de tropische kuststrook,
# het Paraná- en het Amazonebekken bewoonden."
# > Here a triple is (oorspronkelijke bevolking van Brazilië, bestond uit, indianen)
# In 1) we have nmod(land, zuid-amerika) and case(zuid-amerika, van)
# In 2) we have nmod(bevolking, brazilie) and case(brazilie, van)
# In the first we add the van to the 'verb' land (it is identified as verb) and in the second case we
# need to complete bevlking van Brazilie, so 'van' should not be added to the verb, instead, here it is
# a completion. We thus note that completion should be done if the head of the token we are looking at
# is not a verb, for if it is, then case should be appending the verb
if token.head.pos_ != "VERB":
value = f"{self.complete(token_child)} {value}"
return value
self.balance = 5000
self.shoulder = 100
self.total_marg = 0
def back_testing(self, dataframe, strategy, trade_obj):
BackTesting(dataframe, strategy, self.balance, self.instrument,
trade_obj)
if __name__ == "__main__":
filelist = [f for f in os.listdir("temp/mybalance/") if f.endswith(".png")]
for f in filelist:
os.remove("temp/mybalance/" + f)
trade_obj = BaseTrade()
loop = asyncio.get_event_loop()
for i in range(1, 8):
dataframe = []
history_items = loop.run_until_complete(etoro.get_history(i))
if 'Candles' in history_items and history_items['Candles'] is not None:
if history_items['Candles'][0]['Candles']:
for item in reversed(history_items['Candles'][0]['Candles']):
dataframe.append({
'asc': item['Close'],
'bid': item['Open'],
'date': item['FromDate']
})
trade_obj.back_testing(dataframe, strategy.StrategyManager,
trade_obj)
time.sleep(1)
logger.info('Total marg: {}'.format(trade_obj.total_marg))
