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_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_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 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_nav(order_book_ids, start_date=None, end_date=None, fields=None, expect_df=False, 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，例如：'acc_net_value', 'unit_net_value',
'subscribe_status', 'redeem_status', 'change_rate' (Default value = None)
:param expect_df: 返回 MultiIndex DataFrame (Default value = False)
:param market: (Default value = "cn")
:returns: DataFrame or Series or Panel
"""
order_book_ids = ensure_list_of_string(order_book_ids)
if len(order_book_ids) > 1:
ins = instruments(order_book_ids, market=market)
if len(set([i.accrued_daily for i in ins])) > 1:
raise RQDataError(
"ERROR: Only support single accrued type when getting nav at one time."
)
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)
for f in fields:
if f not in NAV_FIELDS:
raise ValueError("invalid field: {}".format(f))
else:
fields = NAV_FIELDS
result = get_client().execute(
"fund.get_nav", order_book_ids, start_date, end_date, fields, market=market
)
if not result:
return
result = pd.DataFrame(result)
if expect_df:
result.sort_values(["order_book_id", "datetime"], inplace=True)
result.set_index(["order_book_id", "datetime"], inplace=True)
result.reindex(columns=fields)
return result
result = result.set_index(["datetime", "order_book_id"])
result.reindex(columns=fields)
result = result.to_panel()
if len(order_book_ids) == 1:
result = result.minor_xs(order_book_ids[0])
if len(fields) == 1:
return result[fields[0]]
if len(order_book_ids) != 1 and len(fields) != 1:
warnings.warn("Panel is removed after pandas version 0.25.0."
" the default value of 'expect_df' will change to True in the future.")
return result
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_factor_return(
start_date,
end_date,
factors=None,
universe="whole_market",
method="implicit",
industry_mapping=True,
market="cn",
):
"""获取因子收益率数据
:param start_date: 开始日期（例如：‘2017-03-03’)
:param end_date: 结束日期（例如：‘2017-03-20’)
:param factors: 因子。默认获取全部因子的因子收益率
当 method 参数取值为'implicit' ，可返回全部因子（风格、行业、市场联动）的隐式因子收益率；
当 method 参数取值为'explicit' , 只返回风格因子的显式因子收益率。具体因子名称见说明文档 (Default value = None)
:param universe: 股票池。默认调用全市场收益率。可选沪深300（‘000300.XSHG’）、中证500（'000905.XSHG'）
、以及中证800（'000906.XSHG'） (Default value = "whole_market")
:param method: 计算方法。默认为'implicit'（隐式因子收益率），可选'explicit'（显式风格因子收益率) (Default value = "implicit")
:param market: 地区代码， 现在仅支持 'cn' (Default value = "cn")
:param industry_mapping(bool): 是否按 2014 年后的申万行业分类标 准计算行业收益率.默认为 True.
若取值为 False,则 2014 年前的行业 收益率按旧行业分类标准计算
:returns: pd.DataFrame. index 为日期，column 为因子字段名称。
Usage example::
# 获取介于2017-03-03 到 2017-03-20到隐式因子收益率数据
get_factor_return('2017-03-03', '2017-03-20')
"""
start_date, end_date = ensure_date_range(start_date, end_date)
if factors:
factors = ensure_list_of_string(factors)
method = ensure_string(method)
if method not in _METHOD_MAPPING:
raise ValueError(
"invalid method: {!r}, valid: explicit, implicit".format(method))
method = _METHOD_MAPPING[method]
if universe not in _UNIVERSE_MAPPING:
raise ValueError("invalid universe: {!r}, valid: {}".format(
universe, list(_UNIVERSE_MAPPING.keys())))
universe = _UNIVERSE_MAPPING[universe]
df = get_client().execute("get_factor_return",
start_date,
end_date,
factors,
universe,
method,
market=market,
industry_mapping=industry_mapping)
if not df:
return None
df = pd.DataFrame(df)
# convert to required format.
df = df.pivot(index="date", columns="factor")[universe]
df.sort_index(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 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_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 _ensure_fields(fields, fields_dict, stocks, funds, futures, spots, options, convertibles, indexes, repos):
has_dominant_id = True
all_fields = set(fields_dict["common"])
if futures:
all_fields.update(fields_dict["future"])
if stocks:
all_fields.update(fields_dict["stock"])
if funds:
all_fields.update(fields_dict["fund"])
if spots:
all_fields.update(fields_dict["spot"])
if options:
all_fields.update(fields_dict["option"])
if convertibles:
all_fields.update(fields_dict["convertible"])
if indexes:
all_fields.update(fields_dict["index"])
if repos:
all_fields.update(fields_dict["repo"])
if fields:
fields = ensure_list_of_string(fields, "fields")
fields_set = set(fields)
if len(fields_set) < len(fields):
warnings.warn("duplicated fields: %s" % [f for f in fields if fields.count(f) > 1])
fields = list(fields_set)
if 'dominant_id' in fields:
if len(fields) == 1:
raise ValueError("can't get dominant_id separately, please use futures.get_dominant")
fields.remove('dominant_id')
else:
has_dominant_id = False
check_items_in_container(fields, all_fields, "fields")
return fields, has_dominant_id
else:
return list(all_fields), has_dominant_id
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 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 get_stock_connect(order_book_ids, start_date=None, end_date=None, fields=None, expect_df=False):
"""获取"陆股通"的持股、持股比例
:param order_book_ids: 股票列表
:param start_date: 开始日期: 如'2017-03-17' (Default value = None)
:param end_date: 结束日期: 如'2018-03-16' (Default value = None)
:param fields: 默认为所有字段，可输入shares_holding或者holding_ratio (Default value = None)
:param expect_df: 返回 MultiIndex DataFrame (Default value = False)
:returns: 返回pandas.DataFrame or pandas.Panel
"""
if order_book_ids not in ("shanghai_connect", "shenzhen_connect", "all_connect"):
order_book_ids = ensure_order_book_ids(order_book_ids, type="CS")
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 ("shares_holding", "holding_ratio"):
raise ValueError("invalid field: {}".format(f))
else:
fields = ["shares_holding", "holding_ratio"]
data = get_client().execute("get_stock_connect", order_book_ids, start_date, end_date, fields)
if not data:
return None
df = pd.DataFrame(data, columns=["trading_date", "order_book_id"] + fields)
if not expect_df and not is_panel_removed:
df = df.set_index(["trading_date", "order_book_id"])
df = df.to_panel()
df.major_axis.name = None
df.minor_axis.name = None
if len(order_book_ids) == 1:
df = df.minor_xs(order_book_ids[0])
if len(fields) == 1:
df = df[fields[0]]
if len(order_book_ids) != 1 and len(fields) != 1:
warnings.warn("Panel is removed after pandas version 0.25.0."
" the default value of 'expect_df' will change to True in the future.")
return df
else:
df.sort_values(["order_book_id", "trading_date"], inplace=True)
df.set_index(["order_book_id", "trading_date"], inplace=True)
if expect_df:
return df
if len(order_book_ids) != 1 and len(fields) != 1:
raise_for_no_panel()
if len(order_book_ids) == 1:
df.reset_index(level=0, drop=True, inplace=True)
if len(fields) == 1:
df = df[fields[0]]
return df
else:
df = df.unstack(0)[fields[0]]
df.index.name = None
df.columns.name = None
return df
def get(order_book_ids, field_list=None, market="cn"):
order_book_ids = ensure_list_of_string(order_book_ids, "order_book_ids")
data = get_client().execute("fenji.get", order_book_ids, field_list,
market)
if not data:
return
_remake_decimal(data)
df = pd.DataFrame(data)
df.reindex(columns=sorted(df.columns))
return df
def get_split(order_book_id, market="cn"):
"""获取基金拆分信息
:param order_book_id: 基金代码 str or list of str
:param market: (Default value = "cn")
:returns: DataFrame
"""
order_book_ids = ensure_list_of_string(order_book_id)
data = get_client().execute("fund.get_split", order_book_ids, market=market)
data = pd.DataFrame(data, columns=["order_book_id", "split_ratio", "ex_dividend_date"])
data.set_index("ex_dividend_date", inplace=True)
return data.sort_index()
def get_snapshot(order_book_ids, fields=None, market="cn"):
"""获取基金的最新数据
:param order_book_ids: 基金代码，str 或 list of str
:param fields: str or list of str，例如："last_week_return", "subscribe_status", (Default value = None)
:param market: (Default value = "cn")
:returns: DataFrame or Series
"""
order_book_ids = ensure_list_of_string(order_book_ids)
if fields is not None:
fields = ensure_list_of_string(fields, "fields")
result = get_client().execute("fund.get_snapshot", order_book_ids, fields, market=market)
if not result:
return
df = pd.DataFrame(result).set_index("order_book_id")
df.sort_index(inplace=True)
if fields is not None:
return df[fields]
return df
def get_stock_connect_quota(connect=None, start_date=None, end_date=None, fields=None):
"""获取历史沪深港通额度日频数据
:param connect: 默认返回全部content ["sh_to_hk", "hk_to_sh", "sz_to_hk", "hk_to_sz"]
:param start_date: 默认为全部历史数据
:param end_date: 默认为最新日期
:param fields: 默认为所有字段 ['buy_turnover', 'sell_turnover', 'quota_balance', 'quota_balance_ratio']
:return:
"""
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')
start_date = ensure_date_int(start_date) if start_date else start_date
end_date = ensure_date_int(end_date) if end_date else end_date
if start_date and end_date and start_date > end_date:
raise ValueError("invalid date range: [{!r}, {!r}]".format(start_date, end_date))
data = get_client().execute(
"get_stock_connect_quota", connect=connect, start_date=start_date, end_date=end_date, fields=fields
)
if not data:
return None
res = pd.DataFrame(data)
res.set_index(['datetime', 'connect'], inplace=True)
res.sort_index(ascending=True, inplace=True)
return res
def instruments(order_book_ids, market="cn"):
"""获取基金详细信息
:param order_book_ids: 基金代码，str 或 list of str
:param market: (Default value = "cn")
:returns: Instrument object or list of Instrument object
取决于参数是一个 order_book_id 还是多个 order_book_id
"""
order_book_ids = ensure_list_of_string(order_book_ids)
if len(order_book_ids) == 1:
return _get_instrument(order_book_ids[0])
d = _all_instruments_dict(market)
return [d[i] for i in order_book_ids if i in d]
def get_current_news(n=None, start_time=None, end_time=None, channels=None):
"""获取新闻
:param n: 新闻条数, n 和 start_time/end_time 只能指定其一
:param start_time: 开始日期，默认为None,格式为%Y-%m-%d %H:%M:%S，如"2018-10-20 09:10:20"
:param end_time: 结束日期，默认为None,格式为%Y-%m-%d %H:%M:%S，如"2018-10-20 19:10:20"
:param channels: 新闻大类, 默认为None,返回每个大类n条新闻, 如 "global"，"forex", "commodity", "a-stock"
"""
if start_time is not None or end_time is not None:
try:
start_time = datetime.datetime.strptime(start_time,
"%Y-%m-%d %H:%M:%S")
except Exception:
raise ValueError(
'start_time should be str format like "%Y-%m-%d %H:%M:%S"')
try:
end_time = datetime.datetime.strptime(end_time,
"%Y-%m-%d %H:%M:%S")
except Exception:
raise ValueError(
'end_time should be str format like "%Y-%m-%d %H:%M:%S"')
start_time = datetime_to_int14(start_time)
end_time = datetime_to_int14(end_time)
if n is not None:
raise ValueError(
"please either specify parameter n, or specify both start_time and end_time"
)
n = 1200
elif n is None:
n = 1
else:
n = ensure_int(n, "n")
if n < 1 or n > 1200:
raise ValueError("n should be in [0, 1200]")
if channels is not None:
channels = ensure_list_of_string(channels)
check_items_in_container(channels,
["global", "forex", "a-stock", "commodity"],
"channels")
else:
channels = ["global", "forex", "a-stock", "commodity"]
data = get_client().execute("get_current_news", n, start_time, end_time,
channels)
if not data:
return
df = pd.DataFrame(data, columns=["channel", "datetime", "content"])
return df.set_index("channel")
def get_yield_curve(start_date=None, end_date=None, tenor=None, market="cn"):
"""获取国债收益率曲线
:param market: 地区代码, 如'cn', 'us' (Default value = "cn")
:param start_date: 开始日期 (Default value = "2013-01-04")
:param end_date: 结束日期 (Default value = "2014-01-04")
:param tenor: 类别, 如 OS, 1M, 3M, 1Y (Default value = None)
"""
start_date, end_date = ensure_date_range(start_date, end_date)
all_tenor = (
"0S",
"1M",
"2M",
"3M",
"6M",
"9M",
"1Y",
"2Y",
"3Y",
"4Y",
"5Y",
"6Y",
"7Y",
"8Y",
"9Y",
"10Y",
"15Y",
"20Y",
"30Y",
"40Y",
"50Y",
)
if tenor:
tenor = ensure_list_of_string(tenor, "tenor")
check_items_in_container(tenor, all_tenor, "tenor")
tenor = ensure_order(tenor, all_tenor)
df = get_client().execute("get_yield_curve",
start_date,
end_date,
tenor,
market=market)
if not df:
return
columns = ["trading_date"]
columns.extend(tenor or all_tenor)
df = pd.DataFrame(df, columns=columns)
df.set_index("trading_date", inplace=True)
return df.sort_index()
def get_factors(factors, start_date, end_date, market="cn"):
start_date, end_date = ensure_date_range(start_date, end_date)
factors = ensure_list_of_string(factors, "factors")
data = get_client().execute("econ.get_factors",
factors,
start_date,
end_date,
market=market)
if not data:
return
df = pd.DataFrame(data)
df = df.reindex(
columns=["factor", "info_date", "start_date", "end_date", "value"])
df.set_index(["factor", "info_date"], inplace=True)
return df
def get_amc(amc_ids=None, fields=None, market="cn"):
"""获取基金公司详情信息
:param amc_ids: 基金公司id或简称，默认为 None
:param fields: 可选参数。默认为所有字段。 (Default value = None)
:param market: (Default value = "cn")
:returns: DataFrame
"""
if fields is None:
fields = AMC_FIELDS
else:
fields = ensure_list_of_string(fields)
check_items_in_container(fields, AMC_FIELDS, "fields")
result = get_client().execute("fund.get_amc", market=market)
if amc_ids:
amc_ids = ensure_list_of_string(amc_ids)
amcs = tuple(amc_ids)
result = [i for i in result if i["amc_id"] in amc_ids or i["amc"].startswith(amcs)]
if not result:
return
return pd.DataFrame(result)[fields]
def get_dividend(order_book_id, market="cn"):
"""获取基金分红信息
:param order_book_id: 基金代码 str or list of str
:param market: (Default value = "cn")
:returns: DataFrame
"""
order_book_ids = ensure_list_of_string(order_book_id)
data = get_client().execute("fund.get_dividend", order_book_ids, market=market)
data = pd.DataFrame(
data,
columns=["order_book_id", "book_closure_date", "payable_date", "dividend_before_tax", "ex_dividend_date"],
)
data.set_index("ex_dividend_date", inplace=True)
return data.sort_index()
def history(
order_book_ids,
start_date="2015-05-21",
end_date="2016-05-21",
frequency="1d",
fields=None,
market="cn",
):
"""获取雪球历史舆情数据
:param order_book_ids: 股票代码或代码列表
:param start_date: 如 '2015-05-21', 必须在2015年4月23日之后 (Default value = "2015-05-21")
:param end_date: 如 '2016-05-21' (Default value = "2016-05-21")
:param frequency: 如 '1d' (Default value = "1d")
:param fields: 如 'new_comments', 'total_comments', 'new_followers',
'total_followers', 'sell_actions', 'buy_actions' (Default value = None)
:param market: 地区代码, 如 'cn' (Default value = "cn")
:returns: 返回pd.Panel或pd.DataFrame或pd.Series
"""
order_book_ids = ensure_order_book_ids(order_book_ids, market=market)
if fields:
fields = ensure_list_of_string(fields, "fields")
check_items_in_container(fields, FIELDS, "fields")
else:
fields = FIELDS
frequency = ensure_string(frequency, "frequency")
check_items_in_container([frequency], {"1d"}, "frequency")
start_date, end_date = ensure_date_range(start_date, end_date)
if start_date < 20150423:
raise ValueError("date out of range, start_date "
"cannot be earlier than 2015-04-23")
data = get_client().execute("xueqiu.history", order_book_ids, start_date,
end_date, fields, market)
if not data:
return
df = pd.DataFrame(data)
df = df.set_index(["date", "order_book_id"])
df.sort_index(inplace=True)
pl = df.to_panel()
if len(pl.minor_axis) == 1:
pl = pl.minor_xs(pl.minor_axis[0])
if len(fields) == 1:
pl = pl[fields[0]]
return pl
def _ensure_fields(fields, fields_dict, stocks, funds, futures, futures888, spots, options, convertibles, indexes,
repos):
has_dominant_id = False
future_only = futures and not any([stocks, funds, spots, options, convertibles, indexes, repos])
all_fields = set(fields_dict["common"])
if futures:
all_fields.update(fields_dict["future"])
if stocks:
all_fields.update(fields_dict["stock"])
if funds:
all_fields.update(fields_dict["fund"])
if spots:
all_fields.update(fields_dict["spot"])
if options:
all_fields.update(fields_dict["option"])
if convertibles:
all_fields.update(fields_dict["convertible"])
if indexes:
all_fields.update(fields_dict["index"])
if repos:
all_fields.update(fields_dict["repo"])
if future_only and futures888 and len(futures) == len(futures888) and not fields:
has_dominant_id = True
if fields:
fields = ensure_list_of_string(fields, "fields")
fields_set = set(fields)
if len(fields_set) < len(fields):
warnings.warn("duplicated fields: %s" % [f for f in fields if fields.count(f) > 1])
fields = list(fields_set)
# 只有期货类型
if 'dominant_id' in fields:
fields.remove("dominant_id")
if not fields:
raise ValueError("can't get dominant_id separately, please use futures.get_dominant")
if futures888:
has_dominant_id = True
else:
warnings.warn(
"only if one of the order_book_id is future and contains 88/888/99/889 can the dominant_id be selected in fields")
check_items_in_container(fields, all_fields, "fields")
return fields, has_dominant_id
else:
return list(all_fields), has_dominant_id
def get_update_status(categories):
"""
获取数据最新日期
:param categories: str or list or str, 数据类型，支持类型有:
stock_1d: 股票日线
stock_1m: 股票分钟线
future_1d: 期货日线
future_1m: 期货分钟线
index_1d：指数日线
index_1m：指数分钟线
:return datetime.datetime or dict(category=datetime.datetime)
"""
categories = ensure_list_of_string(categories, "categories")
check_items_in_container(categories, _CHECK_CATEGORIES, "categories")
ret = get_client().execute("get_update_status", categories)
if len(categories) == 1:
return ret[0]["date"]
return {r["category"]: r["date"] for r in ret}
def get_manager(order_book_ids, expect_df=False, market="cn"):
"""获取基金经理信息
:param order_book_ids: 基金代码，str 或 list of str
:param market: (Default value = "cn")
:param expect_df: 返回 MultiIndex DataFrame (Default value = False)
:returns: DataFrame or Panel
"""
order_book_ids = ensure_list_of_string(order_book_ids)
docs = get_client().execute("fund.get_manager", order_book_ids, market=market)
if not docs:
return
if expect_df:
df = pd.DataFrame(docs)
df.sort_values(["order_book_id", "start_date"], inplace=True)
df.set_index(["order_book_id", "id"], inplace=True)
fields = ["name", "days", "start_date", "end_date", "return"]
return df[fields]
data = {}
for doc in docs:
data.setdefault(doc["order_book_id"], []).append(doc)
fields = ["name", "id", "days", "start_date", "end_date", "return"]
array = np.full((len(fields), max([len(v) for v in data.values()]), len(order_book_ids)), None)
for i in range(max([len(v) for v in data.values()])):
for j, order_book_id in enumerate(order_book_ids):
try:
doc = data.setdefault(order_book_id, [])[i]
except IndexError:
doc = None
for k, f in enumerate(fields):
v = None if doc is None else doc[f]
array[k, i, j] = v
result = pd.Panel(data=array, items=fields, minor_axis=order_book_ids)
if len(order_book_ids) == 1:
return result.minor_xs(order_book_ids[0])
warnings.warn("Panel is removed after pandas version 0.25.0."
" the default value of 'expect_df' will change to True in the future.")
return result
def get_credit_quality(order_book_ids, date=None, market="cn"):
"""获取基金信用风险数据信息
:param order_book_ids: 基金order_book_id, str or list
:param date: 交易日期，默认返回所有
:param market: (Default value = "cn")
:returns: DataFrame
"""
order_book_ids = ensure_list_of_string(order_book_ids)
if date:
date = ensure_date_int(date)
result = get_client().execute("fund.get_credit_quality", order_book_ids, date, market=market)
if not result:
return
df = pd.DataFrame(result)
df.sort_values(["order_book_id", "date", "t_type", "credit_rating"], inplace=True)
df.set_index(["order_book_id", "date"], inplace=True)
return df
def get_holdings(order_book_id, date=None, market="cn", **kwargs):
"""获取距离指定日期最近发布的基金持仓信息
:param order_book_id: 基金代码 str
: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 = ensure_date_int(date)
start_date = end_date = None
else:
if "start_date" in kwargs and "end_date" in kwargs:
start_date = ensure_date_int(kwargs.pop("start_date"))
end_date = ensure_date_int(kwargs.pop("end_date"))
elif "start_date" in kwargs or "end_date" in kwargs:
raise ValueError('please ensure start_date and end_date exist')
else:
start_date = end_date = None
if kwargs:
raise ValueError('unknown kwargs: {}'.format(kwargs))
df = get_client().execute("fund.get_holdings_v3", order_book_id, date, start_date, end_date, market=market)
if not df:
return
df = pd.DataFrame(data=df)
fields = ["order_book_id", "type", "weight", "shares", "market_value", "symbol"]
if "category" in df.columns:
df.category = df.category.map(CATEGORY_MAP)
fields += ["category"]
if "region" in df.columns:
fields += ["region"]
df.sort_values(["fund_id", "date", "type", "order_book_id"], inplace=True)
df.set_index(["fund_id", "date"], inplace=True)
return df[fields]
