def is_suspended(order_book_ids, start_date=None, end_date=None, market="cn"):
"""获取股票停牌信息
:param order_book_ids: 股票名称
:param start_date: 开始日期, 如'2013-01-04' (Default value = None)
:param end_date: 结束日期，如'2014-01-04' (Default value = None)
:param market: 地区代码, 如 'cn' (Default value = "cn")
:returns: DataFrame
"""
order_book_ids = ensure_order_book_ids(order_book_ids, type="CS", market=market)
if len(order_book_ids) == 1:
instrument = instruments(order_book_ids[0], market=market)
start_date, end_date = ensure_dates_base_on_listed_date(instrument, start_date, end_date, market)
if start_date is None:
return
if end_date is None:
end_date = datetime.date.today()
start_date, end_date = ensure_date_range(start_date, end_date)
trading_dates = pd.to_datetime(get_trading_dates(start_date, end_date, market=market))
df = pd.DataFrame(data=False, columns=order_book_ids, index=trading_dates)
data = get_client().execute("get_suspended_days", order_book_ids, start_date, end_date, market=market)
for idx, dates in data.items():
for date in dates:
date = to_datetime(int(date))
df.at[date, idx] = True
df.sort_index(inplace=True)
return df
def get_money_supply(start_date=None, end_date=None, market="cn"):
"""获取货币供应量信息
:param start_date: 开始日期，默认为一年前
:param end_date: 结束日期，默认为今天
:param market: (Default value = "cn")
"""
check_items_in_container("info_date", ["info_date", "effective_date"],
"date_type")
start_date, end_date = ensure_date_range(start_date,
end_date,
delta=relativedelta(years=1))
data = get_client().execute("econ.get_money_supply",
start_date,
end_date,
market=market)
if not data:
return
columns = [
"info_date",
"effective_date",
"m2",
"m1",
"m0",
"m2_growth_yoy",
"m1_growth_yoy",
"m0_growth_yoy",
]
df = pd.DataFrame(
data,
columns=columns).set_index("info_date").sort_index(ascending=True)
return df
def top_stocks(field, date, frequency="1d", count=5, market="cn"):
"""获取雪球舆情数据
:param field: 如 'new_comments', 'total_comments', 'new_followers',
'total_followers', 'sell_actions', 'buy_actions'
:param date: 如 '2015-05-21', 必须在2015年4月23日之后
:param frequency: 如 '1d', '1w', '1M' (Default value = "1d")
:param count: 如 5, 10, 100 (Default value = 5)
:param market: 地区代码, 如 'cn' (Default value = "cn")
:returns: 如果有数据，返回一个DataFrame,否则返回None
"""
field = ensure_string(field, "field")
frequency = ensure_string(frequency, "frequency")
check_items_in_container([field], FIELDS, "field")
check_items_in_container([frequency], {"1d", "1w", "1M"}, "frequency")
d = {"1d": "d", "1M": "m", "1w": "w"}
frequency = d[frequency]
date = ensure_date_int(date)
if date < 20150423 or date > ensure_date_int(datetime.datetime.today()):
raise ValueError("date out of range, start_date "
"cannot be earlier than 2015-04-23")
data = get_client().execute("xueqiu.top_stocks", field, date, frequency,
count, market)
if not data:
return
df = pd.DataFrame(data)
df = df[["order_book_id", field]]
return df
def get_term_to_maturity(order_book_ids, start_date=None, end_date=None, market="cn"):
"""获取货币型基金的持仓剩余期限
:param order_book_ids: 基金代码，str
:param start_date: 开始日期 (Default value = None)
:param end_date: 结束日期 (Default value = None)
:param market: (Default value = "cn")
:returns: DataFrame
"""
order_book_ids = ensure_fund(order_book_ids, market)
if start_date:
start_date = ensure_date_int(start_date)
if end_date:
end_date = ensure_date_int(end_date)
result = get_client().execute("fund.get_term_to_maturity", [order_book_ids], start_date, end_date, market=market)
if not result or result[0] is None:
return
df = pd.DataFrame(result)
df = df[['date', '0_30', '30_60', '60_90', '90_120', '120_397', '90_180', '>180']]
df.set_index('date', inplace=True)
df = df.stack().reset_index()
if pd_version >= "0.21":
df.set_axis(['date', 'term', 'weight'], axis=1, inplace=True)
else:
df.set_axis(1, ['date', 'term', 'weight'])
df = df.set_index('date').sort_index()
df.dropna(inplace=True)
return df
def index_indicator(order_book_ids, start_date=None, end_date=None, fields=None, market="cn"):
"""获取指数指标
:param order_book_ids: 如'000016.XSHG'
:param start_date: 如'2016-01-01' (Default value = None)
:param end_date: 如'2017-01-01' (Default value = None)
:param fields: 如'pb', 默认返回全部 fields (Default value = None)
:param market: (Default value = "cn")
:returns: pd.DataFrame 或 None
"""
all_fields = ("pe_ttm", "pe_lyr", "pb_ttm", "pb_lyr", "pb_lf")
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
if fields is not None:
fields = ensure_list_of_string(fields)
for f in fields:
if f not in all_fields:
raise ValueError("invalid field: {}".format(f))
else:
fields = all_fields
df = get_client().execute(
"index_indicator", order_book_ids, start_date, end_date, fields, market=market
)
if not df:
return
df = pd.DataFrame(df)
df.set_index(["order_book_id", "trade_date"], inplace=True)
return df
def get_manager_info(manager_id, fields=None, market="cn"):
"""获取基金经理个人信息
:param manager: 可以使用人员编码（如'101000002'）或姓名（如'江辉'），str 或 list of str
:param fields: str or list of str，例如："gender", "region", (Default value = None)
:param market: (Default value = "cn")
:returns: DataFrame
"""
manager_id = ensure_list_of_string(manager_id)
# 检查manager中是否同时有人员编码或姓名
if len(set(map(lambda x: x.isdigit(), manager_id))) > 1:
raise ValueError("couldn't get manager_id and name at the same time")
manager_fields = ["gender", "region", "birthdate", "education", "practice_date", "experience_time", "background"]
if fields is not None:
fields = ensure_list_of_string(fields, "fields")
check_items_in_container(fields, manager_fields, "fields")
else:
fields = manager_fields
result = get_client().execute("fund.get_manager_info", manager_id, fields, market=market)
if not result:
warnings.warn("manager_id/manager_name does not exist")
return
df = pd.DataFrame(result).set_index("id")
fields.insert(0, "chinesename")
df.sort_index(inplace=True)
return df[fields]
def get_indicators(order_book_ids, start_date=None, end_date=None, fields=None, market="cn"):
"""获取基金衍生数据
:param order_book_ids: 基金代码，str 或 list of str
:param start_date: 开始日期 (Default value = None)
:param end_date: 结束日期 (Default value = None)
:param fields: str or list of str (Default value = None)
:param market: (Default value = "cn")
:returns: DataFrame or Series
"""
order_book_ids = ensure_list_of_string(order_book_ids)
if start_date:
start_date = ensure_date_int(start_date)
if end_date:
end_date = ensure_date_int(end_date)
if fields is not None:
fields = ensure_list_of_string(fields, "fields")
result = get_client().execute("fund.get_indicators", order_book_ids, start_date, end_date, fields, market=market)
if not result:
return
df = pd.DataFrame(result).set_index(keys=["order_book_id", "datetime"])
df.sort_index(inplace=True)
if fields is not None:
return df[fields]
return df
def get_split(order_book_ids, start_date=None, end_date=None, market="cn"):
"""获取拆分信息
:param order_book_ids: 股票 order_book_id or order_book_id list
:param start_date: 开始日期；默认为上市首日
:param end_date: 结束日期；默认为今天
:param market: (Default value = "cn")
"""
order_book_ids = ensure_order_book_ids(order_book_ids, market=market)
if start_date is not None:
start_date = ensure_date_int(start_date)
if end_date is not None:
end_date = ensure_date_int(end_date)
data = get_client().execute("get_split",
order_book_ids,
start_date,
end_date,
market=market)
if not data:
return
df = pd.DataFrame(data)
df.sort_values("ex_dividend_date", inplace=True)
# cumprod [1, 2, 4] -> [1, 1*2, 1*2*4]
df["cum_factor"] = df["split_coefficient_to"] / df["split_coefficient_from"]
df["cum_factor"] = df.groupby("order_book_id")["cum_factor"].cumprod()
if len(order_book_ids) == 1:
df.set_index("ex_dividend_date", inplace=True)
else:
df.set_index(["order_book_id", "ex_dividend_date"], inplace=True)
df.sort_index(inplace=True)
return df
def get_price_change_rate(order_book_ids,
start_date=None,
end_date=None,
expect_df=False,
market="cn"):
"""获取价格变化信息
:param order_book_ids: 股票列表
:param start_date: 开始日期: 如'2013-01-04'
:param end_date: 结束日期: 如'2014-01-04'；在 start_date 和 end_date 都不指定的情况下，默认为最近3个月
:param expect_df: 返回 DataFrame (Default value = False)
:param market: 地区代码
:returns: 如果输入一只股票, 则返回pandas.Series, 否则返回pandas.DataFrame
"""
start_date, end_date = ensure_date_range(start_date, end_date)
order_book_ids = ensure_order_book_ids(order_book_ids)
data = get_client().execute("get_daily_returns",
order_book_ids,
start_date,
end_date,
market=market)
if not data:
return None
df = pd.DataFrame(data)
if len(order_book_ids) == 1 and not expect_df:
df = df.set_index("date")
series = df["daily_return"]
series.name = order_book_ids[0]
return series
df = df.pivot(index="date", columns="order_book_id", values="daily_return")
return df.sort_index()
def get_descriptor_exposure(order_book_ids,
start_date,
end_date,
descriptors=None,
market="cn"):
"""获取个股细分因子暴露度
:param order_book_ids: 证券代码（例如：‘600705.XSHG’）
:param start_date: 开始日期（例如：‘2017-03-03’）
:param end_date: 结束日期（例如：‘2017-03-20’）
:param descriptors: 细分风格因子。默认调用全部因子的暴露度（'all'）。
具体细分因子名称见说明文档 (Default value = None)
:param market: (Default value = "cn")
:returns: MultiIndex DataFrame. index 第一个 level 为 order_book_id，第 二个 level 为 date，column 为细分风格因子字段名称。
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
if descriptors is not None:
if descriptors == "all":
descriptors = None
else:
descriptors = ensure_list_of_string(descriptors)
check_items_in_container(descriptors, _DESCRIPTORS, "descriptors")
df = get_client().execute("get_descriptor_exposure",
order_book_ids,
start_date,
end_date,
descriptors,
market=market)
if not df:
return
return pd.DataFrame(df).set_index(["order_book_id",
"date"]).sort_index(level=1)
def get_ex_factor(order_book_ids, start_date=None, end_date=None, market="cn"):
"""获取复权因子
:param order_book_ids: 如'000001.XSHE'
:param market: 国家代码, 如 'cn' (Default value = "cn")
:param start_date: 开始日期，默认为股票上市日期
:param end_date: 结束日期，默认为今天
:returns: 如果有数据，返回一个DataFrame, 否则返回None
"""
order_book_ids = ensure_order_book_ids(order_book_ids, market=market)
if start_date is not None:
start_date = ensure_date_int(start_date)
if end_date is not None:
end_date = ensure_date_int(end_date)
data = get_client().execute("get_ex_factor",
order_book_ids,
start_date,
end_date,
market=market)
if not data:
return None
df = pd.DataFrame(data)
df.sort_values(["order_book_id", "ex_date"], inplace=True)
df.set_index("ex_date", inplace=True)
return df
def get_style_factor_exposure(order_book_ids,
start_date,
end_date,
factors=None,
market="cn"):
"""获取个股风格因子暴露度
:param order_book_ids: 证券代码（例如：‘600705.XSHG’）
:param start_date: 开始日期（例如：‘2017-03-03’）
:param end_date: 结束日期（例如：‘2017-03-20’）
:param factors: 风格因子。默认调用全部因子的暴露度（'all'）。
具体因子名称见说明文档 (Default value = None)
:param market: (Default value = "cn")
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
if factors is not None:
factors = ensure_list_of_string(factors)
check_items_in_container(factors, _STYLE_FACTORS, "factors")
df = get_client().execute("get_style_factor_exposure",
order_book_ids,
start_date,
end_date,
factors,
market=market)
if not df:
return
return pd.DataFrame(df).set_index(["order_book_id",
"date"]).sort_index(level=1)
def is_st_stock(order_book_ids, start_date=None, end_date=None, market="cn"):
"""判断股票在给定的时间段是否是ST股, 返回值为一个DataFrame
:param order_book_ids: 股票 id
:param start_date: (Default value = None)
:param end_date: (Default value = None)
:param market: (Default value = "cn")
"""
order_book_ids = ensure_order_book_ids(order_book_ids,
type="CS",
market=market)
if len(order_book_ids) == 1:
instrument = instruments(order_book_ids[0], market=market)
start_date, end_date = ensure_dates_base_on_listed_date(
instrument, start_date, end_date, market)
if start_date is None:
return
start_date, end_date = ensure_date_range(start_date, end_date)
trading_dates = pd.to_datetime(
get_trading_dates(start_date, end_date, market=market))
data = get_client().execute("get_st_days",
order_book_ids,
start_date=start_date,
end_date=end_date)
df = pd.DataFrame(data=False, columns=order_book_ids, index=trading_dates)
for idx, dates in data.items():
for date in dates:
date = to_datetime(date)
df.at[date, idx] = True
return df
def current_stock_connect_quota(
connect=None, fields=None
):
"""
获取沪港通、深港通资金流向数据
:param connect: 字符串，目前可从sh_to_hk, hk_to_sh, sz_to_hk, hk_to_sz多选, 默认为查询所有资金流向数据
:param fields: 字符串列表，需要的字段，目前可从buy_turnover, sell_turnover, quota_balance, quota_balance_ratio多选, 默认取所有
"""
DEFAULT_CONNECT = ["sh_to_hk", "hk_to_sh", "sz_to_hk", "hk_to_sz"]
if connect is None:
connect = DEFAULT_CONNECT
else:
connect = ensure_list_of_string(connect)
check_items_in_container(connect, DEFAULT_CONNECT, 'connect')
DEFAULT_FIELDS = ['buy_turnover', 'sell_turnover', 'quota_balance', 'quota_balance_ratio']
if fields is None:
fields = DEFAULT_FIELDS
else:
fields = ensure_list_of_string(fields)
check_items_in_container(fields, DEFAULT_FIELDS, 'fields')
data = get_client().execute("current_stock_connect_quota", connect=connect)
res = pd.DataFrame(data)
if res.empty:
return None
res["datetime"] = pd.to_datetime(res["datetime"], format='%Y%m%d%H%M')
res.set_index(['datetime', 'connect'], inplace=True)
res = res[fields]
return res
def get_warehouse_stocks(underlying_symbols,
start_date=None,
end_date=None,
market="cn"):
"""获取时间区间内期货的注册仓单
:param underlying_symbols: 期货品种, 支持列表查询
:param start_date: 如'2015-01-01', 如果不填写则为去年的当日日期
:param end_date: 如'2015-01-01', 如果不填写则为当日日期
:param market: 市场, 默认为"cn"
:return: pd.DataFrame
"""
underlying_symbols = ensure_list_of_string(underlying_symbols,
name="underlying_symbols")
start_date, end_date = ensure_date_range(start_date,
end_date,
delta=relativedelta(years=1))
ret = get_client().execute("futures.get_warehouse_stocks",
underlying_symbols,
start_date,
end_date,
market=market)
if not ret:
return
columns = ["date", "underlying_symbol", "on_warrant", "exchange"]
df = pd.DataFrame(ret, columns=columns)
df.set_index(['date', 'underlying_symbol'], inplace=True)
return df.sort_index()
def get_block_trade(order_book_ids,
start_date=None,
end_date=None,
market='cn'):
"""获取大宗交易信息
:param order_book_ids: 股票代码
:param start_date: 起始日期，默认为前三个月
:param end_date: 截止日期，默认为今天
:param market: (default value = 'cn')
:return: pd.DataFrame or None
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
data = get_client().execute('get_block_trade',
order_book_ids,
start_date,
end_date,
market=market)
if not data:
return
df = pd.DataFrame(data)[[
'order_book_id', 'trade_date', 'price', 'volume', 'total_turnover',
'buyer', 'seller'
]]
df.set_index(["order_book_id", "trade_date"], inplace=True)
df.sort_index(inplace=True)
return df
def option(self, option_type=None):
if option_type is not None:
option_type = ensure_int(option_type)
if option_type not in (1, 2, 3, 4, 5, 6, 7):
raise ValueError(
"option_type: expect value in (None, 1, 2, 3, 4, 5, 6, 7)")
data = get_client().execute("convertible.option", self.order_book_id,
option_type)
if not data:
return
df = pd.DataFrame(data)
if 'payment_year' in df.columns:
sort_fields = ['option_type', 'payment_year']
else:
sort_fields = ['option_type']
df = df.sort_values(sort_fields).reset_index()
column_order = [
'option_type', 'start_date', 'end_date', 'payment_year', 'level',
'window_days', 'reach_days', 'frequency', 'price',
'if_include_interest', 'remark'
]
column = [i for i in column_order if i in df.columns]
return df[column]
def get_dividend_info(order_book_ids,
start_date=None,
end_date=None,
market="cn"):
"""对应时间段是否发生分红
:param order_book_ids: 股票 order_book_id or order_book_id list
:param start_date: 开始日期，默认为空
:param end_date: 结束日期，默认为空
:param market: (Default value = "cn")
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
if start_date is not None:
start_date = ensure_date_int(start_date)
if end_date is not None:
end_date = ensure_date_int(end_date)
if start_date and end_date:
if start_date > end_date:
raise ValueError("invalid date range: [{!r}, {!r}]".format(
start_date, end_date))
data = get_client().execute("get_dividend_info",
order_book_ids,
start_date,
end_date,
market=market)
if not data:
return
df = pd.DataFrame(data)
if len(order_book_ids) == 1:
df.set_index("effective_date", inplace=True)
else:
df.set_index(["order_book_id", "effective_date"], inplace=True)
return df.sort_index()
def get_ratings(order_book_id, date=None, market="cn"):
"""获取距离指定日期最近发布的基金评级信息
:param order_book_id: 基金代码 str or list
:param date: 日期，为空则返回所有时间段的数据 (Default value = None)
:param market: (Default value = "cn")
:returns: DataFrame
"""
order_book_id = ensure_list_of_string(order_book_id)
if date is not None:
date = to_datetime(date)
if date > datetime.datetime.today():
return
date = ensure_date_int(date)
df = get_client().execute("fund.get_ratings_v2", order_book_id, date, market=market)
if not df:
return
df = pd.DataFrame(df, columns=["order_book_id", "datetime", "zs", "sh3", "sh5", "jajx"])
df.sort_values(["order_book_id", "datetime"], inplace=True)
if date is not None:
df.drop_duplicates(subset=['order_book_id'], keep='last', inplace=True)
df.set_index(["order_book_id", "datetime"], inplace=True)
df.fillna(np.nan, inplace=True)
return df
def get_ksh_minbar(order_book_ids, start_date, end_date, fields, duration, market):
data = get_client().execute(
"get_ksh_minbar", order_book_ids, start_date, end_date, fields, duration, market
)
if data:
data = [(obid, {k: np.frombuffer(*v) for k, v in d.items()}) for obid, d in data]
df = convert_bar_to_multi_df(data, 'datetime', fields, int14_to_datetime_v)
else:
df = None
today = today_int()
if df is None:
history_latest_date = date_to_int8(get_previous_trading_date(today, market=market))
else:
history_latest_date = date_to_int8(df.index.get_level_values(1).max())
if history_latest_date >= end_date or start_date > today or history_latest_date >= today:
return df
live_df = get_today_ksh_minbar(order_book_ids, today, fields, duration, market)
if live_df is None:
return df
if df is None:
return live_df
df = pd.concat([df, live_df])
df.sort_index(inplace=True)
return df
def get_etf_components(order_book_id, trading_date=None, market="cn"):
"""获取etf基金份额数据
:param order_book_id: 基金代码 str
:param trading_date: 交易日期，默认为当天
:param market: (Default value = "cn")
:return: DataFrame
"""
if order_book_id.endswith(".XSHG") or order_book_id.endswith(".XSHE"):
pass
elif order_book_id.startswith("1"):
order_book_id = order_book_id + ".XSHE"
elif order_book_id.startswith("5"):
order_book_id = order_book_id + ".XSHG"
else:
return None
if trading_date is not None:
trading_date = to_date(trading_date)
if trading_date > datetime.date.today():
return None
else:
trading_date = datetime.date.today()
trading_date = ensure_date_int(ensure_trading_date(trading_date))
result = get_client().execute("fund.get_etf_components", order_book_id, trading_date, market=market)
if not result:
return None
columns = ["trading_date", "order_book_id", "stock_code", "stock_amount", "cash_substitute",
"cash_substitute_proportion", "fixed_cash_substitute"]
df = pd.DataFrame(result, columns=columns).sort_values(by=["trading_date", "order_book_id", "stock_code"],
ascending=[True, True, True])
return df
def get_ksh_tickbar(order_book_id, start_date, end_date, fields, market):
order_book_id = ensure_order_book_id(order_book_id)
start_date, end_date = ensure_date_range(start_date, end_date, datetime.timedelta(days=3))
data = get_client().execute(
"get_ksh_tickbar", order_book_id, start_date, end_date, fields, market
)
today = today_int()
if data:
data = [(obid, {k: np.frombuffer(*v) for k, v in d.items()}) for obid, d in data]
df_list = []
for obid, d in data:
df = pd.DataFrame(d)
df_list.append(df)
df = pd.concat(df_list) # type: pd.DataFrame
df["datetime"] = int17_to_datetime_v(df["datetime"].values)
history_latest_date = date_to_int8(df.iloc[-1]["datetime"])
df.set_index("datetime", inplace=True)
else:
df = None
history_latest_date = date_to_int8(get_previous_trading_date(today, market=market))
if history_latest_date >= end_date or start_date > today or history_latest_date >= today:
return df
live_df = get_today_ksh_tick(order_book_id, today, fields, market=market)
if live_df is None:
return df
if df is None:
return live_df
return pd.concat([df, live_df])
def get_bond_stru(order_book_id, date=None, market="cn"):
"""获取指定日期公募基金债券持仓券种明细信息
:param order_book_id: 基金代码 str, 仅支持传入单个基金代码
:param date: 日期，为空则返回所有时间段的数据 (Default value = None)
:param market: (Default value = "cn")
:returns: DataFrame
"""
order_book_id = ensure_string(order_book_id)
order_book_id = ensure_fund(order_book_id, market)
if date is not None:
date = to_datetime(date)
if date > datetime.datetime.today():
return
date = ensure_date_int(date)
data = get_client().execute("fund.get_bond_stru", order_book_id, date, market=market)
if not data:
return
df = pd.DataFrame(data)
df.set_index(['date'], inplace=True)
df.sort_index(inplace=True)
df = df[['order_book_id', 'bond_type', 'weight_nv', 'weight_bond_mv', 'market_value']]
return df
def get_ksh_daybar(order_book_ids, start_date, end_date, fields, duration=1, market="cn"):
data = get_client().execute(
"get_ksh_daybar", order_book_ids, start_date, end_date, fields, duration, market
)
data = [(obid, {k: np.frombuffer(*v) for k, v in d.items()}) for obid, d in data]
res = convert_bar_to_multi_df(data, 'date', fields, int8_to_datetime_v)
return res
def get_reserve_ratio(reserve_type="all",
start_date=None,
end_date=None,
market="cn"):
"""获取存款准备金率
:param reserve_type: 存款准备金详细类别，默认为'all'，目前仅支持'all'、'major'、'other'类别的查询
:param start_date: 开始查找时间，如'20180501'，默认为上一年的当天
:param end_date: 截止查找时间，如'20180501'，默认为当天
:param market: (Default value = "cn")
:return: pd.DataFrame
"""
check_items_in_container(reserve_type, ["all", "major", "other"],
"reserve_type")
start_date, end_date = ensure_date_range(start_date,
end_date,
delta=relativedelta(years=1))
ret = get_client().execute("econ.get_reserve_ratio", reserve_type,
start_date, end_date, market)
if not ret:
return
columns = [
"info_date", "effective_date", "reserve_type", "ratio_floor",
"ratio_ceiling"
]
df = pd.DataFrame(
ret, columns=columns).set_index("info_date").sort_index(ascending=True)
return df
def performance_forecast(order_book_id, info_date=None, end_date=None, fields=None, market="cn"):
"""获取业绩预报
:param order_book_id: 股票代码，如'000001.XSHE'
:param info_date: 信息发布日期，如'20180501'，默认为最近的交易日 (Default value = None)
:param end_date: 业绩预计报告期，如'20180501'，默认为最近的交易日 (Default value = None)
:param fields: str或list类型. 默认为None，返回所有字段 (Default value = None)
:param market: (Default value = "cn")
:returns: pd.DataFrame
"""
order_book_id = ensure_order_book_id(order_book_id)
if info_date:
info_date = ensure_date_int(info_date)
elif end_date:
end_date = ensure_date_int(end_date)
else:
info_date = ensure_date_int(datetime.datetime.today())
if fields:
fields = ensure_list_of_string(fields, "fields")
check_items_in_container(fields, PERFORMANCE_FORECAST_FIELDS, "fields")
else:
fields = PERFORMANCE_FORECAST_FIELDS
data = get_client().execute(
"performance_forecast", order_book_id, info_date, end_date, fields, market=market
)
if not data:
return
df = pd.DataFrame(data)[["info_date", "end_date"] + fields]
return df
def _prepare_ex_factor_for(order_book_ids, market):
global _ex_factor_cache, _expired, _split_factor_cache
if _expired < time.time():
_ex_factor_cache.clear()
_split_factor_cache.clear()
_expired = time.time() + 3600 * 8
missing = [ob for ob in order_book_ids if ob not in _ex_factor_cache]
if not missing:
return
data = get_client().execute('_get_ex_factor', missing, market)
if not data:
_ex_factor_cache.update((ob, None) for ob in missing)
return
remain = set(r['order_book_id'] for r in data)
# for each order_book_id, we add an init ex_factor value
data.extend({
'order_book_id': o,
'ex_date': MIN_DATE,
'ex_cum_factor': 1.0
} for o in remain)
df = pd.DataFrame(data)
df = df[df.ex_date <= pd.datetime.today()]
df.set_index('ex_date', inplace=True)
df.sort_index(inplace=True)
for order_book_id, s in df.groupby('order_book_id')['ex_cum_factor']:
_ex_factor_cache[order_book_id] = s
for order_book_id in missing:
if order_book_id not in _ex_factor_cache:
_ex_factor_cache[order_book_id] = None
def get_commission_margin(order_book_ids=None,
fields=None,
hedge_flag="speculation"):
"""获取期货保证金和手续费数据
:param order_book_ids: 期货合约, 支持 order_book_id 或 order_book_id list,
若不指定则默认获取所有合约 (Default value = None)
:param fields: str 或 list, 可选字段有： 'margin_type', 'long_margin_ratio', 'short_margin_ratio',
'commission_type', 'open_commission_ratio', 'close_commission_ratio',
'close_commission_today_ratio', 若不指定则默认获取所有字段 (Default value = None)
:param hedge_flag: str, 账户对冲类型, 可选字段为: 'speculation', 'hedge',
'arbitrage', 默认为'speculation', 目前仅支持'speculation' (Default value = "speculation")
:returns: pandas.DataFrame
"""
if order_book_ids:
order_book_ids = ensure_list_of_string(order_book_ids)
if fields is None:
fields = _FIELDS
else:
fields = ensure_list_of_string(fields, "fields")
check_items_in_container(fields, _FIELDS, "fields")
hedge_flag = ensure_string(hedge_flag, "hedge_flag")
if hedge_flag not in ["speculation", "hedge", "arbitrage"]:
raise ValueError("invalid hedge_flag: {}".format(hedge_flag))
ret = get_client().execute("futures.get_commission_margin", order_book_ids,
fields, hedge_flag)
return pd.DataFrame(ret)
def get_conversion_info(order_book_ids,
start_date=None,
end_date=None,
market="cn"):
"""获取转股变动信息
:param order_book_ids: 可转债ID，str or list
:param start_date: 开始日期，默认为None
:param end_date: 结束日期，默认为None
:param market: (Default value = "cn")
:return: pd.DataFrame
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
if start_date:
start_date = ensure_date_int(start_date)
if end_date:
end_date = ensure_date_int(end_date)
data = get_client().execute("convertible.get_conversion_info",
order_book_ids,
start_date,
end_date,
market=market)
if not data:
return
df = pd.DataFrame(data)
df.set_index(["order_book_id", "info_date"], inplace=True)
return df
def get_industry_mapping(source="citics", date=None, market="cn"):
"""获取行业分类列表
:param source: 分类来源，citics。citics: 中信, gildata: 聚源
:param market: (Default value = "cn")
:return: DataFrame
"""
source = ensure_string_in(source,
["sws", "citics", "gildata", "citics_2019"],
"source")
if date is None:
date = datetime.date.today()
date = ensure_date_int(date)
res = get_client().execute("get_industry_mapping_v2",
source,
date,
market=market)
if not res:
return
df = pd.DataFrame(res)
if source == "sws":
df.rename(columns=dict(zip(OTHER_COLUMNS, SHENWAN_COLUMNS)),
inplace=True)
columns = SHENWAN_COLUMNS
else:
columns = OTHER_COLUMNS
df = df.dropna().drop_duplicates()
df = df.sort_values(columns[::2]).reset_index(drop=True)
return df[columns]
