def calculate_price(self):
""""""
self.clear_price()
# Go through all legs to calculate price
for n, leg in enumerate(self.legs.values()):
# Filter not all leg price data has been received
if not leg.bid_volume or not leg.ask_volume:
self.clear_price()
return
# Calculate price
price_multiplier = self.price_multipliers[leg.vt_symbol]
if price_multiplier > 0:
self.bid_price += leg.bid_price * price_multiplier
self.ask_price += leg.ask_price * price_multiplier
else:
self.bid_price += leg.ask_price * price_multiplier
self.ask_price += leg.bid_price * price_multiplier
# Round price to pricetick
if self.pricetick:
self.bid_price = round_to(self.bid_price, self.pricetick)
self.ask_price = round_to(self.ask_price, self.pricetick)
# Calculate volume
trading_multiplier = self.trading_multipliers[leg.vt_symbol]
inverse_contract = self.inverse_contracts[leg.vt_symbol]
if not inverse_contract:
leg_bid_volume = leg.bid_volume
leg_ask_volume = leg.ask_volume
else:
leg_bid_volume = calculate_inverse_volume(
leg.bid_volume, leg.bid_price, leg.size)
leg_ask_volume = calculate_inverse_volume(
leg.ask_volume, leg.ask_price, leg.size)
if trading_multiplier > 0:
adjusted_bid_volume = floor_to(
leg_bid_volume / trading_multiplier, self.min_volume)
adjusted_ask_volume = floor_to(
leg_ask_volume / trading_multiplier, self.min_volume)
else:
adjusted_bid_volume = floor_to(
leg_ask_volume / abs(trading_multiplier), self.min_volume)
adjusted_ask_volume = floor_to(
leg_bid_volume / abs(trading_multiplier), self.min_volume)
# For the first leg, just initialize
if not n:
self.bid_volume = adjusted_bid_volume
self.ask_volume = adjusted_ask_volume
# For following legs, use min value of each leg quoting volume
else:
self.bid_volume = min(self.bid_volume, adjusted_bid_volume)
self.ask_volume = min(self.ask_volume, adjusted_ask_volume)
# Update calculate time
self.datetime = datetime.now()
def calculate_spread_volume(self, vt_symbol: str,
leg_volume: float) -> float:
""""""
leg = self.legs[vt_symbol]
trading_multiplier = self.trading_multipliers[leg.vt_symbol]
spread_volume = leg_volume / trading_multiplier
if spread_volume > 0:
spread_volume = floor_to(spread_volume, self.min_volume)
else:
spread_volume = ceil_to(spread_volume, self.min_volume)
return spread_volume
def calculate_traded_volume(self):
""""""
self.traded = 0
spread = self.spread
n = 0
for leg in spread.legs.values():
leg_traded = self.leg_traded[leg.vt_symbol]
trading_multiplier = spread.trading_multipliers[leg.vt_symbol]
if not trading_multiplier:
continue
adjusted_leg_traded = leg_traded / trading_multiplier
adjusted_leg_traded = round_to(adjusted_leg_traded,
spread.min_volume)
if adjusted_leg_traded > 0:
adjusted_leg_traded = floor_to(adjusted_leg_traded,
spread.min_volume)
else:
adjusted_leg_traded = ceil_to(adjusted_leg_traded,
spread.min_volume)
if not n:
self.traded = adjusted_leg_traded
else:
if adjusted_leg_traded > 0:
self.traded = min(self.traded, adjusted_leg_traded)
elif adjusted_leg_traded < 0:
self.traded = max(self.traded, adjusted_leg_traded)
else:
self.traded = 0
n += 1
self.traded_volume = abs(self.traded)
if self.target > 0 and self.traded >= self.target:
self.status = Status.ALLTRADED
elif self.target < 0 and self.traded <= self.target:
self.status = Status.ALLTRADED
elif not self.traded:
self.status = Status.NOTTRADED
else:
self.status = Status.PARTTRADED
def calculate_pos(self):
""""""
long_pos = 0
short_pos = 0
for n, leg in enumerate(self.legs.values()):
leg_long_pos = 0
leg_short_pos = 0
trading_multiplier = self.trading_multipliers[leg.vt_symbol]
if not trading_multiplier:
continue
inverse_contract = self.inverse_contracts[leg.vt_symbol]
if not inverse_contract:
net_pos = leg.net_pos
else:
net_pos = calculate_inverse_volume(leg.net_pos,
leg.net_pos_price, leg.size)
adjusted_net_pos = net_pos / trading_multiplier
if adjusted_net_pos > 0:
adjusted_net_pos = floor_to(adjusted_net_pos, self.min_volume)
leg_long_pos = adjusted_net_pos
else:
adjusted_net_pos = ceil_to(adjusted_net_pos, self.min_volume)
leg_short_pos = abs(adjusted_net_pos)
if not n:
long_pos = leg_long_pos
short_pos = leg_short_pos
else:
long_pos = min(long_pos, leg_long_pos)
short_pos = min(short_pos, leg_short_pos)
if long_pos > 0:
self.net_pos = long_pos
else:
self.net_pos = -short_pos
def calculate_price(self):
""""""
self.clear_price()
# Go through all legs to calculate price
bid_data = {}
ask_data = {}
volume_inited = False
for variable, leg in self.variable_legs.items():
# Filter not all leg price data has been received
if not leg.bid_volume or not leg.ask_volume:
self.clear_price()
return
# Generate price dict for calculating spread bid/ask
variable_direction = self.variable_directions[variable]
if variable_direction > 0:
bid_data[variable] = leg.bid_price
ask_data[variable] = leg.ask_price
else:
bid_data[variable] = leg.ask_price
ask_data[variable] = leg.bid_price
# Calculate volume
trading_multiplier = self.trading_multipliers[leg.vt_symbol]
if not trading_multiplier:
continue
inverse_contract = self.inverse_contracts[leg.vt_symbol]
if not inverse_contract:
leg_bid_volume = leg.bid_volume
leg_ask_volume = leg.ask_volume
else:
leg_bid_volume = calculate_inverse_volume(
leg.bid_volume, leg.bid_price, leg.size)
leg_ask_volume = calculate_inverse_volume(
leg.ask_volume, leg.ask_price, leg.size)
if trading_multiplier > 0:
adjusted_bid_volume = floor_to(
leg_bid_volume / trading_multiplier, self.min_volume)
adjusted_ask_volume = floor_to(
leg_ask_volume / trading_multiplier, self.min_volume)
else:
adjusted_bid_volume = floor_to(
leg_ask_volume / abs(trading_multiplier), self.min_volume)
adjusted_ask_volume = floor_to(
leg_bid_volume / abs(trading_multiplier), self.min_volume)
# For the first leg, just initialize
if not volume_inited:
self.bid_volume = adjusted_bid_volume
self.ask_volume = adjusted_ask_volume
volume_inited = True
# For following legs, use min value of each leg quoting volume
else:
self.bid_volume = min(self.bid_volume, adjusted_bid_volume)
self.ask_volume = min(self.ask_volume, adjusted_ask_volume)
# Calculate spread price
self.bid_price = self.parse_formula(self.price_code, bid_data)
self.ask_price = self.parse_formula(self.price_code, ask_data)
# Round price to pricetick
if self.pricetick:
self.bid_price = round_to(self.bid_price, self.pricetick)
self.ask_price = round_to(self.ask_price, self.pricetick)
# Update calculate time
self.datetime = datetime.now()