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 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 _is_st_stock(order_book_id, date=None, market="cn"):
"""判断股票在给定日期是否是ST股
:param order_book_id: 股票id
:param date: (Default value = None)
:param market: (Default value = "cn")
:returns: True or False
"""
order_book_id = ensure_order_book_id(order_book_id, type="CS", market=market)
date = ensure_date_or_today_int(date)
df = is_st_stock(order_book_id, start_date=date, end_date=date, market=market)
if df is None or df.empty:
return False
else:
return df[order_book_id][0]
def index_components(order_book_id,
date=None,
start_date=None,
end_date=None,
market="cn"):
"""获取指数成分
:param order_book_id: 指数 id
:param date: 指定日期；如不指定，返回最近一个交易日的数据
:param start_date: 指定开始日期，不能和date同时指定
:param end_date: 指定结束日期, 需和start_date同时指定并且应当不小于开始日期
:param market: (Default value = "cn")
:returns list or dict
"""
order_book_id = ensure_order_book_id(order_book_id)
if date and (start_date or end_date):
raise ValueError(
"date cannot be input together with start_date or end_date")
elif (start_date and not end_date) or (end_date and not start_date):
raise ValueError("start_date and end_date need to be applied together")
if start_date:
start_date, end_date = ensure_date_range(start_date, end_date)
trading_dates = get_trading_dates_in_type(start_date,
end_date,
expect_type="int")
if not trading_dates:
return
data = get_client().execute("index_components_v2",
order_book_id,
trading_dates[0],
trading_dates[-1],
market=market)
if not data:
return
data = {d["trade_date"]: d["component_ids"] for d in data}
dates = sorted(data.keys())
for trading_date in trading_dates:
if trading_date not in data:
position = bisect.bisect_left(dates, trading_date) - 1
data[trading_date] = data[dates[position]]
return {int8_to_datetime(i): data[i] for i in trading_dates}
if date:
date = ensure_date_int(date)
return get_client().execute("index_components",
order_book_id,
date,
market=market)
def data(order_book_id,
start_date=None,
end_date=None,
frequency="1d",
fields=None):
"""获取天猫电商销售额数据
:param order_book_id: 股票名
:param start_date: 开始日期，默认为结束日期前一个月, 必须在2016年6月30日之后 (Default value = None)
:param end_date: 结束日期 (Default value = None)
:param frequency: 如'1d', '1M' (Default value = "1d")
:param fields: 如'sales' (Default value = None)
:returns: 返回DataFrame
"""
order_book_id = ensure_order_book_id(order_book_id)
if not end_date:
end_date = datetime.date.today()
if not start_date:
start_date = end_date - datetime.timedelta(days=30)
end_date = to_datetime(end_date)
start_date = to_datetime(start_date)
if start_date < datetime.datetime(2016, 6, 30):
raise ValueError("start_date cannot be earlier than 2016-06-30")
if start_date > end_date:
raise ValueError()
ensure_string(frequency, "frequency")
check_items_in_container([frequency], {"1d", "1M"}, "frequency")
if fields is None:
fields = "sales"
else:
fields = ensure_string(fields, "fields")
check_items_in_container(fields, ["sales"], "fields")
data = get_client().execute("tmall.data", order_book_id, start_date,
end_date, frequency)
if not data:
return
df = pd.DataFrame(data)
df = df.set_index("date")
df.sort_index(inplace=True)
df.columns = ["sales"]
return df
def index_weights(order_book_id, date=None, market="cn"):
"""获取指数的权重
:param order_book_id: 如'000300.XSHG'和'000905.XSHG'
:param market: 地区代码, 如 'cn' (Default value = "cn")
:param date: 指定日期；如不指定，返回最近一个交易日的
:returns: 返回输入日期最近交易日该指数的权重
"""
index_name = ensure_order_book_id(order_book_id)
if date:
date = ensure_date_int(date)
data = get_client().execute("index_weights", index_name, date, market=market)
if not data:
return None
s = pd.Series({d["order_book_id"]: d["weight"] for d in data})
s.index.name = "order_book_id"
return s
def real_cash_flow(order_book_id, date=None, market="cn"):
"""获取现金流信息
:param order_book_id: 可转债ID str
:param date: 日期，返回该日前已经发生的所有现金流，默认返回所有
:param market: (Default value = "cn")
:return: pd.DataFrame
"""
order_book_id = ensure_order_book_id(order_book_id)
if date:
date = ensure_date_int(date)
data = get_client().execute("convertible.real_cash_flow",
order_book_id,
date,
market=market)
if not data:
return
df = pd.DataFrame(data)
df.set_index(["order_book_id", "payment_date"], inplace=True)
return df
def get_share_transformation(predecessor=None, market="cn"):
"""
获取转股信息
:param predecessor: 换股前的股票代码。默认为空，返回所有转股信息
:param market: (Default value = "cn")
:return pd.DataFrame
"""
if predecessor:
predecessor = ensure_order_book_id(predecessor)
data = get_client().execute("get_share_transformation",
predecessor,
market=market)
if not data:
return
columns = [
"predecessor", "successor", "effective_date", "share_conversion_ratio",
"predecessor_delisted", "discretionary_execution",
"predecessor_delisted_date", "event"
]
df = pd.DataFrame(data, columns=columns)
df = df.sort_values('predecessor').reset_index(drop=True)
return df
def get_cash_flow(order_book_id, start_date=None, end_date=None, market="cn"):
"""获取现金流信息
:param order_book_id: 可转债ID str
:param start_date: 开始日期，默认为None
:param end_date: 结束日期，默认为None
:param market: (Default value = "cn")
:return: pd.DataFrame
"""
order_book_id = ensure_order_book_id(order_book_id)
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_cash_flow",
order_book_id,
start_date,
end_date,
market=market)
if not data:
return
df = pd.DataFrame(data)
df.set_index(["order_book_id", "payment_date"], inplace=True)
return df
def current_performance(
order_book_id, info_date=None, quarter=None, interval="1q", fields=None, market="cn"
):
"""获取A股快报
:param order_book_id: 股票代码, 如'000001.XSHE'
:param info_date: 发布日期, 如'20180501', 默认为最近的交易日 (Default value = None)
:param quarter: 发布季度, 如'2018q1' (Default value = None)
:param interval: 数据区间， 发布日期, 如'2y', '4q' (Default value = "1q")
:param fields: str 或 list 类型. 默认为 None, 返回所有字段 (Default value = None)
:param market: 地区代码, 如'cn' (Default value = "cn")
:returns: pd.DataFrame
"""
order_book_id = ensure_order_book_id(order_book_id, market=market)
end_date = None
if info_date:
info_date = ensure_date_int(info_date)
elif quarter:
splited = quarter.lower().split("q")
if len(quarter) != 6 or len(splited) != 2:
raise ValueError(
"invalid argument {}: {}, valid parameter: {}".format(
"quarter", quarter, "string format like '2016q1'"
)
)
year, quarter = int(splited[0]), int(splited[1])
if not 1 <= quarter <= 4:
raise ValueError(
"invalid argument {}: {}, valid parameter: {}".format(
"quarter", quarter, "quarter should be in [1, 4]"
)
)
month, day = QUARTER_DATE_MAP[quarter]
end_date = ensure_date_int(datetime.datetime(year, month, day))
else:
info_date = ensure_date_int(datetime.date.today())
ensure_string(interval, "interval")
if interval[-1] not in ("y", "q", "Y", "Q"):
raise ValueError(
"invalid argument {}: {}, valid parameter: {}".format(
"interval", interval, "interval unit should be q(quarter) or y(year)"
)
)
try:
int(interval[:-1])
except ValueError:
raise ValueError(
"invalid argument {}: {}, valid parameter: {}".format(
"interval", interval, "string like 4q, 2y"
)
)
interval = interval.lower()
if fields is not None:
fields = ensure_list_of_string(fields, "fields")
check_items_in_container(fields, PERFORMANCE_FIELDS, "fields")
else:
fields = PERFORMANCE_FIELDS
data = get_client().execute(
"current_performance", order_book_id, info_date, end_date, fields, market=market
)
if not data:
return
df = pd.DataFrame(data)
sort_field = "info_date" if info_date else "end_date"
df.sort_values(by=[sort_field, "mark"], ascending=[False, True], inplace=True)
df.drop_duplicates(subset="end_date", keep="first", inplace=True)
num = int(interval[:-1])
unit = interval[-1]
if unit == "y":
latest_month = df.loc[0, "end_date"].month
df["month"] = df.end_date.apply(lambda x: x.month)
df = df[df.month == latest_month]
df.reset_index(drop=True, inplace=True)
return df.loc[: num - 1, ["end_date", "info_date"] + fields]
def get_factor(order_book_ids,
factor,
start_date=None,
end_date=None,
universe=None,
expect_df=False,
**kwargs):
"""获取因子
:param order_book_ids: 股票代码或代码列表
:param factor: 如 'total_income'
:param date: 如 date='2015-01-05', 默认为前一交易日
:param start_date: 开始日期'2015-01-05', 默认为前一交易日, 最小起始日期为'2000-01-04'
:param end_date: 结束日期
:param universe: 股票池，默认为全A股
:param expect_df: 返回 MultiIndex DataFrame (Default value = False)
:returns: pd.DataFrame
"""
order_book_ids = ensure_order_book_ids(order_book_ids, type="CS")
order_book_ids = list(set(order_book_ids))
factor = ensure_list_of_string(factor)
factor = list(OrderedDict.fromkeys(factor))
if start_date and end_date:
start_date, end_date = ensure_date_range(start_date, end_date,
datetime.timedelta(days=15))
if start_date < 20000104:
warnings.warn(
"start_date is earlier than 2000-01-04, adjusted to 2000-01-04"
)
start_date = 20000104
elif start_date:
raise ValueError("Expect end_date")
elif end_date:
raise ValueError("Expect start_date")
else:
date = kwargs.pop("date", None)
date = ensure_date_int(
date or get_previous_trading_date(datetime.date.today()))
start_date = end_date = date
if kwargs:
raise ValueError('unknown kwargs: {}'.format(kwargs))
if universe is not None:
universe = ensure_string(universe, "universe")
if universe != "all":
universe = ensure_order_book_id(universe, type="INDX")
from rqdatac import index_components
allowed_order_book_ids = set(
index_components(universe, date=end_date) or [])
not_permit_order_book_ids = [
order_book_id for order_book_id in order_book_ids
if order_book_id not in allowed_order_book_ids
]
if not_permit_order_book_ids:
warnings.warn(
"%s not in universe pool, value of those order_book_ids will always be NaN"
% not_permit_order_book_ids)
data = get_client().execute("get_factor_from_store",
order_book_ids,
factor,
start_date,
end_date,
universe=universe)
if not data:
return
factor_value_length = len(data[0][2])
if factor_value_length == 0:
return
dates = pd.to_datetime(get_trading_dates(start_date, end_date))
if len(dates) > factor_value_length:
_get_factor_warning_msg(dates[factor_value_length], dates[-1])
dates = dates[0:factor_value_length]
if expect_df or len(factor) > 1:
order_book_id_index_map = {o: i for i, o in enumerate(order_book_ids)}
factor_index_map = {f: i for i, f in enumerate(factor)}
arr = np.full((len(order_book_ids) * len(dates), len(factor)), np.nan)
for order_book_id, factor_name, values in data:
order_book_id_index = order_book_id_index_map[order_book_id]
factor_index = factor_index_map[factor_name]
slice_ = slice(order_book_id_index * len(dates),
(order_book_id_index + 1) * len(dates), None)
arr[slice_, factor_index] = values
multi_index = pd.MultiIndex.from_product(
[order_book_ids, dates], names=["order_book_id", "date"])
df = pd.DataFrame(index=multi_index, columns=factor, data=arr)
return df
order_book_id_index_map = {o: i for i, o in enumerate(order_book_ids)}
arr = np.full((len(dates), len(order_book_ids)), np.nan)
for order_book_id, _, values in data:
arr[:, order_book_id_index_map[order_book_id]] = values
df = pd.DataFrame(index=dates, columns=order_book_ids, data=arr)
if len(df.index) == 1:
return df.iloc[0]
if len(df.columns) == 1:
return df[df.columns[0]]
return df
