def get_traders() -> List[str]:
df = get_group(provider='zvt',
data_schema=SimAccount,
column=SimAccount.trader_name,
group_func=None)
if df_is_not_null(df):
return df['trader_name'].tolist()
return []
def df_to_db(df, data_schema, provider):
db_engine = get_db_engine(provider, data_schema=data_schema)
current = get_data(data_schema=data_schema, columns=[data_schema.id], provider=provider)
if df_is_not_null(current):
df = df[~df['id'].isin(current['id'])]
df.to_sql(data_schema.__tablename__, db_engine, index=False, if_exists='append')
def do_compute(self):
"""
calculate tech indicators self.depth_df
"""
if df_is_not_null(self.depth_df) and self.indicators:
for idx, indicator in enumerate(self.indicators):
if indicator == 'ma':
window = self.indicators_param[idx].get('window')
col = 'ma{}'.format(window)
self.indicator_cols.add(col)
if self.entity_type == 'stock' and self.fq == 'qfq':
df = self.depth_df['qfq_close'].groupby(
level=0).rolling(window=window,
min_periods=window).mean()
else:
df = self.depth_df['close'].groupby(level=0).rolling(
window=window, min_periods=window).mean()
df = df.reset_index(level=0, drop=True)
self.depth_df[col] = df
# self.depth_df = pd.concat([self.depth_df, df], axis=1, sort=False)
if indicator == 'macd':
slow = self.indicators_param[idx].get('slow')
fast = self.indicators_param[idx].get('fast')
n = self.indicators_param[idx].get('n')
self.indicator_cols.add('diff')
self.indicator_cols.add('dea')
self.indicator_cols.add('macd')
# for entity_id, df in self.depth_df.groupby('entity_id'):
# if self.entity_type == 'stock' and self.fq == 'qfq':
# diff, dea, m = macd(df['qfq_close'], slow=slow, fast=fast, n=n)
# else:
# diff, dea, m = macd(df['close'], slow=slow, fast=fast, n=n)
#
# self.depth_df.loc[entity_id, 'diff'] = diff
# self.depth_df.loc[entity_id, 'dea'] = dea
# self.depth_df.loc[entity_id, 'macd'] = m
if self.entity_type == 'stock' and self.fq == 'qfq':
df = self.depth_df.groupby(
level=0)['qfq_close'].apply(lambda x: macd(
x, slow=slow, fast=fast, n=n, return_type='df')
)
else:
df = self.depth_df.groupby(
level=0)['close'].apply(lambda x: macd(
x, slow=slow, fast=fast, n=n, return_type='df')
)
self.depth_df = pd.concat([self.depth_df, df],
axis=1,
sort=False)
def run(self):
"""
"""
if self.filter_factors:
musts = []
for factor in self.filter_factors:
df = factor.get_result_df()
if not df_is_not_null(df):
raise Exception('no data for factor:{},{}'.format(
factor.factor_name, factor))
if len(df.columns) > 1:
s = df.agg("and", axis="columns")
s.name = 'score'
musts.append(s.to_frame(name='score'))
else:
df.columns = ['score']
musts.append(df)
self.filter_result = list(accumulate(musts,
func=operator.__and__))[-1]
if self.score_factors:
scores = []
for factor in self.score_factors:
df = factor.get_result_df()
if not df_is_not_null(df):
raise Exception('no data for factor:{],{}'.format(
factor.factor_name, factor))
if len(df.columns) > 1:
s = df.agg("mean", axis="columns")
s.name = 'score'
scores.append(s.to_frame(name='score'))
else:
df.columns = ['score']
scores.append(df)
self.score_result = list(accumulate(scores,
func=operator.__add__))[-1]
self.generate_targets()
def record(self, entity, start, end, size, timestamps):
# 不复权
try:
df = get_bars(to_jq_entity_id(entity),
count=size,
unit=self.jq_trading_level,
fields=[
'date', 'open', 'close', 'low', 'high', 'volume',
'money'
],
include_now=False)
except Exception as e:
# just ignore the error,for some new stocks not in the index
self.logger.exception(e)
return None
df['name'] = entity.name
df.rename(columns={'money': 'turnover'}, inplace=True)
df['timestamp'] = pd.to_datetime(df['date'])
df['provider'] = 'joinquant'
df['level'] = self.level.value
# 前复权
end_timestamp = to_time_str(now_pd_timestamp())
qfq_df = get_bars(to_jq_entity_id(entity),
count=size,
unit=self.jq_trading_level,
fields=['date', 'open', 'close', 'low', 'high'],
fq_ref_date=end_timestamp,
include_now=False)
# not need to update past
df['qfq_close'] = qfq_df['close']
df['qfq_open'] = qfq_df['open']
df['qfq_high'] = qfq_df['high']
df['qfq_low'] = qfq_df['low']
check_df = qfq_df.head(1)
check_date = check_df['date'][0]
current_df = get_kdata(entity_id=entity.id,
provider=self.provider,
start_timestamp=check_date,
end_timestamp=check_date,
limit=1,
level=self.level)
if df_is_not_null(current_df):
old = current_df.iloc[0, :]['qfq_close']
new = check_df['close'][0]
# 相同时间的close不同，表明前复权需要重新计算
if old != new:
self.factor = new / old
self.last_timestamp = pd.Timestamp(check_date)
return df.to_dict(orient='records')
def on_finish_entity(self, entity):
# fill the timestamp for report published date
the_data_list = get_data(
data_schema=self.data_schema,
provider=self.provider,
entity_id=entity.id,
order=self.data_schema.timestamp.asc(),
return_type='domain',
session=self.session,
filters=[
self.data_schema.timestamp == self.data_schema.report_date,
self.data_schema.timestamp >= to_pd_timestamp('2005-01-01')
])
if the_data_list:
if self.data_schema == FinanceFactor:
for the_data in the_data_list:
self.fill_timestamp_with_jq(entity, the_data)
else:
df = get_finance_factor(
entity_id=entity.id,
columns=[
FinanceFactor.timestamp, FinanceFactor.report_date,
FinanceFactor.id
],
filters=[
FinanceFactor.timestamp != FinanceFactor.report_date,
FinanceFactor.timestamp >=
to_pd_timestamp('2005-01-01'),
FinanceFactor.report_date >=
the_data_list[0].report_date,
FinanceFactor.report_date <=
the_data_list[-1].report_date,
])
if df_is_not_null(df):
index_df(df, index='report_date')
for the_data in the_data_list:
if (df is not None) and (
not df.empty) and the_data.report_date in df.index:
the_data.timestamp = df.at[the_data.report_date,
'timestamp']
self.logger.info(
'db fill {} {} timestamp:{} for report_date:{}'.
format(self.data_schema, entity.id,
the_data.timestamp, the_data.report_date))
self.session.commit()
else:
# self.logger.info(
# 'waiting jq fill {} {} timestamp:{} for report_date:{}'.format(self.data_schema,
# security_item.id,
# the_data.timestamp,
# the_data.report_date))
self.fill_timestamp_with_jq(entity, the_data)
def update_data_table(n_clicks, properties, codes: str, start_date, end_date):
if n_clicks and properties:
props = []
for prop in properties:
props.append(json.loads(prop))
readers = properties_to_readers(properties=props,
codes=codes,
start_date=start_date,
end_date=end_date)
if readers:
data_df = readers[0].data_df
for reader in readers[1:]:
if df_is_not_null(reader.data_df):
data_df = data_df.join(reader.data_df, how='outer')
global current_df
current_df = data_df
normal_data = NormalData(data_df)
data_table = Drawer(data=normal_data).draw_data_table(
id='data-table-content')
# generate col setting table
properties = normal_data.data_df.columns.to_list()
df = pd.DataFrame(
OrderedDict([('property', properties),
('y_axis', ['y1'] * len(properties)),
('chart', ['line'] * len(properties))]))
# generate intents
intents = normal_data.get_intents()
intent_options = [{
'label': intent.value,
'value': intent.value
} for intent in intents]
intent_value = intents[0].value
return data_table, df.to_dict(
'records'), normal_data.get_table_type(
), intent_options, intent_value
else:
return 'no data,please reselect!', None, '', [{
'label':
'compare_self',
'value':
'compare_self'
}], 'compare_self'
raise dash.exceptions.PreventUpdate()
def record(self, entity, start, end, size, timestamps):
if self.start_timestamp:
start = max(self.start_timestamp, to_pd_timestamp(start))
# if self.level < IntervalLevel.LEVEL_1HOUR:
# start = '2019-01-01'
end = now_pd_timestamp()
start_timestamp = to_time_str(start)
# 聚宽get_price函数必须指定结束时间，否则会有未来数据
end_timestamp = to_time_str(end, fmt=TIME_FORMAT_MINUTE2)
# 不复权
df = get_price(
to_jq_entity_id(entity),
start_date=to_time_str(start_timestamp),
end_date=end_timestamp,
frequency=self.jq_trading_level,
fields=['open', 'close', 'low', 'high', 'volume', 'money'],
skip_paused=True,
fq=None)
if df_is_not_null(df):
df.index.name = 'timestamp'
df.reset_index(inplace=True)
df['name'] = entity.name
df.rename(columns={'money': 'turnover'}, inplace=True)
df['entity_id'] = entity.id
df['timestamp'] = pd.to_datetime(df['timestamp'])
df['provider'] = 'joinquant'
df['level'] = self.level.value
df['code'] = entity.code
def generate_kdata_id(se):
if self.level >= IntervalLevel.LEVEL_1DAY:
return "{}_{}".format(
se['entity_id'],
to_time_str(se['timestamp'], fmt=TIME_FORMAT_DAY))
else:
return "{}_{}".format(
se['entity_id'],
to_time_str(se['timestamp'], fmt=TIME_FORMAT_ISO8601))
df['id'] = df[['entity_id', 'timestamp']].apply(generate_kdata_id,
axis=1)
df_to_db(df=df,
data_schema=self.data_schema,
provider=self.provider,
force=self.force_update)
return None
def on_finish_entity(self, entity):
kdatas = get_kdata(
provider=self.provider,
entity_id=entity.id,
level=self.level.value,
order=self.data_schema.timestamp.asc(),
return_type='domain',
session=self.session,
filters=[
self.data_schema.hfq_close.is_(None),
self.data_schema.timestamp >= to_pd_timestamp('2005-01-01')
])
if kdatas:
start = kdatas[0].timestamp
end = kdatas[-1].timestamp
# get hfq from joinquant
df = get_price(to_jq_entity_id(entity),
start_date=to_time_str(start),
end_date=now_time_str(),
frequency='daily',
fields=['factor', 'open', 'close', 'low', 'high'],
skip_paused=True,
fq='post')
if df_is_not_null(df):
# fill hfq data
for kdata in kdatas:
time_str = to_time_str(kdata.timestamp)
if time_str in df.index:
kdata.hfq_open = df.loc[time_str, 'open']
kdata.hfq_close = df.loc[time_str, 'close']
kdata.hfq_high = df.loc[time_str, 'high']
kdata.hfq_low = df.loc[time_str, 'low']
kdata.factor = df.loc[time_str, 'factor']
self.session.add_all(kdatas)
self.session.commit()
latest_factor = df.factor[-1]
# factor not change yet, no need to reset the qfq past
if latest_factor == self.current_factors.get(entity.id):
sql = 'UPDATE {} SET qfq_close=hfq_close/{},qfq_high=hfq_high/{}, qfq_open= hfq_open/{}, qfq_low= hfq_low/{} where ' \
'entity_id=\'{}\' and level=\'{}\' and (qfq_close isnull or qfq_high isnull or qfq_low isnull or qfq_open isnull)'.format(
self.data_schema.__table__, latest_factor, latest_factor, latest_factor, latest_factor,
entity.id, self.level.value)
else:
sql = 'UPDATE {} SET qfq_close=hfq_close/{},qfq_high=hfq_high/{}, qfq_open= hfq_open/{}, qfq_low= hfq_low/{} where ' \
'entity_id=\'{}\' and level=\'{}\''.format(self.data_schema.__table__, latest_factor,
latest_factor, latest_factor, latest_factor,
entity.id,
self.level.value)
self.logger.info(sql)
self.session.execute(sql)
self.session.commit()
def is_normalized(self):
if df_is_not_null(self.data_df):
names = self.data_df.index.names
# it has been normalized
if len(names) == 1 and names[0] == self.category_field:
return True
if len(names) == 2 and names[0] == self.category_field and names[
1] == self.index_field:
return True
return False
def normalize(self):
"""
normalize data_df to
col1 col2 col3
entity_id index_field
"""
if df_is_not_null(self.data_df):
if not self.is_normalized():
names = self.data_df.index.names
for level, name in enumerate(names):
if name in self.data_df.columns.tolist():
self.data_df = self.data_df.reset_index(level=level,
drop=True)
else:
self.data_df = self.data_df.reset_index(level=level)
self.data_df = index_df_with_category_xfield(
self.data_df,
category_field=self.category_field,
xfield=self.index_field,
is_timeseries=self.is_timeseries)
if isinstance(self.data_df.index, pd.MultiIndex):
self.entity_ids = list(
self.data_df.index.get_level_values(0).values)
else:
self.entity_ids = list(self.data_df.index.values)
# remove the duplicates
self.entity_ids = list(set(self.entity_ids))
for entity_id, df_item in self.data_df.groupby(
self.category_field):
df = df_item.copy()
df.reset_index(inplace=True, level=self.category_field)
self.df_list.append(df)
if len(self.df_list) > 1:
self.df_list = fill_with_same_index(df_list=self.df_list)
for df in self.df_list:
entity_id = df[df[self.category_field].notna()][
self.category_field][0]
columns = list(df.columns)
columns.remove(self.category_field)
self.entity_map_df[entity_id] = df.loc[:, columns]
self.entity_size = len(self.entity_ids)
self.row_count = int(len(self.data_df) / self.entity_size)
self.column_size = len(self.data_df.columns)
def df_to_db(df, data_schema, provider, force=False):
if not df_is_not_null(df):
return
db_engine = get_db_engine(provider, data_schema=data_schema)
if force:
session = get_db_session(provider=provider, data_schema=data_schema)
ids = df["id"].tolist()
# count = len(ids)
# start = 0
# while True:
# end = min(count, start + 5000)
# sql = f'delete from {data_schema.__tablename__} where id in {tuple(ids[start:end])}'
# session.execute(sql)
# session.commit()
# if end == count:
# break
# start = end
if len(ids) == 1:
sql = f'delete from {data_schema.__tablename__} where id = "{ids[0]}"'
else:
sql = f'delete from {data_schema.__tablename__} where id in {tuple(ids)}'
session.execute(sql)
session.commit()
else:
current = get_data(data_schema=data_schema,
columns=[data_schema.id],
provider=provider)
if df_is_not_null(current):
df = df[~df['id'].isin(current['id'])]
df.to_sql(data_schema.__tablename__,
db_engine,
index=False,
if_exists='append')
def get_targets(
self,
timestamp,
target_type: TargetType = TargetType.open_long) -> pd.DataFrame:
if target_type == TargetType.open_long:
df = self.open_long_df
if target_type == TargetType.open_short:
df = self.open_short_df
if df_is_not_null(df):
if timestamp in df.index:
target_df = df.loc[[to_pd_timestamp(timestamp)], :]
return target_df['entity_id'].tolist()
return []
def get_trading_signals_figure(order_reader: OrderReader,
entity_id: str,
provider: str,
level):
entity_type, _, _ = decode_entity_id(entity_id)
security_factor = TechnicalFactor(entity_type=entity_type, entity_ids=[entity_id],
level=level, provider=provider)
if df_is_not_null(security_factor.get_data_df()):
print(security_factor.get_data_df().tail())
# generate the annotation df
order_reader.move_on(timeout=0)
df = order_reader.get_data_df().copy()
if df_is_not_null(df):
df['value'] = df['order_price']
df['flag'] = df['order_type'].apply(lambda x: order_type_flag(x))
df['color'] = df['order_type'].apply(lambda x: order_type_color(x))
print(df.tail())
data, layout = security_factor.draw(render=None, figures=go.Candlestick, annotation_df=df)
return go.Figure(data=data, layout=layout)
def init_entities(df, entity_type='stock', provider='exchange'):
df = df.drop_duplicates(subset=['id'])
data_schema = get_entity_schema(entity_type)
store_category = get_db_name(data_schema=data_schema)
db_engine = get_db_engine(provider, db_name=store_category)
security_schema = get_entity_schema(entity_type)
current = get_entities(entity_type=entity_type, columns=[security_schema.id, security_schema.code],
provider=provider)
if df_is_not_null(current):
df = df[~df['id'].isin(current['id'])]
df.to_sql(security_schema.__tablename__, db_engine, index=False, if_exists='append')
def generate_targets(self):
if df_is_not_null(self.filter_result) and df_is_not_null(
self.score_result):
# for long
result1 = self.filter_result[self.filter_result.score]
result2 = self.score_result[
self.score_result.score >= self.long_threshold]
long_result = result2.loc[result1.index, :]
# for short
result1 = self.filter_result[~self.filter_result.score]
result2 = self.score_result[
self.score_result.score <= self.short_threshold]
short_result = result2.loc[result1.index, :]
elif df_is_not_null(self.score_result):
long_result = self.score_result[
self.score_result.score >= self.long_threshold]
short_result = self.score_result[
self.score_result.score <= self.short_threshold]
else:
long_result = self.filter_result[self.filter_result.score]
short_result = self.filter_result[~self.filter_result.score]
self.open_long_df = self.normalize_result_df(long_result)
self.open_short_df = self.normalize_result_df(short_result)
def depth_computing(self):
if df_is_not_null(self.data_df):
self.depth_df = self.data_df.reset_index(level='timestamp')
for idx, indicator in enumerate(self.indicators):
if indicator == 'ma':
window = self.indicators_param[idx].get('window')
col = 'ma{}'.format(window)
self.indicator_cols.add(col)
for entity_id, df in self.depth_df.groupby('entity_id'):
if self.entity_type == 'stock':
self.depth_df.loc[entity_id,
col] = ma(df['qfq_close'],
window=window)
else:
self.depth_df.loc[entity_id,
col] = ma(df['close'],
window=window)
if indicator == 'macd':
slow = self.indicators_param[idx].get('slow')
fast = self.indicators_param[idx].get('fast')
n = self.indicators_param[idx].get('n')
self.indicator_cols.add('diff')
self.indicator_cols.add('dea')
self.indicator_cols.add('macd')
for entity_id, df in self.depth_df.groupby('entity_id'):
if self.entity_type == 'stock' and self.fq == 'qfq':
diff, dea, m = macd(df['qfq_close'],
slow=slow,
fast=fast,
n=n)
else:
diff, dea, m = macd(df['close'],
slow=slow,
fast=fast,
n=n)
self.depth_df.loc[entity_id, 'diff'] = diff
self.depth_df.loc[entity_id, 'dea'] = dea
self.depth_df.loc[entity_id, 'macd'] = m
self.depth_df = self.depth_df.set_index('timestamp', append=True)
def load_data(self):
if self.entity_ids:
self.data_df = get_data(data_schema=self.data_schema,
entity_ids=self.entity_ids,
provider=self.provider,
columns=self.columns,
start_timestamp=self.start_timestamp,
end_timestamp=self.end_timestamp,
filters=self.filters,
order=self.order,
limit=self.limit,
level=self.level,
time_field=self.time_field,
index=self.time_field)
else:
self.data_df = get_data(data_schema=self.data_schema,
codes=self.codes,
provider=self.provider,
columns=self.columns,
start_timestamp=self.start_timestamp,
end_timestamp=self.end_timestamp,
filters=self.filters,
order=self.order,
limit=self.limit,
level=self.level,
time_field=self.time_field,
index=self.time_field)
if self.trip_timestamp:
if self.level == IntervalLevel.LEVEL_1DAY:
self.data_df[self.time_field] = self.data_df[
self.time_field].apply(
lambda x: to_pd_timestamp(to_time_str(x)))
if df_is_not_null(self.data_df):
self.normal_data = NormalData(df=self.data_df,
category_field=self.category_field,
index_field=self.time_field,
is_timeseries=True)
self.data_df = self.normal_data.data_df
for listener in self.data_listeners:
listener.on_data_loaded(self.data_df)
def on_finish(self):
last_year = str(now_pd_timestamp().year)
codes = [item.code for item in self.entities]
need_filleds = get_dividend_financing(
provider=self.provider,
codes=codes,
return_type='domain',
session=self.session,
filters=[DividendFinancing.spo_raising_fund.is_(None)],
end_timestamp=last_year)
for item in need_filleds:
df = get_spo_detail(
provider=self.provider,
entity_id=item.entity_id,
columns=[SpoDetail.timestamp, SpoDetail.spo_raising_fund],
start_timestamp=item.timestamp,
end_timestamp="{}-12-31".format(item.timestamp.year))
if df_is_not_null(df):
item.spo_raising_fund = df['spo_raising_fund'].sum()
self.session.commit()
super().on_finish()
def move_on(self, to_timestamp: Union[str, pd.Timestamp] = None,
timeout: int = 20) -> bool:
"""
get the data happened before to_timestamp,if not set,get all the data which means to now
Parameters
----------
to_timestamp :
timeout : the time waiting the data ready in seconds
Returns
-------
whether got data
"""
if not df_is_not_null(self.data_df):
self.load_data()
return False
df = self.data_df.reset_index(level='timestamp')
recorded_timestamps = df.groupby(level=0)['timestamp'].max()
self.logger.info('level:{},current_timestamps:\n{}'.format(self.level, recorded_timestamps))
changed = False
# FIXME:we suppose history data should be there at first
start_time = time.time()
for category, recorded_timestamp in recorded_timestamps.iteritems():
while True:
category_filter = [self.category_column == category]
if self.filters:
filters = self.filters + category_filter
else:
filters = category_filter
added = get_data(data_schema=self.data_schema, provider=self.provider, columns=self.columns,
start_timestamp=recorded_timestamp,
end_timestamp=to_timestamp, filters=filters, level=self.level)
if df_is_not_null(added):
would_added = added[added['timestamp'] != recorded_timestamp].copy()
if not would_added.empty:
added = index_df_with_category_xfield(would_added, category_field=self.category_field,
xfield=self.time_field)
self.logger.info('category:{},added:\n{}'.format(category, added))
self.data_df = self.data_df.append(added)
self.data_df = self.data_df.sort_index(level=[0, 1])
for listener in self.data_listeners:
listener.on_category_data_added(category=category, added_data=added)
changed = True
# if got data,just move to another category
break
cost_time = time.time() - start_time
if cost_time > timeout:
self.logger.warning(
'category:{} level:{} getting data timeout,to_timestamp:{},now:{}'.format(category, self.level,
to_timestamp,
now_pd_timestamp()))
break
if changed:
for listener in self.data_listeners:
listener.on_data_changed(self.data_df)
return changed
def get_data(data_schema,
entity_ids: List[str] = None,
entity_id: str = None,
codes: List[str] = None,
level: Union[IntervalLevel, str] = None,
provider: str = None,
columns: List = None,
return_type: str = 'df',
start_timestamp: Union[pd.Timestamp, str] = None,
end_timestamp: Union[pd.Timestamp, str] = None,
filters: List = None,
session: Session = None,
order=None,
limit: int = None,
index: str = 'timestamp',
index_is_time: bool = True,
time_field: str = 'timestamp'):
assert data_schema is not None
assert provider is not None
assert provider in global_providers
local_session = False
if not session:
session = get_db_session(provider=provider, data_schema=data_schema)
local_session = True
try:
time_col = eval('data_schema.{}'.format(time_field))
if columns:
# support str
if type(columns[0]) == str:
columns_ = []
for col in columns:
columns_.append(eval('data_schema.{}'.format(col)))
columns = columns_
if time_col not in columns:
columns.append(time_col)
query = session.query(*columns)
else:
query = session.query(data_schema)
if entity_id:
query = query.filter(data_schema.entity_id == entity_id)
if codes:
query = query.filter(data_schema.code.in_(codes))
if entity_ids:
query = query.filter(data_schema.entity_id.in_(entity_ids))
# we always store different level in different schema,the level param is not useful now
if level:
try:
# some schema has no level,just ignore it
data_schema.level
if type(level) == IntervalLevel:
level = level.value
query = query.filter(data_schema.level == level)
except Exception as e:
pass
query = common_filter(query,
data_schema=data_schema,
start_timestamp=start_timestamp,
end_timestamp=end_timestamp,
filters=filters,
order=order,
limit=limit,
time_field=time_field)
if return_type == 'df':
df = pd.read_sql(query.statement, query.session.bind)
if df_is_not_null(df):
return index_df(df,
drop=False,
index=index,
index_is_time=index_is_time)
return df
elif return_type == 'domain':
return query.all()
elif return_type == 'dict':
return [item.__dict__ for item in query.all()]
except Exception:
raise
finally:
if local_session:
session.close()
def is_empty(self):
return not df_is_not_null(self.data_df)
def normalize_result_df(self, df):
if df_is_not_null(df):
df = df.reset_index()
df = index_df(df)
df = df.sort_values(by=['score', 'entity_id'])
return df
def get_trader_detail_figures(trader_domain: business.Trader,
account_reader: AccountReader,
order_reader: OrderReader):
graph_list = []
if account_reader:
account_data, account_layout = account_reader.data_drawer().draw_line(render=None, keep_ui_state=False)
for trader_name in account_reader.trader_names:
graph_list.append(dcc.Graph(
id='{}-account'.format(trader_name),
figure={
'data': account_data,
'layout': account_layout
}))
order_reader.move_on(timeout=0)
df_orders = order_reader.get_data_df().copy()
if df_is_not_null(df_orders):
grouped = df_orders.groupby('entity_id')
for entity_id, order_df in grouped:
entity_type, _, _ = decode_entity_id(entity_id)
indicators = []
indicators_param = []
indicator_cols = []
if trader_domain.technical_factors:
tech_factors = simplejson.loads(trader_domain.technical_factors)
print(tech_factors)
for factor in tech_factors:
indicators += factor['indicators']
indicators_param += factor['indicators_param']
indicator_cols += factor['indicator_cols']
security_factor = TechnicalFactor(entity_type=entity_type, entity_ids=[entity_id],
start_timestamp=trader_domain.start_timestamp,
end_timestamp=trader_domain.end_timestamp,
level=trader_domain.level, provider=trader_domain.provider,
indicators=indicators,
indicators_param=indicators_param)
# generate the annotation df
df = order_df.copy()
if df_is_not_null(df):
df['value'] = df['order_price']
df['flag'] = df['order_type'].apply(lambda x: order_type_flag(x))
df['color'] = df['order_type'].apply(lambda x: order_type_color(x))
print(df.tail())
data, layout = security_factor.draw_depth(render=None, annotation_df=df, height=620)
if trader_domain.real_time:
result = get_current_price(entity_ids=[entity_id])
bid_ask = result.get(entity_id)
if bid_ask:
graph_list.append(daq.LEDDisplay(
id='ask',
label=f'ask price',
value=bid_ask[0],
color="#00da3c"
))
graph_list.append(daq.LEDDisplay(
id='bid',
label=f'bid price',
value=bid_ask[1],
color="#FF5E5E"
))
graph_list.append(
dcc.Graph(
id='{}-{}-signals'.format(trader_domain.trader_name, entity_id),
figure={
'data': data,
'layout': layout
}
)
)
return graph_list
