def change_timezones(time_entries, tz):
for t in time_entries:
start_date = str_to_datetime(t.start_date)
end_date = str_to_datetime(t.end_date)
t.start_date = datetime_str(start_date.astimezone(tz))
t.end_date = datetime_str(end_date.astimezone(tz))
def cut_time_entries_out_of_range(time_entries, dr):
start, end = dr.start(), dr.end()
for t in time_entries:
te_start, te_end = (
str_to_datetime(t.start_date),
str_to_datetime(t.end_date),
)
if te_start < start:
t.start_date = datetime_str(start)
if end < te_end:
t.end_date = datetime_str(end)
def filter_time_entries(time_entries, dr: DateRange):
start, end = dr.start(), dr.end()
result = []
for t in time_entries:
te_start, te_end = (
str_to_datetime(t.start_date),
str_to_datetime(t.end_date),
)
in_range = start <= te_start <= end or start <= te_end <= end
if in_range:
result.append(deepcopy(t))
return result
def update_last_entry(
self,
owner_id: str,
start_date: str,
id_running_entry: str,
event_context: EventContext,
):
last_entry = self.get_last_entry(owner_id, id_running_entry,
event_context)
end_date = str_to_datetime(last_entry.end_date)
_start_date = str_to_datetime(start_date)
if _start_date < end_date:
update_data = {'end_date': start_date}
self.partial_update(last_entry.id, update_data, event_context)
def load_trades(self):
logger.info('[TRADE_MANAGER] loading %s trades.' % len(self.account.get_trades()))
if self.account and self.account.broker == 'FXCM':
for trade_id, trade in self.account.get_trades().items():
if str(trade_id) in self.trades:
continue
self._load_trade(trade_id, trade)
key_list = list(self.trades.keys())
for key in key_list:
if int(key) not in self.account.get_trades():
self.pop_trade(key)
else:
raise NotImplementedError
# restore old data from redis
redis_data = system_redis.get(TRADES_KEY)
if redis_data:
redis_data = json.loads(redis_data)
for k, v in redis_data.items():
if k in self.trades:
self.trades[k]['max'] = Decimal(str(redis_data[k]['max']))
self.trades[k]['min'] = Decimal(str(redis_data[k]['min']))
self.trades[k]['profitable_seconds'] = redis_data[k]['profitable_seconds']
self.trades[k]['last_profitable_start'] = str_to_datetime(redis_data[k]['last_profitable_start'])
total_time = datetime.utcnow() - self.trades[k]['open_time']
last_profit_period = 0
if self.trades[k]['last_profitable_start']:
last_profit_period = (datetime.utcnow() - self.trades[k]['last_profitable_start']).seconds
total_profit_seconds = self.trades[k]['profitable_seconds'] + last_profit_period
self.trades[k]['profitable_time'] = round(total_profit_seconds / float(total_time.seconds), 3)
self.saved_to_redis()
def handle_date_filter_args(args: dict) -> dict:
if "start_date" and "end_date" in args:
start_date = str_to_datetime(args.pop('start_date'))
end_date = str_to_datetime(args.pop('end_date'))
else:
month = int(args.pop("month", get_current_month()))
year = int(args.pop("year", get_current_year()))
start_date, end_date = get_date_range_of_month(year, month)
offset_in_minutes = int(args.pop('timezone_offset', 300))
start_date = start_date + timedelta(minutes=offset_in_minutes)
end_date = end_date + timedelta(minutes=offset_in_minutes)
return {
'start_date': datetime_str(start_date),
'end_date': datetime_str(end_date),
}
def get_tick_price(instrument):
key = instrument.upper() + TICK_PRICE_SUFFIX
data = price_redis.get(key)
if data:
price = json.loads(data)
if 'ask' in price:
price['ask'] = Decimal(str(price['ask']))
if 'bid' in price:
price['bid'] = Decimal(str(price['bid']))
if 'time' in price:
price['time'] = str_to_datetime(price['time'],
format='%Y-%m-%d %H:%M:%S:%f')
return price
return None
def elapsed_time(self) -> timedelta:
start_datetime = str_to_datetime(self.start_date)
end_datetime = str_to_datetime(self.end_date)
return end_datetime - start_datetime
