def __init__(self, directory, fxcodes, time = None):
"""Initialize the Handler.
Parameters:
string directory - the directory which the .csv files lay in
list fxcodes - a list of strings which represent currency
pairs, e.g. ['EURUSD', 'USDJPY']. the Handler will look
into the directory provided by `directory`, if it can
find files called `fxcode`.csv (where fxcode is an
item in fxcodes), e.g. EURUSD.csv
datetime time - the time at which the simulation should
start at, if not provided, it just uses the first time
available
"""
log.debug("Initiating CSVForexTicksHandler Object")
self._directory = directory
self._data = defaultdict(None)
self.fxcodes = fxcodes
self.data_available = True
self.time_change = Signal()
self.tick = Signal()
self._comb_index = None
self._load_files(self._directory, self.fxcodes)
if None == time:
self._time = self._comb_index[0]
else:
self._time = time
self._start_time = self._time
def __init__(self,
market,
limit_storage_time=timedelta(days=10),
lag_time=timedelta(milliseconds=500)):
"""Initialize the broker
Parameters:
Market market - a market instance
timedelta limit_storage_time - a time span which limit
orders will be saved maximum
timdelta lag_time - the time which it will take to broker
to actually set a market order
"""
log.debug("Initiating Broker Object")
self.market = market
self.market.data.tick.registerObserver(self.market_tick)
self.market.data.time_change.registerObserver(self.market_tick)
self._orders = {}
self._limit_storage_time = limit_storage_time
self._market_order_delay = lag_time
self.order_fill = Signal()
self.order_delete = Signal()
self._newest_order_id = -1
def setUp(self):
self.sig_function = Signal()
self.sig_method = Signal()
self.sig_function.connect(onSignalFunction)
global signal_calls
signal_calls = []
def __init__(self, profileID=None, nameAndDecInfo=None, profileData=None):
self.profileID = profileID
self.nameAndDecInfo = nameAndDecInfo
self.originalProfileData = profileData
self.groupsBySettingID = None
self.remoteSvc = sm.RemoteSvc(REMOTE_SERVICE_NAME)
self.on_profile_saved = Signal()
self.on_groups_added = Signal()
self.on_group_changed = Signal()
self.on_profile_value_changed = Signal()
def test_get_signal_dimensions():
s_1 = Signal(known_intruder_1)
assert s_1.get_signal_dimensions() == (8, 11)
s_2 = Signal("----")
assert s_2.get_signal_dimensions() == (1, 4)
def import_data():
"""Import your data here"""
# Import your data as np array
np_x = None
np_y = None
# Wrap your data up into a Signal
fs = 1000 # sampling frequency
x = Signal(np_x, fs=fs)
y = Signal(np_y, fs=fs)
# Return
return x, y
def __init__(self, copy_from=None, FS=96000):
self.tempdir = None
self.tempdir_keep = False
self.backward_euler = False
self.solver = None
self.build_verbose = False
self.module_id = None
self.module_name = None
self.module_desc = None
self.c_datatype = "double"
self.table_datatype = "double" #"float"
self.pre_filter = None
self.post_filter = None
self.code_generator = None
self.plugindef = None
self.build_script = None
self.resample = True
self.FS = FS
self.use_sim = SIM_C
self.sig = Signal()
self._clear()
self._rmtree = shutil.rmtree
self.subcircuits = {}
if copy_from is not None:
self.backward_euler = copy_from.backward_euler
self.solver = copy_from.solver
self.FS = copy_from.FS
self.S = copy_from.S
self.V = copy_from.V
def spectrogram(signal, binWidth, overlap):
"""
Generates the spectrogram of an input signal.
@param signal The input signal object
@return specs The values of the spectrogram
@return f The frequency spectrum
@return t The time domain
"""
try:
signal.name = signal.name
except AttributeError as e:
print('AttributeError: input is not a Signal object')
f = np.linspace(0, binWidth // 2 * signal.sampleRate // binWidth,
binWidth // 2)
t = np.linspace(0, signal.length / signal.sampleRate,
signal.length // binWidth * overlap)
starts = np.arange(0, signal.length, binWidth // overlap)
starts = np.append(starts, signal.length)
specs = np.zeros((binWidth // 2, np.shape(t)[0]))
for step in range(np.shape(starts)[0] - overlap - 1):
subsignal = Signal(sampleRate=signal.sampleRate,
length=starts[step + overlap] - starts[step],
values=signal.values[starts[step]:starts[step +
overlap]])
specs[:, step] = G_xx(subsignal)
return specs, f, t
def separate_interp(self, input_, alphas=None, max_order=4, verbose=False):
# Sanity check
if not isinstance(input_, Signal):
raise TypeError('!! Input must be an instance of Signal')
if alphas is None:
alphas = []
for order in range(max_order):
alphas.append((-1)**order * (1 + order * 0.25))
if verbose: print('>> alphas = {}'.format(alphas))
N = len(alphas)
# Generate matrix R
R = np.zeros(shape=(N, input_.size))
for i in range(N):
R[i] = self(alphas[i] * input_)
# Generate matrix A
A = np.zeros(shape=(N, N))
for r in range(N):
for c in range(N):
A[r, c] = alphas[r]**(c + 1)
inv_A = np.linalg.inv(A)
if verbose:
print('>> ||inv(A)|| = {:.4f}'.format(np.linalg.norm(inv_A)))
# Separate
results = []
yn = np.matmul(inv_A, R)
for order in range(N):
results.append(Signal(yn[order]))
results[order].__array_finalize__(input_)
return results
def inference(self, input_, orders=None, *args, **kwargs):
# Sanity check
if not isinstance(input_, Signal):
raise TypeError('!! Input must be an instance of Signal')
if self.order_lock is not None: orders = self.order_lock
if orders is not None: orders = self._check_orders(orders)
# Calculate
y = np.zeros_like(input_)
if orders is None: pool = self.indices_full
else:
pool = []
for order in orders:
pool += list(
self.kernels.get_homogeneous_indices(
order, self.memory_depth[order - 1], symmetric=False))
for lags in pool:
# lags = (\tau_1, \tau_2, \cdots, \tau_k)
# prod = h_k(\tau_1, \cdots, \tau_k) * \prod_{i=1}^k x[n-\tau_i]
prod = self.kernels[lags]
if prod == 0: continue
for lag in lags:
prod *= self._delay(input_, lag)
y += prod
output = Signal(y)
output.__array_finalize__(input_)
return output
def __init__(self, settingID, groupID, value=0.0):
self.settingInfo = structures.SETTING_OBJECT_BY_SETTINGID[settingID]
self.settingType = self.settingInfo.valueType
self.settingID = settingID
self.groupID = groupID
self.value = value
self.on_profile_value_changed = Signal()
def get_signals_rsi(transaction_currency,
start_time,
end_time,
rsi_overbought,
rsi_oversold,
counter_currency="BTC"):
rsi_signal_query = """ SELECT trend, horizon, strength_value, strength_max, price, price_change, timestamp, rsi_value
FROM signal_signal
WHERE signal_signal.signal=%s AND
transaction_currency=%s AND
counter_currency=%s AND
timestamp >= %s AND
timestamp <= %s AND
(rsi_value > %s OR
rsi_value < %s) AND
source = 0
ORDER BY timestamp;"""
counter_currency_id = CounterCurrency[counter_currency].value
cursor = dbc.execute(rsi_signal_query,
params=("RSI", transaction_currency,
counter_currency_id, start_time, end_time,
rsi_overbought, rsi_oversold))
signals = []
for (trend, horizon, strength_value, strength_max, price, price_change,
timestamp, rsi_value) in cursor:
signals.append(
Signal(SignalType.RSI, trend, horizon, strength_value,
strength_max, price / 1E8, price_change, timestamp,
rsi_value, transaction_currency,
CounterCurrency[counter_currency]))
return signals
def __init__(self, TAlgorithm, datahandler, Broker, Portfolio, name):
"""Initialize a new Stock Simulation
Parameters:
TAlgorithm - A Class which extends TradingAlgorithm. Will be run
as Trader in this simulation. Look at TradingAlgorithm
for information about what this class should contain
DataHandler - An instance of Class extending DataHandler. Look
at DataHandler class about how this classes should look like
Broker - A Class which will extend the Broker Class. Look at the
Broker class about how this classes should look like
Portfolio - a Reference to the Portfolio class
string name - name of the simulation. has no use yet
"""
self.name = name
self.game_end = Signal()
self.data = datahandler
start_port = defaultdict(lambda: 0)
start_port['EUR'] = 50000
self.broker = Broker(self)
self.talgo_port = Portfolio(start_port)
self.talgo = TAlgorithm(self, self.broker, self.talgo_port)
self.date = None
def __init__(self,
itemID,
solarsystemID,
typeID,
ownerID,
structureServices=None,
profileID=None,
currentSchedule=0,
nextSchedule=0,
state=None,
unanchoring=None,
fuelExpires=None):
self.structureInfo = KeyVal(itemID=itemID,
solarsystemID=solarsystemID,
typeID=typeID,
ownerID=ownerID,
structureServices=structureServices,
profileID=profileID,
currentSchedule=currentSchedule,
nextSchedule=nextSchedule,
state=state,
unanchoring=unanchoring,
fuelExpires=fuelExpires)
self.systemAndStructureName = None
self.requiredHours = None
self.on_structure_state_changed = Signal()
def get_signals(signal_type,
transaction_currency,
start_time,
end_time,
counter_currency="BTC"):
signal_query = """ SELECT trend, horizon, strength_value, strength_max, price, price_change, timestamp, rsi_value
FROM signal_signal
WHERE signal_signal.signal=%s AND
transaction_currency=%s AND
counter_currency=%s AND
timestamp >= %s AND
timestamp <= %s AND
source = 0
ORDER BY timestamp;"""
counter_currency_id = CounterCurrency[counter_currency].value
cursor = dbc.execute(signal_query,
params=(signal_type.value, transaction_currency,
counter_currency_id, start_time, end_time))
signals = []
for (trend, horizon, strength_value, strength_max, price, price_change,
timestamp, rsi_value) in cursor:
signals.append(
Signal(signal_type, trend, horizon, strength_value, strength_max,
price / 1E8, price_change, timestamp, rsi_value,
transaction_currency, CounterCurrency[counter_currency]))
return signals
def build_vbi_signals(price_volume_df, percent_change_price, percent_change_volume, transaction_currency, counter_currency,
source, resample_period):
# build signals
all_buy_signals = []
first_cross_buy_signals = []
valid_in_previous_step = False
for row in price_volume_df.itertuples():
timestamp = row.Index.timestamp()
price = row.price
volume = row.volume
avg_price = row.average_price
avg_volume = row.average_volume
# check whether to generate a buy signal:
if price > (1 + percent_change_price)*avg_price and volume > (1 + percent_change_volume)*avg_volume:
signal = Signal("RSI", 1, Horizon.any, 3, 3, price, 0, timestamp, 0, transaction_currency, counter_currency,
source, resample_period)
all_buy_signals.append(signal)
if not valid_in_previous_step:
valid_in_previous_step = True
first_cross_buy_signals.append(signal)
# print(timestamp, price, avg_price, volume, avg_volume)
else:
valid_in_previous_step = False
return all_buy_signals, first_cross_buy_signals
def __init__(self):
self.states = ["INIT", "RUN_COMMANDS"]
self.state = self.states[0]
self.num_frames = 0
self.added_cmd_idx = 0
self.signal_capacity = 15
self.signal = Signal(self.signal_capacity)
self.commands = Commands()
self.unlock_frame_num = 0
def inference(self, input_, **kwargs):
if not self.nn.built:
raise AssertionError('!! Model has not been built yet')
mlp_input = self._gen_mlp_input(input_)
tfinput = TFData(mlp_input)
output = self.nn.predict(tfinput, **kwargs).flatten()
output = Signal(output)
output.__array_finalize__(input_)
return output
def inference(self, input_, orders=None, *args, **kwargs):
# Sanity check
if not isinstance(input_, Signal):
raise TypeError('!! Input must be an instance of Signal')
y = np.zeros_like(input_)
orders = range(self.degree + 1) if orders is None else [orders]
for n in orders:
y += self.G_n(n, input_)
output = Signal(y)
output.__array_finalize__(input_)
return output
def __init__(self, typeID):
self.typeID = typeID
self.radius = evetypes.GetRadius(typeID)
self.movingOffset = None
self.cameraMatrixes = None
self._opacity = 0.0
self.blueprintColor = None
self.ballpark = sm.GetService('michelle').GetBallpark()
self.model_valid = self._LoadModel(':variant?placement', display=True)
self.model_invalid = self._LoadModel(':variant?forbiddenplacement',
display=False)
self.on_location_updated = Signal()
self.UpdateModel()
def G_n(self, n, x):
# Sanity check
if n < 0:
raise ValueError(
'!! degree of any Wiener operator must be non-negative')
if n == 0: y_n = self.kernels[()] * np.ones_like(x)
else:
y_n = np.zeros_like(x)
for i in range(n // 2 + 1):
y_n += self.G_n_i(n, i, x)
output = Signal(y_n)
output.__array_finalize__(x)
return output
def response(self, input_, **kwargs):
# Calculate
y = np.zeros_like(input_)
pool = self.kernels.params.keys()
for lags in pool:
assert isinstance(lags, tuple)
# lags = (\tau_1, \tau_2, \cdots, \tau_k)
# prod = h_k(\tau_1, \cdots, \tau_k) * \prod_{i=1}^k x[n-\tau_i]
prod = self.kernels[lags]
for lag in lags:
prod *= self._delay(input_, lag)
y += prod
output = Signal(y)
output.__array_finalize__(input_)
return output
def __init__(self):
sm.RegisterNotify(self)
self.remoteSvc = sm.RemoteSvc(REMOTE_SERVICE_NAME)
self.objectCashingSvc = sm.GetService('objectCaching')
self.on_new_group_created = Signal()
self.on_group_selected = Signal()
self.on_groupmembers_changed = Signal()
self.on_groupmembers_removed = Signal()
self.on_group_deleted = Signal()
self.on_group_updated = Signal()
self.on_groups_reload = Signal()
self.membersByGroupID = {}
self.groupByGroupID = None
self.publicGroupsByGroupID = {}
self.myGroupsCacheInvalidated = False
self.currentSearchResults = None
def test_get_signal_edge_cases():
# Test that empty strings cant be created for Signal class
with pytest.raises(Exception, match="Signal string can not be empty") as exec_info:
signal = Signal("")
# Test that empty strings cant be created for subclasses of Signal class
with pytest.raises(Exception, match="Signal string can not be empty") as exec_info:
signal = RadarSignal("")
with pytest.raises(Exception, match="Signal string can not be empty") as exec_info:
signal = IntruderSignal("")
# Test that the constructor does not take none as argument
with pytest.raises(Exception, match="Signal string can not be empty") as exec_info:
signal = RadarSignal(None)
def parse(self, s, debug=False):
self.clear()
lines = s.strip().split("\n")
if debug:
print "Parsing message"
print lines
header = lines[0]
parts = header.split(" ")
if parts[0] != "BO_":
print "Aborting: Expected \"BO_\" at beginning of message. Got \"" + parts[
0] + "\"."
return
self.ID = int(parts[1])
self.name = parts[2][:-1]
self.DLC = int(parts[3])
# TODO: Evaluate whatever is the meaning of "Vector__XXX"
for line in lines[1:]:
self.signals.append(Signal(line, debug))
def sys97(x):
assert isinstance(x, Signal)
N = x.size
v1 = np.zeros_like(x)
v2 = np.zeros_like(x)
for n in range(N):
x_1 = x[n - 1] if n - 1 >= 0 else 0
x_2 = x[n - 2] if n - 2 >= 0 else 0
v1_1 = v1[n - 1] if n - 1 >= 0 else 0
v1_2 = v1[n - 2] if n - 2 >= 0 else 0
v1[n] = 1.2 * v1_1 - 0.6 * v1_2 + 0.5 * x_1
v2_1 = v2[n - 1] if n - 1 >= 0 else 0
v2_2 = v2[n - 2] if n - 2 >= 0 else 0
v2_3 = v2[n - 3] if n - 3 >= 0 else 0
v2[n] = 1.8 * v2_1 - 1.1 * v2_2 + 0.2 * v2_3 + 0.1 * (x_1 + x_2)
y = (v1 + 0.8 * v2 * v2 - 0.6 * v1 * v1 * v2) * np.sin((v1 + v2) / 5)
output = Signal(y, fs=x.fs)
return output
def inference(self, input_, orders=None, *args, **kwargs):
if not isinstance(input_, Signal):
raise TypeError('!! Input must be an instance of Signal')
# Update Phi
self._update_Phi_naive(input_)
# Calculate output
y = self.coefs[()] * np.ones_like(input_)
pool = (self.coefs.get_indices(symmetric=False)
if orders is None else self.coefs.get_homogeneous_indices(
orders, self.memory_depth[orders + 1], symmetric=False))
for indices in pool:
y_ = self.coefs[indices] * np.ones_like(input_)
for index in indices:
y_ *= self.Phi[index]
y += y_
output = Signal(y)
output.__array_finalize__(input_)
return output
def G_n_i(self, n, i, x):
y_i = np.zeros_like(x)
# multiplicity is n - i
indices_pool = self.kernels.get_homogeneous_indices(
n - i, self.memory_depth[n - i - 1], symmetric=False)
for indices in indices_pool:
assert isinstance(indices, list) or isinstance(indices, tuple)
# Determine indices
lags = indices + indices[slice(n - 2 * i, n - i)]
x_lags = indices[slice(n - 2 * i)]
prod = self.kernels[lags]
if prod == 0: continue
for lag in x_lags:
prod *= self._delay(x, lag)
y_i += prod
output = Signal(y_i * self._get_coef(n, i))
output.__array_finalize__(x)
return output
import os import sys from PyQt5.QtCore import QSettings, QThread from PyQt5.QtWidgets import QApplication import appinfo qApp = None # instantiate() puts the QApplication obj. here windows = [] documents = [] from signals import Signal, SignalContext # signals appInstantiated = Signal() # Called when the QApplication is instantiated appStarted = Signal() # Called when the main event loop is entered aboutToQuit = Signal() # Use this and not qApp.aboutToQuit mainwindowCreated = Signal() # MainWindow mainwindowClosed = Signal() # MainWindow documentCreated = Signal() # Document documentUrlChanged = Signal() # Document documentLoaded = Signal() # Document documentModificationChanged = Signal() # Document documentClosed = Signal() # Document documentSaved = Signal() # Document documentSaving = SignalContext() # Document viewCreated = Signal() # View viewSpaceCreated = Signal() # ViewSpace (see viewmanager.py) languageChanged = Signal() # (no arguments) settingsChanged = Signal() # (no arguments)
class BitExThreadedClient(WebSocketClient):
signal_heartbeat = Signal()
signal_logged = Signal()
signal_error_login = Signal()
signal_execution_report = Signal()
signal_balance = Signal() # U3
signal_security_list = Signal() # y
signal_news = Signal() # B
signal_error = Signal() #ERROR
signal_deposit_refresh = Signal()
signal_deposit_response = Signal()
signal_process_deposit_response = Signal()
signal_verify_customer_response = Signal()
signal_verify_customer_update = Signal()
signal_connection_open = Signal()
signal_connection_closed = Signal()
signal_book_bid_clear = Signal()
signal_book_bid_new_order = Signal()
signal_book_bid_update_order = Signal()
signal_book_bid_delete_order = Signal()
signal_book_bid_delete_thru = Signal()
signal_book_offer_clear = Signal()
signal_book_offer_new_order = Signal()
signal_book_offer_update_order = Signal()
signal_book_offer_delete_order = Signal()
signal_book_offer_delete_thru = Signal()
signal_trade_clear = Signal()
signal_trade = Signal()
signal_recv = Signal()
signal_send = Signal()
is_logged = False
is_connected = False
def closed(self, code, reason):
print 'BitExThreadedClient::closed'
self.is_connected = False
self.is_logged = False
self.signal_connection_closed(self, (code, reason))
def opened(self):
self.is_connected = True
self.is_logged = False
self.signal_connection_open(self)
def send(self, payload, binary=False):
if self.is_connected:
self.signal_send(self, payload)
super(BitExThreadedClient, self).send(payload, binary)
def login(self, user, password):
if not user or not password:
raise ValueError('Invalid parameters')
loginMsg = {
'UserReqID': 'initial',
'MsgType': 'BE',
'Username': user,
'Password': password,
'UserReqTyp': '1'
}
self.send(json.dumps(loginMsg))
def testRequest(self, request_id=None):
if request_id:
self.send(json.dumps({'MsgType': '1', 'TestReqID': request_id}))
else:
self.send(
json.dumps({
'MsgType': '1',
'TestReqID': int(time.time() * 1000)
}))
def verifyCustomer(self,
client_id,
verify,
verification_data,
opt_request_id=None):
if not opt_request_id:
opt_request_id = random.randint(1, 10000000)
msg = {
'MsgType': 'B8',
'VerifyCustomerReqID': opt_request_id,
'ClientID': client_id,
'Verify': verify,
'VerificationData': verification_data
}
self.send(json.dumps(msg))
return opt_request_id
def processDeposit(self,
action,
opt_request_id=None,
opt_secret=None,
opt_depositId=None,
opt_reasonId=None,
opt_reason=None,
opt_amount=None,
opt_percent_fee=None,
opt_fixed_fee=None):
if not opt_request_id:
opt_request_id = random.randint(1, 10000000)
msg = {
'MsgType': 'B0',
'ProcessDepositReqID': opt_request_id,
'Action': action
}
if opt_secret:
msg['Secret'] = opt_secret
if opt_depositId:
msg['DepositID'] = opt_depositId
if opt_reasonId:
msg['ReasonID'] = opt_reasonId
if opt_reason:
msg['Reason'] = opt_reason
if opt_amount:
msg['Amount'] = opt_amount
if opt_percent_fee:
msg['PercentFee'] = opt_percent_fee
if opt_fixed_fee:
msg['FixedFee'] = opt_fixed_fee
self.send(json.dumps(msg))
return opt_request_id
def requestBalances(self, request_id=None, client_id=None):
if not request_id:
request_id = random.randint(1, 10000000)
msg = {'MsgType': 'U2', 'BalanceReqID': request_id}
if client_id:
msg['ClientID'] = client_id
self.send(json.dumps(msg))
return request_id
def requestMarketData(self,
request_id,
symbols,
entry_types,
subscription_type='1',
market_depth=0,
update_type='1'):
if not symbols or not entry_types:
raise ValueError('Invalid parameters')
subscribe_msg = {
'MsgType': 'V',
'MDReqID': request_id,
'SubscriptionRequestType': subscription_type,
'MarketDepth': market_depth,
'MDUpdateType': update_type, #
'MDEntryTypes': entry_types, # bid , offer, trade
'Instruments': symbols
}
self.send(json.dumps(subscribe_msg))
return request_id
def sendLimitedBuyOrder(self, symbol, qty, price, clientOrderId):
if not symbol or not qty or not qty or not price or not clientOrderId:
raise ValueError('Invalid parameters')
if qty <= 0 or price <= 0:
raise ValueError('Invalid qty or price')
msg = {
'MsgType': 'D',
'ClOrdID': str(clientOrderId),
'Symbol': symbol,
'Side': '1',
'OrdType': '2',
'Price': price,
'OrderQty': qty
}
self.send(json.dumps(msg))
def sendLimitedSellOrder(self, symbol, qty, price, clientOrderId):
if not symbol or not qty or not qty or not price or not clientOrderId:
raise ValueError('Invalid parameters')
if qty <= 0 or price <= 0:
raise ValueError('Invalid qty or price')
msg = {
'MsgType': 'D',
'ClOrdID': str(clientOrderId),
'Symbol': symbol,
'Side': '2',
'OrdType': '2',
'Price': price,
'OrderQty': qty
}
self.send(json.dumps(msg))
def sendMsg(self, msg):
self.send(json.dumps(msg))
def received_message(self, message):
msg = json.loads(str(message))
self.signal_recv(self, msg)
if msg['MsgType'] == '0':
self.signal_heartbeat(self, msg)
elif msg['MsgType'] == 'BF':
if msg['UserStatus'] == 1:
self.is_logged = True
self.signal_logged(self, msg)
else:
self.signal_error_login(self, msg)
elif msg['MsgType'] == '8':
self.signal_execution_report(self, msg)
elif msg['MsgType'] == 'U3':
self.signal_balance(self, msg)
elif msg['MsgType'] == 'y':
self.signal_security_list(self, msg)
elif msg['MsgType'] == 'B':
self.signal_news(self, msg)
elif msg['MsgType'] == 'ERROR':
self.signal_error(self, msg)
elif msg['MsgType'] == 'B1': #Process Deposit Response
self.signal_process_deposit_response(self, msg)
elif msg['MsgType'] == 'B9': #Verification Customer Response
self.signal_verify_customer_response(self, msg)
elif msg['MsgType'] == 'B11': #Verification Customer Update
self.signal_verify_customer_update(self, msg)
elif msg['MsgType'] == 'U19': #Deposit Response
self.signal_deposit_response(self, msg)
elif msg['MsgType'] == 'U23': #Deposit Refresh
self.signal_deposit_refresh(self, msg)
elif msg['MsgType'] == 'X': # Market Data Incremental Refresh
if msg['MDBkTyp'] == '3': # Order Depth
for entry in msg['MDIncGrp']:
if entry['MDEntryType'] == '0':
if entry['MDUpdateAction'] == '0':
self.signal_book_bid_new_order(self, entry)
elif entry['MDUpdateAction'] == '1':
self.signal_book_bid_update_order(self, entry)
elif entry['MDUpdateAction'] == '2':
self.signal_book_bid_delete_order(self, entry)
elif entry['MDUpdateAction'] == '3':
self.signal_book_bid_delete_thru(self, entry)
elif entry['MDEntryType'] == '1':
if entry['MDUpdateAction'] == '0':
self.signal_book_offer_new_order(self, entry)
elif entry['MDUpdateAction'] == '1':
self.signal_book_offer_update_order(self, entry)
elif entry['MDUpdateAction'] == '2':
self.signal_book_offer_delete_order(self, entry)
elif entry['MDUpdateAction'] == '3':
self.signal_book_offer_delete_thru(self, entry)
elif entry['MDEntryType'] == '2':
self.signal_trade(self, entry)
elif msg['MsgType'] == 'W': # Market Data Refresh
if msg['MarketDepth'] != 1: # Has Market Depth
self.signal_book_bid_clear(self, "")
self.signal_book_offer_clear(self, "")
self.signal_trade_clear(self, "")
for entry in msg['MDFullGrp']:
if entry['MDEntryType'] == '0':
self.signal_book_bid_new_order(self, entry)
elif entry['MDEntryType'] == '1':
self.signal_book_offer_new_order(self, entry)
elif entry['MDEntryType'] == '2':
self.signal_trade(self, entry)
