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 is_suspended(order_book_ids, start_date=None, end_date=None):
"""获取停牌信息
:param order_book_ids: 可转债ID
:param start_date: 开始日期, 如'2013-01-04' (Default value = None)
:param end_date: 结束日期，如'2014-01-04' (Default value = None)
:returns: DataFrame
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
if len(order_book_ids) == 1:
instrument = instruments(order_book_ids[0], market="cn")
start_date, end_date = ensure_dates_base_on_listed_date(
instrument, start_date, end_date, "cn")
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="cn"))
df = pd.DataFrame(data=False, columns=order_book_ids, index=trading_dates)
data = get_client().execute("convertible.is_suspended",
order_book_ids,
start_date,
end_date,
market="cn")
for (order_book_id, date) in data:
date = to_datetime(date)
df.at[date, order_book_id] = True
return df
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_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_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 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_capital_flow(order_book_ids,
start_date=None,
end_date=None,
frequency="1d",
market="cn"):
"""获取资金流入流出数据
:param order_book_ids: 股票代码or股票代码列表, 如'000001.XSHE'
:param start_date: 开始日期
:param end_date: 结束日期
:param frequency: 默认为日线。日线使用 '1d', 分钟线 '1m' 快照 'tick' (Default value = "1d"),
:param market: (Default value = "cn")
:returns: pandas.DataFrame or None
"""
ensure_string_in(frequency, ("1d", "1m", "tick"), "frequency")
if frequency == "tick":
return get_capital_flow_tickbar(order_book_ids, start_date, end_date,
TICKBAR_FIELDS, market)
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
if frequency == "1d":
return get_capital_flow_daybar(order_book_ids, start_date, end_date,
DAYBAR_FIELDS, 1, market)
return get_capital_flow_minbar(order_book_ids, start_date, end_date,
MINBAR_FIELDS, 1, market)
def get_instrument_industry(order_book_ids,
source='sws',
level=1,
date=None,
market="cn"):
"""获取股票对应的行业
:param order_book_ids: 股票列表，如['000001.XSHE', '000002.XSHE']
:param source: 分类来源。sws: 申万, citics: 中信, gildata: 聚源
:param date: 如 '2015-01-07' (Default value = None)
:param level: (Default value = 1)
:param market: (Default value = "cn")
:returns: code, name
返回输入日期最近交易日的股票对应行业
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
source = ensure_string_in(source, ["sws", "citics", "gildata"], "source")
check_items_in_container(level, [0, 1, 2, 3], 'level')
date = ensure_date_or_today_int(date)
r = get_client().execute("get_instrument_industry",
order_book_ids,
source,
level,
date,
market=market)
if not r:
return
return pd.DataFrame(r).set_index("order_book_id")
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_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_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_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_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 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 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_open_auction_info(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")
:returns: 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, datetime.timedelta(days=0))
history_permission_denied = realtime_permission_denied = False
try:
# obid add prefix 'OA_'
data = get_client().execute("get_open_auction_info_daybar", ["OA_" + obid for obid in order_book_ids],
start_date, end_date, OA_FIELDS + ["datetime", "date"], market=market)
except PermissionDenied:
data = []
history_permission_denied = True
today = today_int()
prev_trading_date = date_to_int8(get_previous_trading_date(today, market=market))
if data:
data = [(obid[3:], {k: np.frombuffer(*v) for k, v in d.items()}) for obid, d in data]
df = convert_bar_to_multi_df(data, 'datetime', OA_FIELDS + ["date"], int17_to_datetime_v, default=0.0)
if df is None:
history_latest_date = prev_trading_date
else:
history_latest_date = df["date"].max()
del df["date"]
else:
df = None
history_latest_date = prev_trading_date
if history_latest_date >= end_date or start_date > today or history_latest_date >= today or end_date < today:
return df
try:
live_df = get_today_open_auction(order_book_ids, today, market=market)
except PermissionDenied:
live_df = None
realtime_permission_denied = True
if history_permission_denied and realtime_permission_denied:
raise PermissionDenied("get_open_auction_info")
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 shenwan_instrument_industry(order_book_ids,
date=None,
level=1,
expect_df=False,
market="cn"):
"""获取股票对应的申万行业
:param order_book_ids: 股票列表，如['000001.XSHE', '000002.XSHE']
:param date: 如 '2015-01-07' (Default value = None)
:param level: (Default value = 1)
:param expect_df: 返回 DataFrame，默认为 False
:param market: (Default value = "cn")
:returns: code, name
返回输入日期最近交易日的股票对应申万行业
"""
if level not in [0, 1, 2, 3]:
raise ValueError("level should be in 0,1,2,3")
order_book_ids = ensure_order_book_ids(order_book_ids)
if not date:
date = datetime.date.today()
date = ensure_date_int(date)
r = get_client().execute("shenwan_instrument_industry",
order_book_ids,
date,
level,
market=market)
if not r:
return
if len(order_book_ids) == 1 and not expect_df:
r = r[0]
if level != 0:
return r[LEVEL_MAP[level][0]], r[LEVEL_MAP[level][1]]
else:
return (
r["index_code"],
r["index_name"],
r["second_index_code"],
r["second_index_name"],
r["third_index_code"],
r["third_index_name"],
)
df = pd.DataFrame(r).set_index("order_book_id")
if level != 0 and level != 1:
df.rename(columns=dict(zip(LEVEL_MAP[level], LEVEL_MAP[1])),
inplace=True)
return df
def get_private_placement(order_book_ids,
start_date=None,
end_date=None,
progress="complete",
market="cn"):
"""获取定增数据
:param order_book_ids: 合约代码
:param start_date: 开始日期，默认为None
:param end_date: 结束日期，默认为None
:param progress: 是否已完成定增，默认为complete。可选参数["complete", "incomplete", "all"]
:param market: (Default value = "cn")
:return:
"""
order_book_ids = ensure_order_book_ids(order_book_ids, market=market)
if start_date and end_date:
start_date, end_date = ensure_date_range(start_date, end_date)
elif start_date:
start_date = ensure_date_int(start_date)
elif end_date:
end_date = ensure_date_int(end_date)
ensure_string_in(progress, ["complete", "incomplete", "all"], "progress")
data = get_client().execute("get_private_placement",
order_book_ids,
start_date,
end_date,
progress,
market=market)
if not data:
return
progress_map = {
10: "董事会预案",
20: "股东大会通过",
21: "国资委通过",
22: "发审委通过",
23: "证监会通过",
29: "实施中",
30: "实施完成",
40: "国资委否决",
41: "股东大会否决",
42: "证监会否决",
43: "发审委否决",
50: "延期实施",
60: "停止实施",
70: "暂缓发行"
}
issue_type_map = {21: "非公开发行", 23: "非公开发行配套融资"}
df = pd.DataFrame(data)
df["progress"] = df["progress"].map(progress_map)
df["issue_type"] = df["issue_type"].map(issue_type_map)
df.set_index(["order_book_id", "initial_info_date"], inplace=True)
return df
def get_greeks(order_book_ids,
start_date=None,
end_date=None,
fields=None,
model='implied_forward',
market="cn"):
"""获取指定股票期权的隐含波动率iv， 以及5个希腊字母数值(delta, gamma, bega, theta, rho)
:param order_book_ids: 股票 order_book_id or order_book_id list
:param start_date: 开始日期, 必要参数
:param end_date: 结束日期；默认为今天
:param fields: str或list类型. 默认为None, 返回所有fields.
:param model: str类型， last: 代表用每日close价格， implied_forward 代表用隐含风险收益率计算
:param market: 默认值为"cn"
"""
order_book_ids = ensure_order_book_ids(order_book_ids, market=market)
check_items_in_container(model, ['implied_forward', 'last'], 'model')
if start_date is not None:
start_date = ensure_date_int(start_date)
else:
raise ValueError('start_date is expected')
if end_date is not None:
end_date = ensure_date_int(end_date)
else:
end_date = ensure_date_int(datetime.datetime.now().date())
if end_date < start_date:
raise ValueError("invalid date range: [{!r}, {!r}]".format(
start_date, end_date))
if fields is None:
fields = VALID_GREEKS_FIELDS
else:
check_items_in_container(fields, VALID_GREEKS_FIELDS, 'Greeks')
data = get_client().execute("options.get_greeks",
order_book_ids,
start_date,
end_date,
fields,
model,
market=market)
if not data:
return None
df = pd.DataFrame(data)
df.set_index(["order_book_id", "trading_date"], inplace=True)
df.sort_index(inplace=True)
return df[fields]
def get_instrument_industry(order_book_ids,
source='citics',
level=1,
date=None,
market="cn"):
"""获取股票对应的行业
:param order_book_ids: 股票列表，如['000001.XSHE', '000002.XSHE']
:param source: 分类来源。citics 以及 citics_2019: 中信, gildata: 聚源
:param date: 如 '2015-01-07' (Default value = None)
:param level: (Default value = 1)
:param market: (Default value = "cn")
:returns: code, name
返回输入日期最近交易日的股票对应行业
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
source = ensure_string_in(source,
["sws", "citics", "gildata", "citics_2019"],
"source")
if source == "citics_2019":
check_items_in_container(level, [0, 1, 2, 3, "citics_sector"], 'level')
else:
check_items_in_container(level, [0, 1, 2, 3], 'level')
date = ensure_date_or_today_int(date)
r = get_client().execute("get_instrument_industry",
order_book_ids,
source,
level,
date,
market=market)
if not r:
return
res = [i['order_book_id'] for i in r]
if source == "citics_2019" and level == "citics_sector":
# is_special industry是否传入的是风格版块，产业板块和上下游产业版块
from rqdatac.services import basic
res_list = basic.instruments(res)
date = to_date_str(date)
for index, order_book in enumerate(res_list):
if order_book.de_listed_date == "0000-00-00" or order_book.de_listed_date is None:
order_book.de_listed_date = "2099-12-31"
if not order_book.listed_date <= date <= order_book.de_listed_date:
r.pop(index)
return pd.DataFrame(r).set_index("order_book_id")
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 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_order_book_ids(order_book_ids)
all_dict = _all_instruments_dict(market)
if len(order_book_ids) == 1:
try:
return all_dict[order_book_ids[0]]
except KeyError:
warnings.warn(
'unknown convertible order_book_id: {}'.format(order_book_ids))
return
all_list = (all_dict.get(i) for i in order_book_ids)
return [i for i in all_list if i]
def zx_instrument_industry(order_book_ids,
date=None,
level=1,
expect_df=False):
"""获取股票对应的中信行业
:param order_book_ids: 股票列表，如['000001.XSHE', '000002.XSHE']
:param date: 如 '2015-01-07' (Default value = None)
:param level: (Default value = 1)
:param expect_df: 返回 DataFrame，默认为 False
:returns: code, name
返回输入日期最近交易日的股票对应中信行业
"""
if level not in [0, 1, 2, 3]:
raise ValueError("level should be in 0,1,2,3")
order_book_ids = ensure_order_book_ids(order_book_ids)
if not date:
date = datetime.date.today()
date = ensure_date_int(date)
r = get_client().execute("zx_instrument_industry", order_book_ids, date,
level)
if not r:
return
if len(order_book_ids) == 1 and not expect_df:
r = r[0]
if level != 0:
return [
r[ZX_LEVEL_MAP[level]],
]
else:
return [
r["first_industry_name"],
r["second_industry_name"],
r["third_industry_name"],
]
df = pd.DataFrame(r).set_index("order_book_id")
return df
def get_specific_return(order_book_ids, start_date, end_date):
""" 获取个股特异收益率
:param order_book_ids str or [list of str] 证券代码（例如：‘600705.XSHG’）
:param start_date str 开始日期（例如：‘2017-03-03’）
:param end_date str 结束日期（例如：‘2017-03-20’）
:return: pandas.DataFrame，其中 index 为date, column 为 order_book_ids。
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
df = get_client().execute('get_specific_return', order_book_ids,
start_date, end_date)
if not df:
return
df = pd.DataFrame(df)
df = df.pivot(index='date',
columns='order_book_id',
values="specific_return").sort_index()
return df
def jy_instrument_industry(order_book_ids,
date=None,
level=1,
expect_df=False,
market="cn"):
"""获取股票对应的聚源行业
:param order_book_ids: 股票列表，如['000001.XSHE', '000002.XSHE']
:param date: 如 '2015-01-07' (Default value = None)
:param level: 聚源等级，0, 1, 2, 3, 'customized' (Default value = 1)
:param expect_df: 返回 DataFrame，默认为 False
:param market: (Default value = "cn")
:returns: code, name
返回输入日期最近交易日的股票对应聚源行业以及对应的聚源等级
"""
if level not in (0, 1, 2, 3, "customized"):
raise ValueError("level should in 0, 1, 2, 3, 'customized'")
order_book_ids = ensure_order_book_ids(order_book_ids, market=market)
if not date:
date = ensure_date_int(
get_previous_trading_date(datetime.date.today(), market=market))
else:
date = ensure_date_int(date)
df = get_client().execute("jy_instrument_industry",
order_book_ids,
date,
level,
market=market)
if not df:
return
if len(order_book_ids) == 1 and not expect_df:
r = df[0]
if level == 0:
return r["first_industry_name"], r["second_industry_name"], r[
"third_industry_name"]
return r["industry_name"]
return pd.DataFrame(df).set_index("order_book_id")
def get_specific_risk(order_book_ids, start_date, end_date, horizon='daily'):
""" 获取个股特异方差
:param order_book_ids str or [list of str] 证券代码（例如：‘600705.XSHG’）
:param start_date str 开始日期（例如：‘2017-03-03’）
:param end_date str 结束日期（例如：‘2017-03-20’）
:param horizon str 预测期限。默认为日度（'daily'），可选月度（‘monthly’）或季度（'quarterly'）
:return: pandas.DataFrame，其中 index 为date, column 为 order_book_ids。
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
ensure_string_in(horizon, HORIZON_CONTAINER, 'horizon')
df = get_client().execute('get_specific_risk', order_book_ids, start_date,
end_date, horizon)
if not df:
return
df = pd.DataFrame(df)
df = df.pivot(index="date",
columns="order_book_id",
values="specific_risk").sort_index()
return df
def get_allotment(order_book_ids, start_date=None, end_date=None, fields=None, market="cn"):
"""获取配股信息
:param order_book_ids: 股票名称
:param start_date: 开始日期, 如'1991-01-01' (Default value = 1991-01-01)
:param end_date: 结束日期，如'2014-01-04' (Default value = None)
:param market: 地区代码，如'cn' (Default value = "cn")
:returns: 返回一个DataFrame
'order_book_id': 股票合约代码
'declaration_announcement_date': 首次信息发布日期
'proportion': 配股比例(每一股对应的配股比例)
'allotted_proportion': 实际配股比例(每一股对应的配股比例)
'allotted_shares': 实际配股数量
'allotment_price': 每股配股价格
'book_closure_date': 股权登记日
'ex_right_date': 除权除息日
"""
order_book_ids = ensure_order_book_ids(order_book_ids, market=market)
if start_date:
start_date = ensure_date_int(start_date)
if end_date:
end_date = ensure_date_int(end_date)
if fields:
fields = ensure_list_of_string(fields, "fields")
check_items_in_container(fields, allotment_fields, "fields")
else:
fields = allotment_fields
all_allotment = get_client().execute("get_allotment", order_book_ids, fields, start_date, end_date, market=market)
if not all_allotment:
return
df = pd.DataFrame(all_allotment)
df.set_index(["order_book_id", "declaration_announcement_date"], inplace=True)
df.sort_index(inplace=True)
df = df[fields]
return df
def get_dividend(order_book_ids,
start_date=None,
end_date=None,
adjusted=False,
market="cn"):
"""获取分红信息
:param order_book_ids: 股票 order_book_id or order_book_id list
:param start_date: 开始日期，默认为股票上市日期
:param end_date: 结束日期，默认为今天
:param adjusted: deprecated
:param market: (Default value = "cn")
"""
if adjusted:
warnings.warn("get_dividend adjusted = `True` is not supported yet. "
"The default value is `False` now.")
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)
data = get_client().execute("get_dividend",
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("declaration_announcement_date", inplace=True)
else:
df.set_index(["order_book_id", "declaration_announcement_date"],
inplace=True)
return df.sort_index()
def get_index_factor_exposure(order_book_ids,
start_date=None,
end_date=None,
factors=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 factors: 如'yield', 'beta', 'volatility' (Default value = None)
:param market: 地区代码, 如'cn' (Default value = "cn")
"""
try:
order_book_ids = ensure_order_book_ids(order_book_ids, type="INDX")
except ValueError:
return
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, exposure_factors, "factors")
results = get_client().execute("get_index_factor_exposure",
order_book_ids,
start_date,
end_date,
factors,
market=market)
if not results:
return None
df = pd.DataFrame.from_records(results, index=['date', 'order_book_id'])
df.sort_index(inplace=True)
return df
def get_stock_beta(order_book_ids,
start_date,
end_date,
benchmark="000300.XSHG",
market="cn"):
"""获取个股相对于基准的贝塔
:param order_book_ids: 证券代码（例如：‘600705.XSHG’）
:param start_date: 开始日期（例如：‘2017-03-03’)
:param end_date: 结束日期（例如：‘2017-03-20’）
:param benchmark: 基准指数。默认为沪深300（‘000300.XSHG’）
可选上证50（'000016.XSHG'）、中证500（'000905.XSHG'）、
中证800（'000906.XSHG'）以及中证全指（'000985.XSHG'） (Default value = "000300.XSHG")
:param market: (Default value = "cn")
:returns: pandas.DataFrame，index 为日期，column 为个股的 order_book_id
"""
order_book_ids = ensure_order_book_ids(order_book_ids)
start_date, end_date = ensure_date_range(start_date, end_date)
all_benchmark = ("000300.XSHG", "000016.XSHG", "000905.XSHG",
"000906.XSHG", "000985.XSHG")
benchmark = ensure_string(benchmark, "benchmark")
check_items_in_container(benchmark, all_benchmark, "benchmark")
benchmark = benchmark.replace(".", "_")
df = get_client().execute("get_stock_beta",
order_book_ids,
start_date,
end_date,
benchmark,
market=market)
if not df:
return
df = pd.DataFrame(df)
df = df.pivot(index="date", columns="order_book_id",
values=benchmark).sort_index()
return df
