def scan_(self, _longer_list):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
positive_instr = OrderedDict()
negative_instr = OrderedDict()
_scan_param_ix = 0
for factor_ix in range(_longer_list):
try:
_key_ = list(self.positive_factors.keys())[factor_ix]
positive_instr[_key_] = self.receive_(
self.positive_factors[_key_][_scan_param_ix])
except IndexError:
pass
except exceptions_.ScannerReturnsNothingError:
negative_instr[_key_] = []
try:
_key_ = list(self.negative_factors.keys())[factor_ix]
negative_instr[_key_] = self.receive_(
self.negative_factors[_key_][_scan_param_ix])
except IndexError:
pass
except exceptions_.ScannerReturnsNothingError:
negative_instr[_key_] = []
log.log(_longer_list)
return positive_instr, negative_instr
def _time_gates_f(self, _time_gates, ix):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.strat.add_to_manager(self.strat.strat_name, *log.monitor())
gate = _time_gates[ix].time()
if self.strat.debugging.dummy_time:
_now = self.strat.lt._manipulated_time(datetime.datetime.now())
else:
_now = datetime.datetime.now()
_now = self.strat.lt.us_tz_op(_now).time()
while _now < gate: # _time_gates
if self.strat.debugging.dummy_time:
_now = self.strat.lt._manipulated_time(datetime.datetime.now())
else:
_now = datetime.datetime.now()
_now = self.strat.lt.us_tz_op(_now).time()
self.strat.lt.ib.sleep(1)
# _visible_counter += 1
# if _visible_counter % 5 == 0:
# print('_visible_counter seconds {} ({} - {})'.format(str(_visible_counter),_now.strftime('%H:%M:%S'),gate.strftime('%H:%M:%S')))
continue
log.log()
def match_f(self,
positive_instr,
negative_instr,
_n_iters,
_first_iter=False):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.strat.add_to_manager(self.strat.strat_name, *log.monitor())
positive_list = self._relevance_discarding(positive_instr, _n_iters,
self.strat.runtime_tm,
_first_iter)
# must_appear_at_least = len2 if _first_iter else 2 * _n_iters
must_appear_at_least = len(
self.positive_factors) if _first_iter else len(
self.positive_factors) * _n_iters
self.cons_disp.print_warning(
'not sure if must_appear_at_least is correct')
concat_ = []
for i_ix, i in enumerate(positive_instr.keys()):
concat_.append(positive_list[i_ix])
counts_ = []
flat = [j for k in concat_ for j in k]
for f in flat:
counts_.append([f, flat.count(f)])
positive_matches = []
for c_ix, c in enumerate(list(counts_)):
if c[1] >= must_appear_at_least:
positive_matches.append(c[0])
positive_matches = list(set(positive_matches))
if len(negative_instr) > 0:
negative_list = self._relevance_discarding(negative_instr,
_n_iters,
self.strat.runtime_tm,
_first_iter)
# sort out a certain number of overnight stars
matches = []
negative_list_flat = [j for i in negative_list.values() for j in i]
_cnt_remove = 0
_step_through = int(
1 / (1 - self.strat.rm.fraction_sorting_out_negative_list))
for j, i in enumerate(list(positive_matches)):
if i in negative_list_flat:
if _cnt_remove < _step_through:
_cnt_remove += 1
else:
_cnt_remove = 0
continue
matches.append(i)
else:
matches = positive_matches
log.log(matches)
return matches
def _reduce_fraction_sorting_out_negative_list(self):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.strat.add_to_manager(self.strat.strat_name, *log.monitor())
self.strat.rm.fraction_sorting_out_negative_list -= .1
if self.strat.rm.fraction_sorting_out_negative_list < .0:
self.strat.rm.fraction_sorting_out_negative_list = .0
log.log(self.strat.rm.fraction_sorting_out_negative_list)
def reshuffle_winners(self,
parallel_traded_instr_per_strat,
next_in_line,
remove=None):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.strat.add_to_manager(self.strat.strat_name, *log.monitor())
if remove is None:
# self.__traded_instr = []
for i in range(parallel_traded_instr_per_strat):
# if len(self.__winners) == 0 and len(self.__traded_instr) > 0:
if len(self.__winners) == 0 and len(
self.strat.lt.traded_instr) > 0:
return
# elif len(self.__winners) == 0 and len(self.__traded_instr) == 0:
elif len(self.__winners) == 0 and len(
self.strat.lt.traded_instr) == 0:
raise exceptions_.NoMoreWinnersInLineError
# self.__traded_instr.append(next_in_line)
self.strat.lt.traded_instr.append(next_in_line)
self.strat.add_to_manager(self.strat.strat_name,
'traded_instr',
self.strat.lt.traded_instr)
self.strat.add_to_manager(self.strat.strat_name, '__winners',
self.__winners)
self.strat.lt.heartbeat_q.put(
[self.strat.strat_name, '__winners', self.__winners])
else:
# ix = self.__traded_instr.index(remove)
try:
ix = self.strat.lt.traded_instr.index(remove)
del self.strat.lt.traded_instr[ix]
# self.strat.add_to_manager(self.strat.strat_name, 'traded_instr', self.strat.lt.traded_instr)
except ValueError:
pass
if len(self.__winners) == 0 and len(
self.strat.lt.traded_instr) > 0:
# if len(self.__winners) == 0 and len(self.__traded_instr) > 0:
return
elif len(self.__winners) == 0 and len(
self.strat.lt.traded_instr) == 0:
# elif len(self.__winners) == 0 and len(self.__traded_instr) == 0:
raise exceptions_.NoMoreWinnersInLineError
self.strat.lt.traded_instr.append(next_in_line)
# self.__traded_instr.append(next_in_line)
# self.strat.add_to_manager(self.strat.strat_name, 'traded_instr', self.strat.lt.traded_instr)
# self.strat.add_to_manager(self.strat.strat_name, '__winners', self.__winners)
self.strat.lt.heartbeat_q.put(
[self.strat.strat_name, '__winners', self.__winners])
def _remove_misc_negative_instr(cls, black_list, matches, runtime_tm):
log_start = datetime.datetime.now()
log = logging_.Logging(
runtime_tm, log_start,
str(cls.__class__.__name__ + ',' + sys._getframe().f_code.co_name))
selected_matches = []
for i in matches:
if i in black_list:
continue
selected_matches.append(i)
log.log()
return selected_matches
def get_budget(_n_winners, cap_, runtime_tm):
log_start = datetime.datetime.now()
log = logging_.Logging(runtime_tm, log_start,
str(' ' + ',' + sys._getframe().f_code.co_name))
if _n_winners > TOO_FEW_INSTR_TRADED:
budget = cap_ / _n_winners
else:
try:
budget = (cap_ / _n_winners) * (1 -
CAP_RETENTION_IF_TOO_FEW_INSTR)
except Exception as e:
if _n_winners == 0:
raise exceptions_.WinnersZero()
else:
raise e
log.log(budget, _n_winners)
return budget
def update_trade_flow(self, ticker):
log_start = datetime.datetime.now()
log = logging_.Logging(self.runtime_tm, log_start, str(self.__class__.__name__ + ',' + sys._getframe().f_code.co_name))
# self.lt.add_to_monitor(*log.monitor())
price, offer_size, size, status = None, None, None, None
try:
curr_n_trades = self.lt.cnt_trades_per_instr_per_day[ticker.contract.symbol]
except KeyError:
curr_n_trades = 0
if ticker.contract.symbol not in self.lt.portfolio_instr and curr_n_trades < self.max_trades_per_instr_per_day:
self.__make_trade_decision(ticker, 'BUY')
elif ticker.contract.symbol in self.lt.portfolio_instr:
self.__make_trade_decision(ticker, 'SELL')
log.log(price
,offer_size
,size
,status)
self.add_to_manager(self.strat_name, 'n loops update_trade_flow', 'increment_1')
def _start_routine_check(self):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.add_to_manager(self.strat_name, *log.monitor())
if self.debugging.dummy_time:
_now = self.lt._manipulated_time(datetime.datetime.now())
else:
_now = datetime.datetime.now()
current = self.lt.us_tz_op(_now).time()
op = datetime.datetime.strptime(MARKET_OPEN, '%H:%M:%S').time()
if current < op:
status = False
else:
status = True
log.log(status)
return status
def receive_(self, _type_):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
scan_data = []
self.ss.scanCode = _type_
scan = self.strat.lt.ib.reqScannerData(self.ss)
if len(scan) == 0:
print('scanner did not return anything')
raise exceptions_.ScannerReturnsNothingError
rank = 0
while True:
try:
scan_data.append([scan[rank].contractDetails.contract.symbol])
rank += 1
except IndexError:
break
log.log(_type_)
return scan_data
def _check_if_done(self):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.add_to_manager(self.strat_name, *log.monitor())
d_is_empty = lambda x: not bool(x) #empty dict check, turn around
status = True
if d_is_empty(self.lt.cnt_trades_per_instr_per_day):
status = False
for i in self.lt.cnt_trades_per_instr_per_day.keys():
if self.lt.cnt_trades_per_instr_per_day[
i] < MAX_TRADES_PER_INSTR_PER_DAY:
status = False
if status:
raise exceptions_.MaxTradesPerDayError
if self.signals.sell_at_eob_f():
raise exceptions_.SellAtEOBWarning
log.log(status)
def _relevance_discarding(cls,
factors,
_n_iters,
runtime_tm,
_first_iter=False):
log_start = datetime.datetime.now()
log = logging_.Logging(
runtime_tm, log_start,
str(cls.__class__.__name__ + ',' + sys._getframe().f_code.co_name))
selection_dict = OrderedDict()
for ix, i in enumerate(factors.values()):
flat = [j for k in i for j in k]
n = []
for f in flat:
n.append([f, flat.count(f)])
if not _first_iter:
for cix, c in enumerate(n):
if c[1] < _n_iters:
del n[cix]
fittest = [r[0] for r in n]
selection_dict[ix] = fittest
log.log()
return selection_dict
def initial_scan_to_sort(self, _longer_list):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
positive_instr = OrderedDict()
negative_instr = OrderedDict()
_scan_param_ix = 0
for factor_ix in range(_longer_list):
try:
_key_ = list(self.positive_factors.keys())[factor_ix]
positive_instr[_key_] = self.receive_(
self.positive_factors[_key_][_scan_param_ix])
except IndexError:
pass
except exceptions_.ScannerReturnsNothingError:
del self.positive_factors[factor_ix]
try:
_factor_val_ix, _factor_type_ix = 0, 1
if isinstance(self.negative_factors, tuple):
for _nf in self.negative_factors:
if list(_nf.values())[0][_factor_type_ix] == 'scanner':
_neg_fact = _nf
break
else:
_neg_fact = self.negative_factors[0]
_key_ = list(_neg_fact.keys())[factor_ix]
negative_instr[_key_] = self.receive_(
_neg_fact[_key_][_scan_param_ix])
except IndexError:
pass
except exceptions_.ScannerReturnsNothingError:
del self.negative_factors[factor_ix]
log.log(_longer_list)
return positive_instr, negative_instr
def _check_tradeability_of_instr(self, traded_instr_this_strat):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
removables = []
# for wnr_ in self.__winners:
instrs = copy.copy(traded_instr_this_strat)
for wnr_ in traded_instr_this_strat:
if self.is_used_by_another_parallel_strat(wnr_):
removables.append(wnr_)
if len(removables) > 0:
for rem_ in removables:
next_in_line = self.__winners.pop(0)
instrs.append(next_in_line)
self.reshuffle_winners(
self.strat.parallel_traded_instr_per_strat,
next_in_line,
remove=rem_)
_ix = instrs.index(rem_)
del instrs[_ix]
log.log(removables)
return instrs
def _init_trade_cnt(self, _traded_instr):
self.cons_disp.print_warning('this might be conflicting')
# print('this might be conflicting')
log_start = datetime.datetime.now()
log = logging_.Logging(
self.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.add_to_manager(self.strat_name, *log.monitor())
if len(_traded_instr) == 0:
self.lt.cnt_trades_per_instr_per_day = {}
else:
for w_ix, wnr in enumerate(_traded_instr):
if w_ix == 0:
self.lt.cnt_trades_per_instr_per_day = {wnr: 0}
else:
self.lt.cnt_trades_per_instr_per_day[wnr] = 0
self.add_to_manager(self.strat_name, 'cnt_trades_per_instr_per_day',
self.lt.cnt_trades_per_instr_per_day)
self.lt.heartbeat_q.put([
self.strat_name, 'cnt_trades_per_instr_per_day',
self.lt.cnt_trades_per_instr_per_day
])
log.log()
def mkt_cap(self, symbol_, threshold_):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.lt.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
if isinstance(threshold_, int) or isinstance(threshold_, float):
raise Exception('invalid value, must be a letter at end')
if threshold_[-1] == 'M':
mult_ = 1000000
elif threshold_[-1] == 'B':
mult_ = 1000000000
else:
mult_ = 1
threshold_ = int(threshold_[:-1]) * mult_
self.lt.hlprs.add_to_manager(self.lt.manager_, *log.monitor())
contract_ = Stock(symbol_, 'ISLAND', 'USD')
snapshot_xml = self.lt.ib.reqFundamentalData(contract_,
'ReportSnapshot')
if len(snapshot_xml) > 0:
snapshot = xmltodict.parse(snapshot_xml)
fin_stat_xml = self.lt.ib.reqFundamentalData(
contract_, 'ReportsFinStatements')
fin_stat = xmltodict.parse(fin_stat_xml)
px_ = float(snapshot \
['ReportSnapshot']\
['Ratios']\
['Group']\
[0]\
['Ratio']\
[0]\
['#text'])
coa_ = fin_stat \
['ReportFinancialStatements']\
['FinancialStatements']\
['COAMap']\
['mapItem']
# periods = fin_stat \
# ['ReportFinancialStatements']\
# ['FinancialStatements']\
# ['AnnualPeriods']\
# ['FiscalPeriod']
line_items_ = fin_stat \
['ReportFinancialStatements']\
['FinancialStatements']\
['AnnualPeriods']\
['FiscalPeriod']\
[0]\
['Statement']\
[1]\
['lineItem']
# [len(periods)-1]\
for ix_, acc_grp in enumerate(coa_):
if acc_grp['#text'] == 'Total Common Shares Outstanding':
where = coa_[ix_]['@coaItem']
precision_ = int(acc_grp['@precision'])
if precision_ == 1:
zeros = 1000.0
elif precision_ == 2:
zeros = 1000000.0
else:
zeros = 1.0
for ix2, line_ in enumerate(line_items_):
if line_['@coaCode'] == where:
shares_outstanding_ = float(
line_items_[ix2]['#text']) * zeros
break
mkt_cap = px_ * shares_outstanding_
else:
mkt_cap = 0.0
log.log()
if mkt_cap > threshold_:
return True
else:
return False
def collect_hist_ticks(self, ticker, unix_ts):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.strat.add_to_manager(self.strat.strat_name, *log.monitor())
cnt = 0
log_msg1 = ""
while cnt < self.strat.iteration_timeout_secs:
# if DEBUGGING:
if self.strat.debugging.dummy_data:
# available_bids, available_asks = 5, 6
available_bids = self.strat.lt._ticker_len_n_type_check(
ticker.domBids)
available_asks = self.strat.lt._ticker_len_n_type_check(
ticker.domAsks)
else:
available_bids = self.strat.lt._ticker_len_n_type_check(
ticker.domBids)
available_asks = self.strat.lt._ticker_len_n_type_check(
ticker.domAsks)
if available_asks > 0 and available_bids > 0:
break
else:
log_msg1 = 'no bids or asks available for contract, iterating through {}/ITERATION_TIMEOUT_SECS = {}'\
.format(str(cnt), str(self.strat.iteration_timeout_secs))
log.log(log_msg1)
self.strat.add_to_manager(self.strat.strat_name,
*log.monitor())
self.strat.lt.ib.sleep(1)
cnt += 1
else:
log_msg1 = 'ending iteration - no bids or asks available for contract'
self.cons_disp.print_warning(log_msg1)
status = 1
log.log(log_msg1)
return status
for interm_side in ['ask', 'bid']:
symbol = ticker.contract.symbol
if interm_side == 'ask':
side = 0
items = ticker.domAsks
else:
side = 1
items = ticker.domBids
_n_ranks = self.strat.n_willingness_to_move_up_price \
if self.strat.n_willingness_to_move_up_price >= len(items) \
else len(items)
for rank in range(_n_ranks):
if self.strat.debugging.dummy_data:
# price, size = float(random.randint(10,100)), random.randint(100,10000)
price, size = items[rank].price, items[rank].size
else:
try:
price, size = items[rank].price, items[rank].size
except IndexError:
try:
price, size = items.price, items.size
except AttributeError:
continue
df = pd.DataFrame([[symbol, unix_ts, side, rank, price, size]],
columns=[
'symbol', 'unix_ts', 'side', 'rank',
'price', 'size'
])
self.__hist_data_winners_df = pd.concat(
[self.__hist_data_winners_df, df])
_row_major = 0
# self.lt.add_to_monitor('n __hist_data_winners_df', self.__hist_data_winners_df.shape[_row_major])
# print(self.hist_data_winners_df)
status = 0
log.log(log_msg1, price, size, side)
return status
def __make_trade_decision(self, ticker, order):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.strat.add_to_manager(self.strat.strat_name, *log.monitor())
buy_try, sell_try, status = None, None, None
if order == 'BUY':
side = 1 # bid
elif order == 'SELL':
side = 0 # ask
else:
raise Exception('must be either BUY or SELL')
# if DEBUGGING:
if self.strat.debugging.dummy_data:
# available_bids, available_asks = 5, 6
available_bids = self.strat.lt._ticker_len_n_type_check(
ticker.domBids)
available_asks = self.strat.lt._ticker_len_n_type_check(
ticker.domAsks)
else:
available_bids = self.strat.lt._ticker_len_n_type_check(
ticker.domBids)
available_asks = self.strat.lt._ticker_len_n_type_check(
ticker.domAsks)
buy_conditions = self.signals.__buy_conditions(ticker)
if order == 'BUY' and not buy_conditions:
status = -1
elif order == 'BUY' and buy_conditions:
buy_try = 0
while True:
price, offer_size = self.signals.price_size_select(
ticker, buy_try, side)
if price > self.strat.max_price_instr_usd:
status = 1
break
price, offer_size = self.signals.price_size_select(
ticker, buy_try, side)
cap_ = ''
_cap_cnt = 0
_max_cap_cnt = 10
while _cap_cnt < _max_cap_cnt:
cap_ = self.strat.lt.cash.available_funds(
self.strat.lt.report.pnl(), self.strat.lt.account_curr)
if cap_ != 'value cannot be determined':
break
self.strat.lt.ib.sleep(0.5)
_cap_cnt += 1
if _cap_cnt == _max_cap_cnt:
raise exceptions_.ReportExtractionError
self.strat.add_to_manager(self.strat.strat_name, 'cap_usd',
cap_)
# budget = self.scanner_based.rm.get_budget(len(self.__traded_instr), cap_, self.scanner_based.runtime_tm)
budget = self.strat.rm.get_budget(
len(self.strat.lt.traded_instr), cap_,
self.strat.runtime_tm)
# self.lt.add_to_monitor('budget_per_instr RiskManagement.get_budget', budget)
offer = price * offer_size
size = int(budget / price)
# if budget < price:
# buy_try += 1
# else:
# buy_order_filled_status = self.lt.buy(ticker, buy_try, size, ORDER_TYPE)
# if buy_order_filled_status == 0:
# status = 0
# break
# else:
# status = -1
buy_order_filled_status = self.strat.lt.buy(
ticker, buy_try, size, self.order_type)
if buy_order_filled_status == 0:
status = 0
break
else:
status = -1
if buy_try == self.strat.n_willingness_to_move_up_price - 1 or buy_try == available_bids:
status = -1
break
elif order == 'SELL' and not self.signals.__sell_conditions(ticker):
status = -1
elif order == 'SELL' \
and (self.signals.__sell_conditions(ticker) or self.signals.stop_loss_f(ticker)):
sell_try = 0
size_ix = 3
symbol_ix = 0
while True:
price, offer_size = self.signals.price_size_select(
ticker, sell_try, side)
# offer = price * size
# held_position = self.lt.held_instruments[str(reqId)]['size'] * price
row_num = [i[symbol_ix] for i in self.strat.lt.portfolio
].index(ticker.contract.symbol)
held_size = self.strat.lt.portfolio[row_num][size_ix]
if offer_size < held_size:
sell_try += 1
else:
status = 0
self.strat.lt.sell(ticker, sell_try, self.order_type)
break
if sell_try == self.strat.n_willingness_to_move_up_price - 1 or sell_try == available_asks:
status = -1
break
# statuses:
# -1 = next try/price up
# 0 = ok = buy/sell
# 1 = other conditions not met = abandon
log.log(buy_try, sell_try, status)
def find_winners(self, parallel_traded_instr_per_strat):
log_start = datetime.datetime.now()
log = logging_.Logging(
self.strat.runtime_tm, log_start,
str(self.__class__.__name__ + ',' +
sys._getframe().f_code.co_name))
self.strat.add_to_manager(self.strat.strat_name, *log.monitor())
hist_data_df = None
# matches = None
_analysis_logic = datetime.datetime.strptime(
self.analysis_logic_start_time, '%H:%M:%S')
_trading_logic = datetime.datetime.strptime(
self.trading_logic_start_time, '%H:%M:%S')
_n_iters = int((_trading_logic - _analysis_logic).seconds / 60)
if self.strat.debugging.dummy_time:
_now = self.strat.lt._manipulated_time(datetime.datetime.now())
else:
_now = datetime.datetime.now()
_time_gates = [
self.strat.lt.us_tz_op(_now) + datetime.timedelta(minutes=ix)
for ix, _ in enumerate(range(_n_iters))
] # minutes=ix works fairly well
_inst_ = self
del _inst_
negative_scan_instr, negative_misc_factors = [], []
_factor_val_ix, _factor_type_ix = 0, 1
for nf in self.negative_factors:
v_ = list(nf.values())
if v_[0][_factor_type_ix] == 'scanner':
negative_scan_instr.append(v_)
else:
negative_misc_factors.append(v_)
longer_scan_list = len(self.positive_factors) \
if len(self.positive_factors) >= len(negative_scan_instr) \
else len(self.negative_factors)
reduce_from_longer_scan_list = self.positive_factors \
if len(self.positive_factors) >= len(negative_scan_instr) \
else self.negative_factors
for ix, turn in enumerate(range(_n_iters)):
if ix == 0:
while True:
# first iter, check lenghts and availabilities
# this might be too complicated for the small number of factors
positive_instr, negative_scan_instr = self.initial_scan_to_sort(
longer_scan_list)
matches = self.match_f(positive_instr,
negative_scan_instr,
_n_iters,
_first_iter=True)
negative_misc_instr = []
for nmi_ in negative_misc_factors:
if nmi_[0][_factor_type_ix] == 'finRatiosMarketCap':
for match in matches[0:int(self.strat.lt.
funda_data_req_max /
self.strat.n_strats)]:
try:
if not self.strat.lt.fin_ratios.mkt_cap(
match, nmi_[0][_factor_val_ix]):
negative_misc_instr.append(match)
except Exception as e:
print('stop')
negative_misc_instr = negative_misc_instr + self.black_list
matches = self._remove_misc_negative_instr(
negative_misc_instr, matches, self.strat.runtime_tm)
if len(matches
) < parallel_traded_instr_per_strat and not len(
matches) == 0:
if self.strat.rm.fraction_sorting_out_negative_list > .0:
self._reduce_fraction_sorting_out_negative_list()
continue
if len(self.negative_factors) > 0:
# _key_ = list(self.negative_factors.keys())[0]
_key_ = list(self.negative_factors)
del self.negative_factors[_key_]
continue
self.cons_disp.print_warning(
'not sure if this can be deleted or needs to stay')
# if len(self.positive_factors) == 2:
# break
# _key_ = list(reduce_from_longer_scan_list.keys())[longer_scan_list - 1]
_key_ = list(reduce_from_longer_scan_list.keys())[
longer_scan_list - 1]
del reduce_from_longer_scan_list[_key_]
longer_list = len(self.positive_factors) \
if len(self.positive_factors) >= len(self.negative_factors) \
else len(self.negative_factors)
reduce_from_longer_scan_list = self.positive_factors \
if len(self.positive_factors) >= len(self.negative_factors) \
else self.negative_factors
elif len(matches) == 0:
raise exceptions_.TooFewContractsWhileDeterminingError
else:
break
else:
self._time_gates_f(_time_gates, ix)
_pos_instr, _neg_instr = self.scan_(longer_scan_list)
for _fctr_ix in range(len(positive_instr)):
_key_ = list(positive_instr.keys())[_fctr_ix]
positive_instr[
_key_] = positive_instr[_key_] + _pos_instr[_key_]
for _fctr_ix in range(len(negative_scan_instr)):
_key_ = list(negative_scan_instr.keys())[_fctr_ix]
negative_scan_instr[
_key_] = negative_scan_instr[_key_] + _neg_instr[_key_]
matches = self.match_f(positive_instr, negative_scan_instr, _n_iters)
# matches = self._remove_misc_negative_instr(self.black_list, matches, self.strat.runtime_tm)
if self.strat.debugging.dummy_data:
matches = self.strat.debugging.dummy_instr
log.log(hist_data_df, matches)
return matches
