def before_ranking(date, ranking_type, before=1):
d = utils.to_datetime(date) - utils.relativeterm(before, with_time=True)
while not utils.is_weekday(d):
d = d - utils.relativeterm(1, with_time=True)
d = utils.to_format(d)
stocks = Loader.ranking(d, ranking_type)
return stocks
def subject(self, date):
before = self.load_portfolio(utils.to_datetime(date) - utils.relativeterm(1))
# 前月のポートフォリオの状況次第で変える
length = 10 if self.setting.portfolio_size is None else self.setting.portfolio_size
length = int(length/2) if before is None else length
data = self.load_portfolio(utils.to_datetime(date), length=length)
if data is None:
codes = []
else:
codes = data["code"].values.tolist()
return codes
def select_data(codes, stocks, start, end, strategy_creator):
select = {"data": {}, "index": stocks["index"], "args": stocks["args"]}
args = select["args"]
for code in codes:
if not code in stocks["data"].keys():
continue
start_date = utils.to_format(
utils.to_datetime(start) - utils.relativeterm(3))
select["data"][code] = stocks["data"][code].split(start_date, end)
select["data"][code] = strategy_creator.add_data(
stocks["data"][code], stocks["index"])
return select
def steady_trend_stocks(start_date, end_date, filename="rising_stocks.csv"):
current = start_date
data = {"all": []}
output_format = "%Y%m"
while int(utils.format(current, output_format=output_format)) <= int(utils.format(end_date, output_format=output_format)):
try:
months = utils.format(current, output_format=output_format)
d = pandas.read_csv("%s/steady_trend_stocks/%s/%s" % (Loader.settings_dir, months, filename), header=None)
d.columns = ['code']
data[months] = d["code"].values.tolist()
data["all"] = list(set(data["all"] + data[months]))
except:
continue
finally:
current = utils.to_format(utils.to_datetime(current) + utils.relativeterm(1))
return data
def create_terms(args):
optimize_terms = []
validate_terms = []
valid_end_date = utils.to_datetime(args.date)
for c in range(args.count):
if args.instant:
end_date = valid_end_date - utils.relativeterm(args.validate_term,
with_time=True)
start_date = end_date - utils.relativeterm(
args.validate_term * args.optimize_count, with_time=True)
else:
end_date = valid_end_date - utils.relativeterm(args.validate_term)
start_date = end_date - utils.relativeterm(
args.validate_term * args.optimize_count)
term = {
"start_date": start_date,
"end_date": end_date - utils.relativeterm(1, with_time=True)
}
validate_term = {
"start_date": end_date,
"end_date": valid_end_date - utils.relativeterm(1, with_time=True)
}
if args.optimize_count > 0:
optimize_terms.append(term)
validate_terms.append(validate_term)
valid_end_date = start_date
print(
list(
map(
lambda x: "%s - %s" %
(str(x["start_date"]), str(x["end_date"])), optimize_terms)))
print(
list(
map(
lambda x: "%s - %s" %
(str(x["start_date"]), str(x["end_date"])), validate_terms)))
optimize_terms = sorted(optimize_terms, key=lambda x: x["start_date"])
validate_terms = sorted(validate_terms, key=lambda x: x["start_date"])
return optimize_terms, validate_terms
def load(args, codes, terms, combination_setting):
min_start_date = min(list(map(lambda x: x["start_date"], terms)))
prepare_term = utils.relativeterm(args.validate_term)
start_date = utils.to_format(min_start_date - prepare_term)
end_date = utils.format(args.date)
strategy_creator = strategy.load_strategy_creator(args,
combination_setting)
print("loading %s %s %s %s" %
(len(codes), min_start_date, start_date, end_date))
index = strategy.load_index(args, start_date, end_date)
data = {}
params = list(
map(
lambda x: {
"code": x,
"start_date": start_date,
"end_date": end_date,
"args": args
}, codes))
try:
p = Pool(args.jobs)
ret = p.map(create_simulator_data, params)
for r in ret:
if r is None:
continue
data[r.code] = r
except KeyboardInterrupt:
p.close()
exit()
finally:
p.close()
print("loading done")
return {"data": data, "index": index, "args": args}
def select_weekday(self, date, days):
current = utils.to_datetime(date)
for i in range(days):
current = utils.select_weekday(current -
utils.relativeterm(1, True))
return utils.to_format(current)
def apply_trace(figure, before, date, code, row, col, rows, cols, layout,
options):
args = create_args(code)
end = date
start = utils.to_format(
utils.to_datetime(end) - utils.relativeterm(int(before)))
simulator_data = strategy.load_simulator_data(
args.code,
start,
end,
args,
names=["average"] if options["use_multi"] else [])
df = simulator_data.middle
df = df[df["date"] >= start]
df = df.reset_index()
# 陽線-> candle.data[1], 陰線 -> candle.data[0]
candle = FF.create_candlestick(df["open"],
df["high"],
df["low"],
df["close"],
dates=df["date"])
stocks = list(candle.data)
figure = add_stats(figure, row, col, stocks, df, []) # ローソク足をグラフに適用
# 日付リスト
dates = list(map(lambda x: utils.to_datetime(x), df["date"].astype(str)))
rangebreaks = [{
"values":
list(
filter(lambda x: not utils.is_weekday(x),
utils.daterange(dates[0], dates[-1])))
}] # 休日を除外
daterange = [dates[0], dates[-1]]
layout_settings = create_layout_settings(options)
if options["use_multi"]:
setting = layout_settings[0]
setting["line"] = [setting["line"][0]] # candle with average
layout_settings = [setting]
# ===================================================================
# layout_settingをもとに各グラフにデータを入れる
domain_from = 0
for setting in sorted(layout_settings, key=lambda x: x["to"]):
i = row if options["use_multi"] else setting["id"]
label_i = (
(col - 1) +
(row - 1) * cols) + 1 if options["use_multi"] else setting["id"]
# multiの場合同じlegendがいくつも並ぶので最初のだけ有効に
showlegend = layout["showlegend"] and row == 1 and col == 1 if options[
"use_multi"] else layout["showlegend"]
figure = apply_fig_setting(figure,
i,
col,
df,
setting["bar"],
mode="bar",
showlegend=showlegend)
figure = apply_fig_setting(figure,
i,
col,
df,
setting["line"],
mode="lines",
showlegend=showlegend)
figure = apply_fig_setting(figure,
i,
col,
df,
setting["marker"],
mode="markers",
showlegend=showlegend)
xlabel = "xaxis%s" % label_i
layout[xlabel] = {
"range": daterange,
"rangebreaks": rangebreaks,
"scaleanchor": "x1"
}
if not options["use_multi"]:
ylabel = "yaxis%s" % label_i
layout[ylabel] = {"domain": [domain_from, setting["to"]]}
layout[xlabel]["domain"] = [0.0, 1.0]
domain_from = setting["to"]
return figure, layout
