def _RUN_():
"""
p1 = multiprocessing.Process(target = update_all_DB)
p2 = multiprocessing.Process(target = list_of_orders)
p1.start()
p2.start()
p1.join()
p2.join()
"""
update_all_DB()
orders, magic = list_of_orders()
zm = DWX_ZeroMQ_Connector()
print(
"------------------------------LOAD EXPERT ADVISOR (10 seconds)--------------------------------"
)
time.sleep(10)
print(
"----------------------------- Closing Obsolete Trades-----------------------------"
)
for m in magic:
if m not in read_from_log():
try:
pass
# zm._DWX_MTX_CLOSE_TRADES_BY_MAGIC_(m)
except:
continue
write_to_log(magic)
for order in orders:
try:
zm._DWX_MTX_NEW_TRADE_(order)
time.sleep(1)
except:
continue
def initDwx(self):
#self._symbols = [(self.p.dataname,0.01)]
self._verbose = True
self._name = "DWXData"
self._market_open = True
self._delay = 0.5
self._zmq = DWX_ZeroMQ_Connector(_host=self.p.host,
_verbose=self._verbose)
print("waiting while the connection is initialized...")
time.sleep(3)
print("getting all open trades...")
self._zmq._set_response_() #Clear de response
self._zmq._DWX_MTX_GET_ALL_OPEN_TRADES_()
while not self._zmq._get_response_():
time.sleep(1)
respondZmq = self._zmq._get_response_()
print("close all open trades...")
self._zmq._DWX_MTX_CLOSE_TRADES_BY_MAGIC_(123456)
while not self._zmq._get_response_():
time.sleep(1)
respondZmq = self._zmq._get_response_()
def trade_sender(_exec_dict):
_lock = threading.Lock()
dwx = DWX_ZeroMQ_Connector()
_lock.acquire()
response = dwx._DWX_MTX_NEW_TRADE_(_order=_exec_dict)
_lock.release()
def _RUN_():
try:
update_all_DB()
except:
pass
orders = list_of_orders()
zm = DWX_ZeroMQ_Connector()
print(
"------------------------------LOAD EXPERT ADVISOR (10 seconds)--------------------------------"
)
time.sleep(15)
for order in orders:
try:
zm._DWX_MTX_NEW_TRADE_(order)
time.sleep(1)
except:
continue
def __init__(self,
Pool_Limit=100,
Update_Frequency=5,
_Time_Out=4,
_Refresh=0.3,
_TimeZone=1,
Factors=None):
self.Pool_Limit = Pool_Limit
self.Update_Frequency = Update_Frequency
self._Time_Out = _Time_Out
self._Refresh = _Refresh
self._TimeZone = _TimeZone
self._Holding = {}
self._Price_Buffer = pd.DataFrame()
self._Volume_Buffer = pd.DataFrame()
self._lock = Lock()
self._Asset_Watchlist = []
self._Online_Auditor = None
self._Online_Appraiser = None
self._Holding_Port = DWX_ZeroMQ_Connector(_verbose=False,
_PUSH_PORT=32001,
_PULL_PORT=32002,
_SUB_PORT=32000)
self._Data_Port = DWX_ZeroMQ_Connector(_verbose=False,
_PUSH_PORT=32553,
_PULL_PORT=32554,
_SUB_PORT=32555)
self._Execution_Port = DWX_ZeroMQ_Connector(_verbose=False)
self._Check_Connection_status()
self._DB_Worker = DB_Operator('MT4_Database')
self.Factors = Factors
def __init__(self, _name="DEFAULT_STRATEGY", # Name
_symbols=[('EURUSD',0.01), # List of (Symbol,Lotsize) tuples
('AUDNZD',0.01),
('NDX',0.10),
('UK100',0.1),
('GDAXI',0.01),
('XTIUSD',0.01),
('SPX500',1.0),
('STOXX50E',0.10),
('XAUUSD',0.01)],
_broker_gmt=3, # Darwinex GMT offset
_verbose=False): # Print ZeroMQ messages
self._name = _name
self._symbols = _symbols
self._broker_gmt = _broker_gmt
# Not entirely necessary here.
self._zmq = DWX_ZeroMQ_Connector(_verbose=_verbose)
# Modules
self._execution = DWX_ZMQ_Execution(self._zmq)
self._reporting = DWX_ZMQ_Reporting(self._zmq)
import time
from DWX_ZeroMQ_Connector_v2_0_1_RC8 import DWX_ZeroMQ_Connector
_zmq = DWX_ZeroMQ_Connector()
_zmq._DWX_MTX_SUBSCRIBE_MARKETDATA_()
for i in range(100):
print(_zmq._Market_Data_DB)
time.sleep(1)
""" Az a nagy lófasz helyzet van, hogy valamiért a kliens nem kap vissza adatot, lehet hogy neki kéne kérnie? """
class Live_Trade_App():
def __init__(self,
Pool_Limit=100,
Update_Frequency=5,
_Time_Out=4,
_Refresh=0.3,
_TimeZone=1,
Factors=None):
self.Pool_Limit = Pool_Limit
self.Update_Frequency = Update_Frequency
self._Time_Out = _Time_Out
self._Refresh = _Refresh
self._TimeZone = _TimeZone
self._Holding = {}
self._Price_Buffer = pd.DataFrame()
self._Volume_Buffer = pd.DataFrame()
self._lock = Lock()
self._Asset_Watchlist = []
self._Online_Auditor = None
self._Online_Appraiser = None
self._Holding_Port = DWX_ZeroMQ_Connector(_verbose=False,
_PUSH_PORT=32001,
_PULL_PORT=32002,
_SUB_PORT=32000)
self._Data_Port = DWX_ZeroMQ_Connector(_verbose=False,
_PUSH_PORT=32553,
_PULL_PORT=32554,
_SUB_PORT=32555)
self._Execution_Port = DWX_ZeroMQ_Connector(_verbose=False)
self._Check_Connection_status()
self._DB_Worker = DB_Operator('MT4_Database')
self.Factors = Factors
def Run(self):
self._Holding_Updater = Thread(name='Holding Updater',
target=self._Current_Holding,
args=(self.Update_Frequency, ))
self._Holding_Updater.daemon = True
self._Holding_Updater.start()
self._Risk_Updater = Thread(name='Risk Updater',
target=self._Risk_Performance_Monitor,
args=(self.Update_Frequency, ))
self._Risk_Updater.daemon = True
self._Risk_Updater.start()
self._Random_Trader = Thread(name='Rand Trader',
target=self._Baby_Strategy,
args=(self.Update_Frequency, ))
self._Random_Trader.daemon = True
self._Random_Trader.start()
self._Price_Ledger = Thread(name='Price Ledger',
target=self._Snapshots,
args=(self.Update_Frequency, ))
self._Price_Ledger.daemon = True
self._Price_Ledger.start()
def _Current_Holding(self, every):
while self._Market_Open:
self._Holding_Port._set_response_(None)
self._Holding_Port._DWX_MTX_GET_ALL_OPEN_TRADES_()
_wait_start = pd.to_datetime('now')
#To prevent the case of waiting forever if never hear back for any reason
while self._Holding_Port._valid_response_('zmq') == False:
self._Holding_Port._DWX_MTX_GET_ALL_OPEN_TRADES_()
sleep(self._Refresh)
if (pd.to_datetime('now') -
_wait_start).total_seconds() > (self._Time_Out):
print('... Holding Request Never Heard Back')
break
if self._Holding_Port._valid_response_('zmq'):
_Response = self._Holding_Port._get_response_()
# print('Hear Back Success')
if ('_trades' in _Response.keys()
and len(_Response['_trades']) > 0):
New_Holding = pd.DataFrame(
_Response['_trades']).transpose()
Asset = list(pd.unique(New_Holding['_symbol']))
self._Asset_Watchlist = list(
set(Asset + self._Asset_Watchlist))
self._Holding = {}
self._Volume_Multiplier = {}
self._Holding['Cash'] = _Response['_Equity']
for idx, row in New_Holding.iterrows():
ls = 1 if row['_type'] == 0 else -1
quantity = row['_Units_lot'] * row['_lots'] * ls
if row['_symbol'] not in self._Holding:
self._Holding[row['_symbol']] = quantity
self._Volume_Multiplier[
row['_symbol']] = row['_Units_lot']
else:
self._Holding[row['_symbol']] += quantity
self._Holding['Cash'] -= quantity * row['_open_price']
self._HDF = New_Holding
sleep(every)
def _Risk_Performance_Monitor(self, every):
Last_Postion = {}
while self._Market_Open:
if bool(self._Holding) == False:
print(
'Waiting for the first Holding info to be retrieved first')
else:
if Last_Postion != self._Holding:
Last_Postion = self._Holding.copy()
if self._Price_Buffer.shape[0] < 500:
self._Online_Auditor = Risk_Advisor(
holding_info=Last_Postion,
frequency='Minutely',
Test_day='live',
Graphic=False,
Volume_Multiplier=self._Volume_Multiplier)
self._Online_Appraiser = Performance_Advisor(
holding_info=Last_Postion,
frequency='Minutely',
Test_day='live',
Factors=self.Factors,
Graphic=False,
Volume_Multiplier=self._Volume_Multiplier)
else:
self._Online_Auditor = Risk_Advisor(
holding_info=Last_Postion,
_Price=self._Price_Buffer,
_Volume=self._Volume_Buffer,
Test_day='live',
Graphic=False)
print(self._Holding)
self._Online_Auditor.All_Live_Printers()
Vol_Att = self._Online_Auditor.Risk_Contribution(latest=False)
if any(Vol_Att < 0) == False:
plt.pie(Vol_Att.values,
labels=list(Vol_Att.columns),
autopct='%1.1f%%')
else:
Vol_Att.plot.bar()
loadings = self._Online_Appraiser.Show_Loading(live=True)
print(" ")
print('The loadings of factors ', self.Factors,
'are as follows: ')
print(loadings)
plt.show()
sleep(every)
clear_output()
def _Baby_Strategy(self, every):
while self._Market_Open:
if bool(self._Holding) == False:
print(
'Waiting for the first Holding info to be retrieved first')
else:
for idx, row in self._HDF.iterrows():
if row['_pnl'] > 20:
symbol = row['_symbol']
action = 'CLOSE'
tkt = idx
self.Trade_Execute(action=action,
symbol=symbol,
tkt=tkt)
Open_Ast = random.sample(self._Asset_Watchlist, 1)[0]
ls = random.randint(0, 1)
quantity = 0.1
self.Trade_Execute('OPEN', Open_Ast, _type=ls, lot=quantity)
sleep(every)
def Trade_Execute(self, action, symbol=None, **kwarg):
if action == 'CLOSE_All':
_check = '_response_value'
self._Execution_Port._DWX_MTX_CLOSE_ALL_TRADES_()
else:
self._Execution_Port._set_response_(None)
if symbol is None:
print('You forgot to provide a symbol to trade!')
self._Execution_Port._New_Order(action=action,
symbol=symbol,
**kwarg)
_wait = pd.to_datetime('now')
if action == 'OPEN':
_check = '_action'
elif action == 'CLOSE':
_check = '_response_value'
while self._Execution_Port._valid_response_('zmq') == False:
sleep(self._Refresh)
if (pd.to_datetime('now') -
_wait).total_seconds() > (self._Time_Out):
print('...Trade Execution Never Heard Back')
break
if self._Execution_Port._valid_response_('zmq'):
# print('... executed successfully')
if _check in self._Execution_Port._get_response_().keys():
return self._Execution_Port._get_response_()
return None
def _Price_Buffering(self, symbol=None, stop=False):
if stop:
self._Data_Port._DWX_MTX_UNSUBSCRIBE_ALL_MARKETDATA_REQUESTS_()
else:
for items in symbol:
self._Data_Port._DWX_MTX_SUBSCRIBE_MARKETDATA_(items)
def _Snapshots(self, every=10, symbol=None):
if self._Price_Buffer.shape[0] == 0:
print('Starting to Record Price ... ')
if symbol == None:
symbol = self._Asset_Watchlist
self._Price_Buffering(symbol=symbol)
while self._Market_Open:
self._Price_Buffer = pd.DataFrame()
sleep(self._Refresh)
while self._Price_Buffer.shape[0] <= self.Pool_Limit:
sleep(every)
self._Data_Port._reset_DB_()
if bool(self._Data_Port._Market_Data_DB):
snapshot = pd.DataFrame.from_dict(
self._Data_Port._Market_Data_DB)
snapshot.index = pd.to_datetime(
snapshot.index).round('1s') + Timedelta(
self._TimeZone, 'h')
snapshot = pd.DataFrame(snapshot[symbol].to_list(),
index=snapshot.index)
snapshot.columns = ['Bid', 'Ask', 'Volume']
self._Price_Buffer = pd.concat(
[self._Price_Buffer, snapshot]).drop_duplicates()
self._DB_Worker.DF_to_new_table('Streaming_Price')
self._Price_Buffering(stop=True)
self._DB_Worker.disconnect()
def Print_Price_Buffer(self):
return self._Price_Buffer
def _Check_Connection_status(self):
self._Execution_Port._DWX_ZMQ_HEARTBEAT_()
self._Holding_Port._DWX_ZMQ_HEARTBEAT_()
self._Data_Port._DWX_ZMQ_HEARTBEAT_()
_wait_start = pd.to_datetime('now')
while (pd.to_datetime('now') - _wait_start).total_seconds() < 3:
sleep(self._Refresh)
if self._Execution_Port._valid_response_('zmq'):
_Response_1 = self._Execution_Port._get_response_()
if _Response_1['_response'] != 'loud and clear!':
Fail = 1
else:
Fail = None
print('Execution Port Connected. ')
else:
self._Execution_Port._DWX_ZMQ_HEARTBEAT_()
Fail = 1
if self._Data_Port._valid_response_('zmq'):
_Response_2 = self._Data_Port._get_response_()
if _Response_2['_response'] != 'loud and clear!':
Fail = 2
else:
print('Data Port Connected. ')
else:
self._Data_Port._DWX_ZMQ_HEARTBEAT_()
Fail = 2
if self._Holding_Port._valid_response_('zmq'):
_Response_3 = self._Holding_Port._get_response_()
if _Response_3['_response'] != 'loud and clear!':
Fail = 3
else:
print('Holding Port Connected. ')
else:
self._Holding_Port._DWX_ZMQ_HEARTBEAT_()
Fail = 3
if Fail is None:
print('Good morning sir, PARIS is online ')
self._Market_Open = True
return None
if Fail == 1:
print('Please Check the configuration of the Execution port')
elif Fail == 2:
print('Please Check the configuration of the Data port')
elif Fail == 3:
print('Please Check the configuration of the Holding port')
def _Set_Asset(self, Names):
self._Asset_Watchlist.extend(Names)
def _Close_Market(self):
self._Market_Open = False
import sys
sys.path.append(
"C:\\Users\\otkin\\dwx_connector\\dwx-zeromq-connector\\v2.0.1\\python\\api"
)
from DWX_ZeroMQ_Connector_v2_0_1_RC8 import DWX_ZeroMQ_Connector
_zmq = DWX_ZeroMQ_Connector()
# _zmq._DWX_MTX_SUBSCRIBE_MARKETDATA_(DWX_ZeroMQ_Connector, 'EURUSD')
my_trade = {
'_lots': 0.05,
'_SL': 250,
'_TP': 750,
'_comment': 'we made a trade!'
}
_zmq._DWX_MTX_NEW_TRADE_(_order=my_trade)
# Notes:
# MQL4 location C:\Users\otkin\AppData\Roaming\MetaQuotes\Terminal\3B534B10135CFEDF8CD1AAB8BD994B13\MQL4
# mql-zmq-master.zip C:\Users\otkin\dwx_connector
class DWXStore(with_metaclass(MetaSingleton, object)):
frompackages = (('influxdb', [('InfluxDBClient', 'idbclient')]),
('influxdb.exceptions', 'InfluxDBClientError'))
params = (('influxdb', False), ('historical', False),
('host', '127.0.0.1'), ('hostdb', None), ('port', '8086'),
('username', None), ('password', None), ('database', None))
def __init__(self):
super(DWXStore, self).__init__()
self._connected = False # modules/objects created
if not self.p.historical or (self.p.startdate and not self._influxdb):
self.initDwx()
self._connected = True
if self.p.influxdb:
self.initInflux()
self._connected = True
def initDwx(self):
#self._symbols = [(self.p.dataname,0.01)]
self._verbose = True
self._name = "DWXData"
self._market_open = True
self._delay = 0.5
self._zmq = DWX_ZeroMQ_Connector(_host=self.p.host,
_verbose=self._verbose)
print("waiting while the connection is initialized...")
time.sleep(3)
print("getting all open trades...")
self._zmq._set_response_() #Clear de response
self._zmq._DWX_MTX_GET_ALL_OPEN_TRADES_()
while not self._zmq._get_response_():
time.sleep(1)
respondZmq = self._zmq._get_response_()
print("close all open trades...")
self._zmq._DWX_MTX_CLOSE_TRADES_BY_MAGIC_(123456)
while not self._zmq._get_response_():
time.sleep(1)
respondZmq = self._zmq._get_response_()
def initInflux(self):
_hostdb = self.p.hostdb if self.p.hostdb else self.p.host
try:
self._ndb = idbclient(_hostdb, self.p.port, self.p.username,
self.p.password, self.p.database)
except InfluxDBClientError as err:
print('Failed to establish connection to InfluxDB: %s' % err)
'''Base class for all Stores'''
_started = False
def getdata(self, *args, **kwargs):
'''Returns ``DataCls`` with args, kwargs'''
data = self.DataCls(*args, **kwargs)
data._store = self
return data
@classmethod
def getbroker(cls, *args, **kwargs):
'''Returns broker with *args, **kwargs from registered ``BrokerCls``'''
broker = cls.BrokerCls(*args, **kwargs)
broker._store = cls
return broker
BrokerCls = None # broker class will autoregister
DataCls = None # data class will auto register
def start(self, data=None, broker=None):
if not self._started:
self._started = True
self.notifs = collections.deque()
self.datas = list()
self.broker = None
if data is not None:
self._cerebro = self._env = data._env
self.datas.append(data)
if self.broker is not None:
if hasattr(self.broker, 'data_started'):
self.broker.data_started(data)
elif broker is not None:
self.broker = broker
def stop(self):
pass
def put_notification(self, msg, *args, **kwargs):
self.notifs.append((msg, args, kwargs))
def get_notifications(self):
'''Return the pending "store" notifications'''
self.notifs.append(None) # put a mark / threads could still append
return [x for x in iter(self.notifs.popleft, None)]
from DWX_ZeroMQ_Connector_v2_0_1_RC8 import DWX_ZeroMQ_Connector
OP_BUY = 0
OP_SELL = 1
OP_BUY_LIMIT = 2
OP_SELL_LIMIT = 3
OP_BUY_STOP = 4
OP_SELL_STOP = 5
zmq = DWX_ZeroMQ_Connector()
my_trade = zmq._generate_default_order_dict()
my_trade['_type'] = OP_SELL_LIMIT
my_trade['_symbol'] = 'EURCHF'
my_trade['_price'] = 1.06
zmq._DWX_MTX_NEW_TRADE_(_order=my_trade)
resp = zmq._thread_data_output
print(f"response={resp}")
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 29 21:38:44 2020
@author: farhad
"""
from DWX_ZeroMQ_Connector_v2_0_1_RC8 import DWX_ZeroMQ_Connector
a = DWX_ZeroMQ_Connector()
a._generate_default_order_dict()
a._DWX_MTX_GET_ALL_OPEN_TRADES_()
a._DWX_MTX_MODIFY_TRADE_BY_TICKET_(128844168, 200, 200)
a._DWX_MTX_CLOSE_TRADE_BY_TICKET_(128844168)
a._DWX_MTX_NEW_TRADE_(
) # when this send with no args, default order dict will send
a._DWX_MTX_CLOSE_TRADES_BY_MAGIC_(123456)
#subscribe to hystorical data of mt4 :
a._DWX_MTX_SEND_MARKETDATA_REQUEST_()
#subscribe to real market data :
# this will fill a dict of our object named Market_Data_DB
a._DWX_MTX_SUBSCRIBE_MARKETDATA_('EURUSD')
print("response is: ")
print(a._get_response_())
import random import numpy as np from DWX_ZeroMQ_Connector_v2_0_1_RC8 import DWX_ZeroMQ_Connector _zmq = DWX_ZeroMQ_Connector() #print(_zmq._generate_default_order_dict()) print(_zmq.remote_recv)
def job(x,
pred,
op,
symbol="GBPUSD",
pips=1000,
loscut=10,
spread=0.01,
tp=30,
sl=70,
lot_size=0.5,
use_pred=False):
##########################################################################
_zmq = DWX_ZeroMQ_Connector()
# pred = pred[-300::]
length = len(pred)
x = x[-length::, ]
ud = []
pre_ud = []
pre_ud2 = []
for i in range(1, len(pred)):
ud.extend(np.where(x[i] > x[i - 1], "buy", "sell"))
pre_ud.extend(np.where(pred[i] < x[i - 1], "buy", "sell"))
pre_ud2.extend(np.where(pred[i] > pred[i - 1], "buy", "sell"))
print("accuracy = ", sklearn.metrics.accuracy_score(ud, pre_ud))
pre_ud2 = pre_ud
x = op[-len(pre_ud)::]
##########################################################################
##########################################################################
length = len(trade)
if length == 0:
if pre_ud[-1] == "buy" and pre_ud2[-1] == "buy":
# _type = 0 <== "buy"
_zmq._DWX_MTX_SEND_COMMAND_(_symbol=symbol,
_lots=lot_size,
_SL=sl,
_TP=tp)
bs.append(np.float(x[-1]) - spread)
trade.append("buy")
elif pre_ud[-1] == "sell" and pre_ud2[-1] == "sell":
# _type = 1 <== "sell"
_zmq._DWX_MTX_SEND_COMMAND_(_symbol=symbol,
_lots=lot_size,
_type=1,
_SL=sl,
_TP=tp)
bs.append(np.float(x[-1]) + spread)
trade.append("sell")
else:
if pre_ud[-1] == "buy" and pre_ud2[-1] == "buy" and trade[-1] == "buy":
pip = (np.float(x[-1]) - bs[-1]) * pips
if pip <= -loscut:
_zmq._DWX_MTX_CLOSE_ALL_TRADES_()
trade.append("buy")
elif pre_ud[-1] == "buy" and pre_ud2[-1] == "buy" and trade[
-1] == "sell":
_zmq._DWX_MTX_CLOSE_ALL_TRADES_()
_zmq._DWX_MTX_SEND_COMMAND_(_symbol=symbol,
_lots=lot_size,
_SL=sl,
_TP=tp)
bs.append(np.float(x[-1]) - spread)
trade.append("buy")
elif pre_ud[-1] == "sell" and pre_ud2[-1] == "sell" and trade[
-1] == "sell":
pip = (bs[-1] - np.float(x[-1])) * pips
if pip <= -loscut:
_zmq._DWX_MTX_CLOSE_ALL_TRADES_()
print("pip = ", pip)
trade.append("sell")
elif pre_ud[-1] == "sell" and pre_ud2[-1] == "sell" and trade[
-1] == "buy":
_zmq._DWX_MTX_CLOSE_ALL_TRADES_()
_zmq._DWX_MTX_SEND_COMMAND_(_symbol=symbol,
_lots=lot_size,
_type=1,
_SL=sl,
_TP=tp)
bs.append(np.float(x[-1]) + spread)
trade.append("sell")
print("trade length = ", len(trade))
return trade, bs
# _zmq._DWX_MTX_SEND_COMMAND_(_symbol=symbol,_lots=lot_size,_SL=sl,_TP=100000)
##############################################################################
# use trade = job(trade=trade) #
##############################################################################