def delete_bar_data(self, symbol: str, exchange: Exchange,
interval: Interval) -> int:
""""""
bind_params = {
"vt_symbol": generate_vt_symbol(symbol, exchange),
"interval": interval.value
}
# Query data count
query1 = ("select count(close_price) from bar_data"
" where vt_symbol=$vt_symbol"
" and interval=$interval")
result = self.client.query(query1, bind_params=bind_params)
points = result.get_points()
for d in points:
count = d["count"]
# Delete data
query2 = ("drop series from bar_data"
" where vt_symbol=$vt_symbol"
" and interval=$interval")
self.client.query(query2, bind_params=bind_params)
# Delete overview
f = shelve.open(self.overview_filepath)
vt_symbol = generate_vt_symbol(symbol, exchange)
key = f"{vt_symbol}_{interval.value}"
if key in f:
f.pop(key)
f.close()
return count
def delete_bar_data(self, symbol: str, exchange: "Exchange",
interval: "Interval") -> int:
"""
Delete all bar data with given symbol + exchange + interval.
"""
bind_params = {
"vt_symbol": generate_vt_symbol(symbol, exchange),
"interval": interval.value
}
# Query data count
query1 = ("select count(close_price) from bar_data"
" where vt_symbol=$vt_symbol"
" and interval=$interval")
result = influx_client.query(query1, bind_params=bind_params)
points = result.get_points()
for d in points:
count = d["count"]
# Delete data
query2 = ("drop series from bar_data"
" where vt_symbol=$vt_symbol"
" and interval=$interval")
influx_client.query(query2, bind_params=bind_params)
return count
def get_oldest_bar_data(self, symbol: str, exchange: "Exchange",
interval: "Interval") -> Optional["BarData"]:
query = ("select first(close_price), * from bar_data"
" where vt_symbol=$vt_symbol"
" and interval=$interval")
bind_params = {
"vt_symbol": generate_vt_symbol(symbol, exchange),
"interval": interval.value
}
result = influx_client.query(query, bind_params=bind_params)
points = result.get_points()
bar = None
for d in points:
dt = datetime.strptime(d["time"], "%Y-%m-%dT%H:%M:%SZ")
bar = BarData(symbol=symbol,
exchange=exchange,
interval=interval,
datetime=dt.replace(tzinfo=DB_TZ),
open_price=d["open_price"],
high_price=d["high_price"],
low_price=d["low_price"],
close_price=d["close_price"],
volume=d["volume"],
open_interest=d["open_interest"],
gateway_name="DB")
return bar
def delete_tick_data(
self,
symbol: str,
exchange: Exchange
) -> int:
""""""
bind_params = {
"vt_symbol": generate_vt_symbol(symbol, exchange),
}
# Query data count
query1 = (
"select count(last_price) from tick_data"
" where vt_symbol=$vt_symbol"
)
result = self.client.query(query1, bind_params=bind_params)
points = result.get_points()
for d in points:
count = d["count"]
# Delete data
query2 = (
"drop series from tick_data"
" where vt_symbol=$vt_symbol"
)
self.client.query(query2, bind_params=bind_params)
return count
def load_tick_data(self, symbol: str, exchange: Exchange, start: datetime,
end: datetime) -> List[TickData]:
""""""
query = ("select * from tick_data"
" where vt_symbol=$vt_symbol"
f" and time >= '{start.date().isoformat()}'"
f" and time <= '{end.date().isoformat()}';")
bind_params = {
"vt_symbol": generate_vt_symbol(symbol, exchange),
}
result = self.client.query(query, bind_params=bind_params)
points = result.get_points()
ticks: List[TickData] = []
for d in points:
dt = datetime.strptime(d["time"], "%Y-%m-%dT%H:%M:%SZ")
tick = TickData(symbol=symbol,
exchange=exchange,
datetime=dt.astimezone(DB_TZ),
name=d["name"],
volume=d["volume"],
turnover=d["turnover"],
open_interest=d["open_interest"],
last_price=d["last_price"],
last_volume=d["last_volume"],
limit_up=d["limit_up"],
limit_down=d["limit_down"],
open_price=d["open_price"],
high_price=d["high_price"],
low_price=d["low_price"],
pre_close=d["pre_close"],
bid_price_1=d["bid_price_1"],
bid_price_2=d["bid_price_2"],
bid_price_3=d["bid_price_3"],
bid_price_4=d["bid_price_4"],
bid_price_5=d["bid_price_5"],
ask_price_1=d["ask_price_1"],
ask_price_2=d["ask_price_2"],
ask_price_3=d["ask_price_3"],
ask_price_4=d["ask_price_4"],
ask_price_5=d["ask_price_5"],
bid_volume_1=d["bid_volume_1"],
bid_volume_2=d["bid_volume_2"],
bid_volume_3=d["bid_volume_3"],
bid_volume_4=d["bid_volume_4"],
bid_volume_5=d["bid_volume_5"],
ask_volume_1=d["ask_volume_1"],
ask_volume_2=d["ask_volume_2"],
ask_volume_3=d["ask_volume_3"],
ask_volume_4=d["ask_volume_4"],
ask_volume_5=d["ask_volume_5"],
localtime=d["localtime"],
gateway_name="DB")
ticks.append(tick)
return ticks
def load_bar_data(
self,
symbol: str,
exchange: Exchange,
interval: Interval,
start: datetime,
end: datetime,
) -> Sequence[BarData]:
if isinstance(start, datetime):
start = start.date()
if isinstance(end, datetime):
end = end.date()
query = ("select * from bar_data"
" where vt_symbol=$vt_symbol"
" and interval=$interval"
f" and time >= '{start.isoformat()}'"
f" and time <= '{end.isoformat()}';")
bind_params = {
"vt_symbol": generate_vt_symbol(symbol, exchange),
"interval": interval.value
}
result = influx_client.query(query, bind_params=bind_params)
points = result.get_points()
data = []
for d in points:
dt = datetime.strptime(d["time"], "%Y-%m-%dT%H:%M:%SZ")
bar = BarData(symbol=symbol,
exchange=exchange,
interval=interval,
datetime=dt.replace(tzinfo=DB_TZ),
open_price=d["open_price"],
high_price=d["high_price"],
low_price=d["low_price"],
close_price=d["close_price"],
volume=d["volume"],
open_interest=d["open_interest"],
gateway_name="DB")
data.append(bar)
return data
def load_bar_data(
self,
symbol: str,
exchange: Exchange,
interval: Interval,
start: datetime,
end: datetime
) -> List[BarData]:
""""""
query = (
"select * from bar_data"
" where vt_symbol=$vt_symbol"
" and interval=$interval"
f" and time >= '{start.date().isoformat()}'"
f" and time <= '{end.date().isoformat()}';"
)
bind_params = {
"vt_symbol": generate_vt_symbol(symbol, exchange),
"interval": interval.value
}
result = self.client.query(query, bind_params=bind_params)
points = result.get_points()
bars: List[BarData] = []
for d in points:
dt = datetime.strptime(d["time"], "%Y-%m-%dT%H:%M:%SZ")
bar = BarData(
symbol=symbol,
exchange=exchange,
interval=interval,
datetime=DB_TZ.localize(dt),
open_price=d["open_price"],
high_price=d["high_price"],
low_price=d["low_price"],
close_price=d["close_price"],
volume=d["volume"],
open_interest=d["open_interest"],
gateway_name="DB"
)
bars.append(bar)
return bars
def new_child_order(self, message: fix.Message):
""""""
child_order = GenusChildOrder(
cl_ord_id=get_field_value(message, fix.ClOrdID()),
symbol=get_field_value(message, fix.Symbol()),
side=get_field_value(message, fix.Side()),
order_qty=get_field_value(message, fix.OrderQty()),
price=get_field_value(message, fix.Price()),
order_type=get_field_value(message, fix.OrdType()),
ord_status="A",
parent_orderid=get_field_value(message, fix.StringField(526)))
# If parent offset not exist, then this child order should be ignored
offset = self.client.get_parent_offset(child_order.parent_orderid)
if not offset:
return
symbol, genus_exchange = child_order.symbol.split(".")
exchange = EXCHANGE_GNS2VT[genus_exchange]
direction = DIRECTION_GNS2VT[child_order.side]
order_type = ORDERTYPE_GNS2VT[child_order.order_type]
vt_symbol = generate_vt_symbol(symbol, exchange)
child_order.order_id = self.client.send_order(
vt_symbol,
direction,
offset,
order_type,
child_order.price,
child_order.order_qty,
)
self.child_orders[child_order.order_id] = child_order
self.genus_vt_map[child_order.cl_ord_id] = child_order.order_id
msg = f"委托{direction.value}{vt_symbol}：{child_order.order_qty}@{child_order.price}"
self.client.write_log(msg, algo_name=child_order.parent_orderid)