def downloadAllMinuteBar(self, days=0):
"""下载所有配置中的合约的分钟线数据"""
if days == 0:
days = self.setting["days"]
startDt = datetime.today() - days * timedelta(1)
enddt = datetime.today()
print('-' * 50)
print(u'开始下载合约分钟线数据')
print('-' * 50)
if 'Bar.Min' in self.setting:
l = self.setting["Bar.Min"]
for VNSymbol in l:
dt0 = time.process_time()
symbol = VNSymbol.split(".")[0]
exchange = Exchange(VNSymbol.split(".")[1])
self.query_history(symbol,
exchange,
startDt,
enddt,
interval='1m')
cost = (time.process_time() - dt0)
print(u'合约%s的分钟K线数据下载完成%s - %s，耗时%s秒' %
(symbol, startDt, enddt, cost))
print(jq.get_query_count())
print('-' * 50)
print
u'合约分钟线数据下载完成'
print('-' * 50)
return None
def set_parameters(
self,
vt_symbol: str,
interval: Interval,
start: datetime,
rate: float,
slippage: float,
size: float,
pricetick: float,
capital: int = 0,
end: datetime = None,
mode: BacktestingMode = BacktestingMode.BAR,
inverse: bool = False
):
""""""
self.mode = mode
self.vt_symbol = vt_symbol
self.interval = Interval(interval)
self.rate = rate
self.slippage = slippage
self.size = size
self.pricetick = pricetick
self.start = start
self.symbol, exchange_str = self.vt_symbol.split(".")
self.exchange = Exchange(exchange_str)
self.capital = capital
self.end = end
self.mode = mode
self.inverse = inverse
# 更新日志目录
self.logs_path = os.path.abspath(os.path.join(os.getcwd(), 'log', self.test_name))
def generateVtBar(row, symbol, exchange):
"""生成K线"""
bar = BarData(symbol=symbol,
exchange=Exchange(exchange),
interval=Interval.MINUTE,
open_price=row["open"],
high_price=row["high"],
low_price=row["low"],
close_price=row["close"],
volume=row["volume"],
datetime=row.name.to_pydatetime(),
gateway_name="DB")
bar.date = bar.datetime.strftime("%Y%m%d")
bar.time = bar.datetime.strftime("%H%M%S")
# 将bar的时间改成提前一分钟
hour = bar.time[0:2]
minute = bar.time[2:4]
sec = bar.time[4:6]
if minute == "00":
minute = "59"
h = int(hour)
if h == 0:
h = 24
hour = str(h - 1).rjust(2, '0')
else:
minute = str(int(minute) - 1).rjust(2, '0')
bar.time = hour + minute + sec
bar.datetime = bar.datetime.strptime(' '.join([bar.date, bar.time]),
'%Y%m%d %H%M%S')
return bar
def load_trade_data(self, filter: dict) -> defaultdict(TradeData):
"""加载交易记录"""
if self.trade_data_collection.count_documents(filter) == 0:
self.output("无符合条件的交易记录")
return
else:
trades = defaultdict(TradeData)
c: Cursor = self.trade_data_collection.find(filter)
for d in c:
d["exchange"] = Exchange(d["exchange"])
d["direction"] = Direction(d["direction"])
d["offset"] = Offset(d["offset"])
d["gateway_name"] = "DB"
d.pop("_id")
trade = TradeData(**d)
trades[d["tradeid"]] = trade
start = self.trade_data_collection.find_one(sort=[("datetime",
1)])["datetime"]
end = self.trade_data_collection.find_one(sort=[("datetime",
-1)])["datetime"]
self.output(
f"已从{self.trade_db.name}{self.trade_data_collection.name}加载{start}至{end}交易记录{len(trades)}条"
)
return trades
def run_single_backtesting(args):
engine = BacktestingEngine()
req = HistoryRequest(symbol=args.symbol,
exchange=Exchange(args.exchange),
interval=Interval(args.interval),
start=datetime.strptime(args.startdate, '%Y-%m-%d'),
end=datetime.strptime(args.enddate, '%Y-%m-%d'))
setting = txt_to_dic(args.backtesting_setting_file)
strategy_class = STRATEGIES[args.strategy_class]
engine.set_parameters(vt_symbol=req.vt_symbol,
interval=req.interval,
start=req.start,
end=req.end,
rate=args.rate,
slippage=args.slippage,
size=args.size,
pricetick=args.pricetick,
capital=args.capital)
engine.add_strategy(strategy_class, setting)
engine.load_data()
engine.run_backtesting()
df = engine.calculate_result()
engine.calculate_statistics(df)
engine.show_chart(df)
def query_bar_from_rq(self, vt_symbol: str, interval: Interval,
start: datetime, end: datetime):
"""
Query bar data from RQData.
"""
symbol, exchange_str = vt_symbol.split(".")
if symbol.upper() not in self.rq_symbols:
return None
df = self.rq_client.get_price(
symbol.upper(),
frequency=interval.value,
fields=["open", "high", "low", "close", "volume"],
start_date=start,
end_date=end)
data = []
for ix, row in df.iterrows():
bar = BarData(symbol=symbol,
exchange=Exchange(exchange_str),
interval=interval,
datetime=row.name.to_pydatetime(),
open_price=row["open"],
high_price=row["high"],
low_price=row["low"],
close_price=row["close"],
volume=row["volume"],
gateway_name="RQ")
data.append(bar)
return data
def init_tick_database(self, vt_symbol: str):
"""初始化历史tick数据库"""
symbol, exchange_str = vt_symbol.split(".")
exchange = Exchange(exchange_str)
db_name = f"{exchange.value}历史数据"
db_names = self.client.list_database_names()
if db_name in db_names:
self.output(f"已有{db_name}数据库，现在开始初始化")
else:
self.output(f"当前不存在{db_name}数据库，开始创建新的数据库")
# 初始化K线数据库
self.history_db: Database = self.client[db_name]
collection_name = f"{symbol}_tick_data"
collection_names = self.history_db.list_collection_names()
if collection_name in collection_names:
self.output(f"已有{collection_name}集合，现在开始初始化")
else:
self.output(f"当前不存在{collection_name}集合，开始创建新的集合")
# 初始化Tick数据表
self.tick_collection: Collection = self.history_db[collection_name]
self.tick_collection.create_index([
("exchange", ASCENDING),
("symbol", ASCENDING),
("datetime", ASCENDING),
],
unique=True)
self.output(f"已完成{db_name}数据库{collection_name}集合初始化")
def load_bar_data(
self,
symbol: str,
exchange: Exchange,
interval: Interval,
start: datetime,
end: datetime
) -> List[BarData]:
""""""
s: ModelSelect = (
DbBarData.select().where(
(DbBarData.symbol == symbol)
& (DbBarData.exchange == exchange.value)
& (DbBarData.interval == interval.value)
& (DbBarData.datetime >= start)
& (DbBarData.datetime <= end)
).order_by(DbBarData.datetime)
)
vt_symbol = f"{symbol}.{exchange.value}"
bars: List[BarData] = []
for db_bar in s:
db_bar.datetime = DB_TZ.localize(db_bar.datetime)
db_bar.exchange = Exchange(db_bar.exchange)
db_bar.interval = Interval(db_bar.interval)
db_bar.gateway_name = "DB"
db_bar.vt_symbol = vt_symbol
bars.append(db_bar)
return bars
def load_tick_data(
self,
symbol: str,
exchange: Exchange,
start: datetime,
end: datetime
) -> List[TickData]:
""""""
s: ModelSelect = (
DbTickData.select().where(
(DbTickData.symbol == symbol)
& (DbTickData.exchange == exchange.value)
& (DbTickData.datetime >= start)
& (DbTickData.datetime <= end)
).order_by(DbTickData.datetime)
)
vt_symbol = f"{symbol}.{exchange.value}"
ticks: List[TickData] = []
for db_tick in s:
db_tick.datetime = DB_TZ.localize(db_tick.datetime)
db_tick.exchange = Exchange(db_tick.exchange)
db_tick.gateway_name = "DB"
db_tick.vt_symbol = vt_symbol
ticks.append(db_tick)
return ticks
def set_parameters(self,
vt_symbol: str,
interval: Interval,
start: datetime,
rate: float,
slippage: float,
size: float,
pricetick: float,
capital: int = 0,
end: datetime = None,
annual_days: int = 240):
""""""
self.vt_symbol = vt_symbol
self.rate = rate
self.slippage = slippage
self.size = size
self.start = start
self.symbol, exchange_str = self.vt_symbol.split(".")
self.exchange = Exchange(exchange_str)
self.capital = capital
self.end = end
self.annual_days = annual_days
def gen_task_detail(self, objs: Sequence["DownloadTaskData"]):
task_detail_list = []
for t in objs:
startdate = datetime(t.startdate.year, t.startdate.month,
t.startdate.day, 9)
enddate = datetime(t.enddate.year, t.enddate.month, t.enddate.day,
16)
daydate = startdate
while daydate < enddate:
if daydate.weekday() not in [5, 6]:
task_detail = DownloadTaskDetailData(
maintype=MainType(t.maintype),
symbol=t.symbol,
exchange=Exchange(t.exchange),
interval=t.interval,
detaildate=daydate,
status=TaskStatus.INIT,
processdate=datetime.now(),
breakpointdate=datetime.now(),
)
task_detail_list.append(task_detail)
daydate += timedelta(days=1)
self.update_task(t.maintype, t.symbol, t.exchange, t.interval,
t.startdate, t.enddate, TaskStatus.FINISHED)
ds = [
self.class_task_detail.from_task_detail(i)
for i in task_detail_list
]
self.class_task_detail.save_all(ds)
def load_ticks(self, csv_path: str):
ticks = []
with codecs.open(csv_path, "r", "utf-8") as f:
reader = csv.DictReader(f)
for item in reader:
dt = datetime.strptime(item['datetime'], '%Y-%m-%d %H:%M:%S')
tick = TickData(
symbol=item['symbol'],
exchange=Exchange(item['exchange']),
datetime=dt,
name=item['name'],
volume=self.covertf(item['volume']),
open_interest=self.covertf(item['open_interest']),
last_price=self.covertf(item['last_price']),
last_volume=self.covertf(item['last_volume']),
limit_up=self.covertf(item['limit_up']),
limit_down=self.covertf(item['limit_down']),
open_price=self.covertf(item['open_price']),
high_price=self.covertf(item['high_price']),
low_price=self.covertf(item['low_price']),
pre_close=self.covertf(item['pre_close']),
bid_price_1=self.covertf(item['bid_price_1']),
ask_price_1=self.covertf(item['ask_price_1']),
bid_volume_1=self.covertf(item['bid_volume_1']),
ask_volume_1=self.covertf(item['ask_volume_1']),
gateway_name="JQ")
ticks.append(tick)
return ticks
def set_parameters(self,
vt_symbol: str,
interval: Interval,
start: datetime,
rate: float,
slippage: float,
size: float,
pricetick: float,
capital: int = 0,
end: datetime = None,
mode: BacktestingMode = BacktestingMode.BAR,
inverse: bool = False,
risk_free: float = 0,
annual_days: int = 240):
""""""
self.mode = mode
self.vt_symbol = vt_symbol
self.interval = Interval(interval)
self.rate = rate
self.slippage = slippage
self.size = size
self.pricetick = pricetick
self.start = start
self.symbol, exchange_str = self.vt_symbol.split(".")
self.exchange = Exchange(exchange_str)
self.capital = capital
self.end = end
self.mode = mode
self.inverse = inverse
self.risk_free = risk_free
self.annual_days = annual_days
def load_bar_data(self, filter: dict) -> List[BarData]:
"""加载历史数据"""
if self.bar_collection.count_documents(filter) == 0:
self.output("无符合条件的历史数据")
return
else:
bars = []
c: Cursor = self.bar_collection.find(filter)
for d in c:
d["exchange"] = Exchange(d["exchange"])
d["interval"] = Interval(d["interval"])
d["gateway_name"] = "DB"
d.pop("_id")
bar = BarData(**d)
bars.append(bar)
bars = sorted(bars, key=lambda bar: bar.datetime)
self.output(
f"已从{self.history_db.name}库{self.bar_collection.name}集合加载{bars[0].datetime}至{bars[-1].datetime}K线数据{len(bars)}条"
)
return bars
def to_opbasic(self):
"""
Generate OptionsBasic object from DbOpitonsBasic.
"""
opbasic = OptionsBasic(
symbol=self.symbol,
exchange=Exchange(self.exchange),
name=self.name,
per_unit=self.per_unit,
opt_code=self.opt_code,
opt_type=self.opt_type,
call_put=self.call_put,
exercise_type=self.exercise_type,
exercise_price=self.exercise_price,
s_month=self.s_month,
maturity_date=self.maturity_date,
list_price=self.list_price,
list_date=self.list_date,
delist_date=self.delist_date,
last_edate=self.last_edate,
last_ddate=self.last_ddate,
quote_unit=quote_unit,
min_price_chg=self.min_price_chg,
gateway_name="DB",
)
return opbasic
def main():
print("实盘交易")
# 事件引擎
event_engine = EventEngine()
# 把事件引擎附加到主引擎里
main_engine = MainEngine(event_engine)
main_engine.write_log("主引擎创建成功")
main_engine.add_gateway(OkexfGateway)
# 获取所有交易通道
gateway_names = main_engine.get_all_gateway_names()
for name in gateway_names:
# 连接火币平台
connect = ConnectExchange(main_engine=main_engine, gateway_name=name)
connect.connect()
sleep(2)
setting = load_json(filename="jyx_data_recorder_setting.json")
vt_symbols = setting["vt_symbols"]
functions = []
for vt_symbol in vt_symbols:
gevent.sleep(1)
# 交易对， 交易所
symbol, exchange_str = vt_symbol.split(".")
exchange = Exchange(exchange_str)
gateway = main_engine.get_gateway(exchange_str)
functions += start_gevent(gateway=gateway,
symbol=symbol,
exchange=exchange)
gevent.joinall(functions)
def get_bar_data_available(self) -> List[Dict]:
""""""
data = database_manager.get_bar_data_statistics()
for d in data:
oldest_bar = database_manager.get_oldest_bar_data(
d["symbol"], Exchange(d["exchange"]), Interval(d["interval"])
)
d["start"] = oldest_bar.datetime
newest_bar = database_manager.get_newest_bar_data(
d["symbol"], Exchange(d["exchange"]), Interval(d["interval"])
)
d["end"] = newest_bar.datetime
return data
def set_parameters(
self,
vt_symbol: str,
interval: Interval,
start: datetime,
rate: float,
slippage: float,
size: float,
pricetick: float,
capital: int = 0,
end: datetime = None,
mode: BacktestingMode = BacktestingMode.BAR,
):
""""""
self.mode = mode
self.vt_symbol = vt_symbol
self.interval = interval
self.rate = rate
self.slippage = slippage
self.size = size
self.pricetick = pricetick
self.start = start
self.symbol, exchange_str = self.vt_symbol.split(".")
self.exchange = Exchange(exchange_str)
if capital:
self.capital = capital
if end:
self.end = end
if mode:
self.mode = mode
def to_investment(self):
investment = InvestmentData(
id=self.id,
exchange=Exchange(self.exchange),
product_code=self.product_code,
symbol=self.symbol,
open_price=self.open_price,
finish_price=self.finish_price,
volume=self.volume,
close_volume=self.close_volume,
direction=Direction(self.direction),
money_lock=self.money_lock,
profit=self.profit,
profit_rate=self.profit_rate,
net_profit=self.net_profit,
cost_fee=self.cost_fee,
strategy=self.strategy,
start_datetime=self.start_datetime,
end_datetime=self.end_datetime,
open_trade_id=self.open_trade_id,
close_trade_ids=self.close_trade_ids.split(",") if self.close_trade_ids is not None else None,
state=InvestmentState(self.state),
engine_type=EngineType(self.engine_type)
)
return investment
def load_bar_data(self, symbol: str, exchange: Exchange,
interval: Interval, start: datetime,
end: datetime) -> List[BarData]:
""""""
s: ModelSelect = (
DbBarData.select().where((DbBarData.symbol == symbol)
& (DbBarData.exchange == exchange.value)
& (DbBarData.interval == interval.value)
& (DbBarData.datetime >= start)
& (DbBarData.datetime <= end)).order_by(
DbBarData.datetime))
bars: List[BarData] = []
for db_bar in s:
bar = BarData(symbol=db_bar.symbol,
exchange=Exchange(db_bar.exchange),
datetime=db_bar.datetime.astimezone(DB_TZ),
interval=Interval(db_bar.interval),
volume=db_bar.volume,
turnover=db_bar.turnover,
open_interest=db_bar.open_interest,
open_price=db_bar.open_price,
high_price=db_bar.high_price,
low_price=db_bar.low_price,
close_price=db_bar.close_price,
gateway_name="DB")
bars.append(bar)
return bars
def load_tick_data(
self,
symbol: str,
exchange: Exchange,
start: datetime,
end: datetime,
collection_name: str = None,
) -> List[TickData]:
""""""
if not collection_name:
s: QuerySet = DbTickData.objects(
symbol=symbol,
exchange=exchange.value,
datetime__gte=convert_tz(start),
datetime__lte=convert_tz(end),
)
else:
with switch_collection(DbBarData, collection_name):
s: QuerySet = DbTickData.objects(
symbol=symbol,
exchange=exchange.value,
datetime__gte=convert_tz(start),
datetime__lte=convert_tz(end),
)
vt_symbol = f"{symbol}.{exchange.value}"
ticks: List[TickData] = []
for db_tick in s:
db_tick.datetime = DB_TZ.localize(db_tick.datetime)
db_tick.exchange = Exchange(db_tick.exchange)
db_tick.gateway_name = "DB"
db_tick.vt_symbol = vt_symbol
ticks.append(db_tick)
return ticks
def load_tick_data(
self,
symbol: str,
exchange: Exchange,
start: datetime,
end: datetime
) -> List[TickData]:
""""""
s: QuerySet = DbTickData.objects(
symbol=symbol,
exchange=exchange.value,
datetime__gte=convert_tz(start),
datetime__lte=convert_tz(end),
)
ticks: List[TickData] = []
for db_tick in s:
tick = TickData(
symbol=db_tick.symbol,
exchange=Exchange(db_tick.exchange),
datetime=db_tick.datetime.astimezone(DB_TZ),
name=db_tick.name,
volume=db_tick.volume,
turnover=db_tick.turnover,
open_interest=db_tick.open_interest,
last_price=db_tick.last_price,
last_volume=db_tick.last_volume,
limit_up=db_tick.limit_up,
limit_down=db_tick.limit_down,
open_price=db_tick.open_price,
high_price=db_tick.high_price,
low_price=db_tick.low_price,
pre_close=db_tick.pre_close,
bid_price_1=db_tick.bid_price_1,
bid_price_2=db_tick.bid_price_2,
bid_price_3=db_tick.bid_price_3,
bid_price_4=db_tick.bid_price_4,
bid_price_5=db_tick.bid_price_5,
ask_price_1=db_tick.ask_price_1,
ask_price_2=db_tick.ask_price_2,
ask_price_3=db_tick.ask_price_3,
ask_price_4=db_tick.ask_price_4,
ask_price_5=db_tick.ask_price_5,
bid_volume_1=db_tick.bid_volume_1,
bid_volume_2=db_tick.bid_volume_2,
bid_volume_3=db_tick.bid_volume_3,
bid_volume_4=db_tick.bid_volume_4,
bid_volume_5=db_tick.bid_volume_5,
ask_volume_1=db_tick.ask_volume_1,
ask_volume_2=db_tick.ask_volume_2,
ask_volume_3=db_tick.ask_volume_3,
ask_volume_4=db_tick.ask_volume_4,
ask_volume_5=db_tick.ask_volume_5,
localtime=db_tick.localtime,
gateway_name="DB"
)
ticks.append(tick)
return ticks
def move_1_min_csv_to_mongo_db(csv_path: str, symbol: str, exchange: str, interval, logger):
try:
start_time = time.time()
logger.info("saving {} starts".format(symbol))
imported_data = pd.read_csv(csv_path)
imported_data.columns = ["datetime", "open", "high", "low", "close", "volume"]
imported_data.loc[:, "exchange"] = Exchange(exchange)
imported_data.loc[:, "open_interest"] = 0.0
imported_data.loc[:, "interval"] = interval
imported_data.loc[:, "symbol"] = symbol
datetime_format = '%Y%m%d %H:%M:%S'
imported_data['datetime'] = pd.to_datetime(imported_data['datetime'], format=datetime_format)
float_columns = ['open', 'high', 'low', 'close', 'volume', 'open_interest']
for col in float_columns:
imported_data.loc[:, col] = imported_data[col].astype('float')
def move_df_to_mongodb(import_data: pd.DataFrame, collection_name: str):
bars = []
start = None
count = 0
bar = None
for row in import_data.itertuples():
bar = BarData(
symbol=row.symbol,
exchange=row.exchange,
datetime=row.datetime,
interval=row.interval,
volume=row.volume,
open_price=row.open,
high_price=row.high,
low_price=row.low,
close_price=row.close,
open_interest=row.open_interest,
gateway_name="DB",
)
bars.append(bar)
# do some statistics
count += 1
if not start:
start = bar.datetime
end = bar.datetime
# insert into database
database_manager.save_bar_data(bars, collection_name)
print(f"Insert Bar: {count} from {start} - {end}")
move_df_to_mongodb(imported_data, symbol)
end_time = time.time()
logger.info("time used is {}".format(end_time - start_time))
logger.info("saving {} successful".format(symbol))
except (ValueError, Exception):
logger.info("saving {} failed".format(symbol))
def load_tick_data(
self,
symbol: str,
exchange: Exchange,
start: datetime,
end: datetime
) -> List[TickData]:
"""加载TICK数据"""
s = self.db.query(DbTickData).filter(
DbTickData.symbol == symbol,
DbTickData.exchange == exchange.value,
DbTickData.datetime >= start,
DbTickData.datetime <= end
).order_by(DbTickData.datetime).all()
ticks: List[TickData] = []
for db_tick in s:
data = TickData(
symbol=db_tick.symbol,
exchange=Exchange(db_tick.exchange),
datetime=DB_TZ.localize(db_tick.datetime),
volume=db_tick.volume,
open_interest=db_tick.open_interest,
last_price=db_tick.last_price,
last_volume=db_tick.last_volume,
limit_up=db_tick.limit_up,
limit_down=db_tick.limit_down,
open_price=db_tick.open_price,
high_price=db_tick.high_price,
low_price=db_tick.low_price,
pre_close=db_tick.pre_close,
bid_price_1=db_tick.bid_price_1,
bid_price_2=db_tick.bid_price_2,
bid_price_3=db_tick.bid_price_3,
bid_price_4=db_tick.bid_price_4,
bid_price_5=db_tick.bid_price_5,
ask_price_1=db_tick.ask_price_1,
ask_price_2=db_tick.ask_price_2,
ask_price_3=db_tick.ask_price_3,
ask_price_4=db_tick.ask_price_4,
ask_price_5=db_tick.ask_price_5,
bid_volume_1=db_tick.bid_volume_1,
bid_volume_2=db_tick.bid_volume_2,
bid_volume_3=db_tick.bid_volume_3,
bid_volume_4=db_tick.bid_volume_4,
bid_volume_5=db_tick.bid_volume_5,
ask_volume_1=db_tick.ask_volume_1,
ask_volume_2=db_tick.ask_volume_2,
ask_volume_3=db_tick.ask_volume_3,
ask_volume_4=db_tick.ask_volume_4,
ask_volume_5=db_tick.ask_volume_5,
gateway_name="DB"
)
ticks.append(data)
return ticks
def _get_vn_exchange(self, symbol):
"""获取"""
underlying_symbol = get_underlying_symbol(symbol).upper()
info = self.future_contracts.get(underlying_symbol, None)
if info:
return Exchange(info.get('exchange'))
else:
market_id = get_tdx_marketid(symbol)
return Tdx_Vn_Exchange_Map.get(str(market_id), Exchange.INE)
def to_product(self):
product = ProductData(exchange=Exchange(self.exchange),
product_code=self.product_code,
product_name=self.product_name,
contract_size=self.contract_size,
margin_percent=self.margin_percent,
commission_unit=CommissionUnit(
self.commission_unit),
commission=self.commission)
return product
def data_record(start, end, vt_symbol):
from vnpy.trader.database import database_manager
from vnpy.gateway.ib.ib_gateway import IbGateway
from vnpy.trader.utility import load_json
from vnpy.trader.object import HistoryRequest
from vnpy.trader.constant import Interval, Exchange
from dateutil import parser
from vnpy.event.engine import EventEngine
from vnpy.trader.event import EVENT_LOG
vt_symbol = vt_symbol
symbol, exchange = vt_symbol.split('.')
if not start and not end:
offset = 0 if dt.datetime.now().time() > dt.time(17, 0) else 1
start = (dt.datetime.today() - dt.timedelta(days=offset + 1)).replace(
hour=17, minute=0, second=0, microsecond=0)
end = (dt.datetime.today() - dt.timedelta(days=offset)).replace(
hour=17, minute=0, second=0, microsecond=0)
else:
start = parser.parse(start)
end = parser.parse(end) if end else end
ib_settings = load_json('connect_ib.json')
ib_settings["客户号"] += 4
recorder_engine = EventEngine()
def log(event):
data = event.data
print(data.level, data.msg)
recorder_engine.register(EVENT_LOG, log)
ib = IbGateway(recorder_engine)
try:
recorder_engine.start()
ib.connect(ib_settings)
if ib.api.client.isConnected():
req = HistoryRequest(symbol, Exchange(exchange), start, end,
Interval.MINUTE)
ib.write_log(f'发起请求#{vt_symbol}, {start}至{end}')
his_data = ib.query_history(req)
ib.write_log(
f'获得数据#{vt_symbol}， {his_data[0].datetime}至{his_data[-1].datetime}, 共{len(his_data)}条'
)
database_manager.save_bar_data(his_data)
ib.write_log(f'成功入库')
else:
ib.write_log('连接失败！请检查客户号是否被占用或IP是否正确')
except Exception as e:
raise e
finally:
ib.close()
recorder_engine.stop()
def download(self):
""""""
symbol = self.symbol_edit.text()
exchange = Exchange(self.exchange_combo.currentData())
interval = Interval(self.interval_combo.currentData())
start_date = self.start_date_edit.date()
start = datetime(start_date.year(), start_date.month(), start_date.day())
count = self.engine.download_bar_data(symbol, exchange, interval, start)
QtWidgets.QMessageBox.information(self, "下载结束", f"下载总数据量：{count}条")
def load_tick_data(self, symbol: str, exchange: Exchange, start: datetime,
end: datetime) -> List[TickData]:
""""""
s: ModelSelect = (
DbTickData.select().where((DbTickData.symbol == symbol)
& (DbTickData.exchange == exchange.value)
& (DbTickData.datetime >= start)
& (DbTickData.datetime <= end)).order_by(
DbTickData.datetime))
ticks: List[TickData] = []
for db_tick in s:
tick = TickData(symbol=db_tick.symbol,
exchange=Exchange(db_tick.exchange),
datetime=db_tick.datetime.astimezone(DB_TZ),
name=db_tick.name,
volume=db_tick.volume,
turnover=db_tick.turnover,
open_interest=db_tick.open_interest,
last_price=db_tick.last_price,
last_volume=db_tick.last_volume,
limit_up=db_tick.limit_up,
limit_down=db_tick.limit_down,
open_price=db_tick.open_price,
high_price=db_tick.high_price,
low_price=db_tick.low_price,
pre_close=db_tick.pre_close,
bid_price_1=db_tick.bid_price_1,
bid_price_2=db_tick.bid_price_2,
bid_price_3=db_tick.bid_price_3,
bid_price_4=db_tick.bid_price_4,
bid_price_5=db_tick.bid_price_5,
ask_price_1=db_tick.ask_price_1,
ask_price_2=db_tick.ask_price_2,
ask_price_3=db_tick.ask_price_3,
ask_price_4=db_tick.ask_price_4,
ask_price_5=db_tick.ask_price_5,
bid_volume_1=db_tick.bid_volume_1,
bid_volume_2=db_tick.bid_volume_2,
bid_volume_3=db_tick.bid_volume_3,
bid_volume_4=db_tick.bid_volume_4,
bid_volume_5=db_tick.bid_volume_5,
ask_volume_1=db_tick.ask_volume_1,
ask_volume_2=db_tick.ask_volume_2,
ask_volume_3=db_tick.ask_volume_3,
ask_volume_4=db_tick.ask_volume_4,
ask_volume_5=db_tick.ask_volume_5,
localtime=db_tick.localtime,
gateway_name="DB")
ticks.append(tick)
return ticks
def on_info(self, data: dict):
""""""
for account_data in data["position"]:
_type = account_data["type"]
# Spot
if "spot" in _type:
account = AccountData(
accountid=account_data["contract"],
balance=float(account_data["total_amount"]),
frozen=float(account_data["frozen"]),
gateway_name=self.gateway_name
)
self.gateway.on_account(account)
# Futures
elif _type == "future":
long_position = PositionData(
symbol=account_data["contract"],
exchange=Exchange(self.exchange.upper()),
direction=Direction.LONG,
price=account_data["average_open_price_long"],
volume=account_data["total_amount_long"],
pnl=account_data["unrealized_long"],
frozen=account_data["frozen_position_long"],
gateway_name=self.gateway_name,
)
short_position = PositionData(
symbol=account_data["contract"],
exchange=Exchange(self.exchange.upper()),
direction=Direction.SHORT,
price=account_data["average_open_price_short"],
volume=account_data["total_amount_short"],
pnl=account_data["unrealized_short"],
frozen=account_data["frozen_position_short"],
gateway_name=self.gateway_name,
)
self.gateway.on_position(long_position)
self.gateway.on_position(short_position)