def sendMessage(self, message):
socket = QtNetwork.QLocalSocket(self)
socket.connectToServer(self._key, QtCore.QIODevice.WriteOnly)
socket.waitForConnected(self._timeout)
socket.write(bytes(message, 'UTF-8'))
socket.waitForBytesWritten(self._timeout)
socket.disconnectFromServer()
def __init__(self, id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QtNetwork.QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QtCore.QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QtNetwork.QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def send_message(**data):
socket = QtNetwork.QLocalSocket()
print("in send message, SERVER:", get_server_name())
socket.connectToServer(get_server_name(), QtCore.QIODevice.WriteOnly)
if socket.waitForConnected(500):
socket.write(json.dumps(data).encode('utf-8'))
if not socket.waitForBytesWritten(2000):
raise RuntimeError('could not write to socket: %s' %
socket.errorString())
socket.disconnectFromServer()
elif socket.error() == QtNetwork.QAbstractSocket.HostNotFoundError:
global _tries
if _tries < 10:
if not _tries:
if QtCore.QProcess.startDetached(
'python', [os.path.abspath(__file__)]):
atexit.register(lambda: send_message(shutdown=True))
else:
raise RuntimeError('could not start dialog server')
_tries += 1
QtCore.QThread.msleep(100)
send_message(**data)
else:
raise RuntimeError('could not connect to server: %s' %
socket.errorString())
else:
raise RuntimeError('could not send data: %s' % socket.errorString())
def main():
global sockets
args = parse_args()
# Try to connect to the GPU backend
app = QtCore.QCoreApplication([])
procs = []
for dbname in args.dbnames:
# Start the GPU backend
cmdline = [FASTSIM_EXEC, dbname]
if args.cpu_only:
cmdline.append('--cpu_only')
procs.append(subprocess.Popen(cmdline))
socket = QtNetwork.QLocalSocket(app)
dbname_noext = os.path.splitext(os.path.basename(dbname))[0]
sockets[dbname_noext] = socket
while not socket.isValid():
socket_name = os.path.splitext(os.path.basename(dbname))[0]
socket.connectToServer(socket_name)
time.sleep(0.3)
if args.http_interface:
handler = FastSimHTTPHandler
else:
handler = FastSimHandler
server = ThreadedHTTPServer((args.hostname, args.port), handler)
print("Running HTTP server...")
server.serve_forever()
for proc in procs:
proc.kill()
def main():
args = parse_args()
app = QtCore.QCoreApplication([])
socket = QtNetwork.QLocalSocket(app)
smiles = input("Smiles: ")
dbcount = 1
dbname = args.dbname
dbkey = args.dbkey
socket.connectToServer('gpusimilarity')
while smiles and smiles.lower() not in ('quit', 'exit'):
return_count = 20
similarity_cutoff = 0
fp_binary, _ = smiles_to_fingerprint_bin(smiles)
fp_qba = QtCore.QByteArray(fp_binary)
output_qba = QtCore.QByteArray()
output_qds = QtCore.QDataStream(output_qba, QtCore.QIODevice.WriteOnly)
output_qds.writeInt(dbcount)
output_qds.writeString(dbname.encode())
output_qds.writeString(dbkey.encode())
request_num = random.randint(0, 2**31)
output_qds.writeInt(request_num)
output_qds.writeInt(return_count)
output_qds.writeFloat(similarity_cutoff)
output_qds << fp_qba
socket.write(output_qba)
socket.flush()
socket.waitForReadyRead(30000)
output_qba = socket.readAll()
smiles = []
scores = []
ids = []
data_reader = QtCore.QDataStream(output_qba)
returned_request = data_reader.readInt()
if request_num != returned_request:
raise RuntimeError("Incorrect result ID returned!")
return_count = data_reader.readInt()
approximate_matches = data_reader.readUInt64()
for i in range(return_count):
smiles.append(data_reader.readString())
for i in range(return_count):
ids.append(data_reader.readString())
for i in range(return_count):
scores.append(data_reader.readFloat())
print("Approximate total matches: {0}, returning {1}".format(
approximate_matches, return_count))
for cid, smi, score in zip(ids, smiles, scores):
print("{0} {1}: {2}".format(cid, smi, score))
smiles = input("Smiles: ")
def setup_socket(app):
global socket
socket = QtNetwork.QLocalSocket(app)
while not socket.isValid():
socket_name = 'gpusimilarity'
socket.connectToServer(socket_name)
time.sleep(0.3)
def startMultiplexer(self, address):
if self.protocol() == 'unix':
self.multiplexer = QtNetwork.QLocalSocket(self)
self.multiplexer.connectToServer(address,
QtCore.QIODevice.WriteOnly)
else:
self.multiplexer = QtNetwork.QTcpSocket(self)
address, port = address.split(':')
self.multiplexer.connectToHost(address, int(port),
QtCore.QIODevice.WriteOnly)
def sendToInstance(self, data=''):
socket = QtNetwork.QLocalSocket()
socket.connectToServer(self.catalog, QIODevice.WriteOnly)
if socket.waitForConnected(500):
if len(data) > 0:
socket.write(data)
socket.flush()
socket.close()
return True
return False
def __init__(self, argv):
QtWidgets.QApplication.__init__(self, argv)
self._key = 'KCC'
self._timeout = 1000
self._locked = False
socket = QtNetwork.QLocalSocket(self)
socket.connectToServer(self._key, QtCore.QIODevice.WriteOnly)
if not socket.waitForConnected(self._timeout):
self._server = QtNetwork.QLocalServer(self)
# noinspection PyUnresolvedReferences
self._server.newConnection.connect(self.handleMessage)
self._server.listen(self._key)
else:
self._locked = True
socket.disconnectFromServer()
def send_message(self, message):
if self.is_running():
print(f"{self._name} is already running")
socket = QtNetwork.QLocalSocket(self)
socket.connectToServer(self._name, QtCore.QIODevice.WriteOnly)
if not socket.waitForConnected(self._timeout):
raise Exception(socket.errorString())
if not isinstance(message, bytes):
message = str(message).encode('utf-8')
socket.write(message)
if not socket.waitForBytesWritten(self._timeout):
raise Exception(socket.errorString())
socket.disconnectFromServer()
sys.exit(0)
else:
self.visibility_changed.emit(self.visibility)
def __init__(self, options, argv):
"""
Initialize Eddy.
:type options: Namespace
:type argv: list
"""
super().__init__(argv)
self.server = None
self.socket = QtNetwork.QLocalSocket()
self.socket.connectToServer(APPID)
self.running = self.socket.waitForConnected()
self.sessions = DistinctList()
self.welcome = None
if not self.isRunning() or options.tests:
self.server = QtNetwork.QLocalServer()
self.server.listen(APPID)
self.socket = None
connect(self.sgnCreateSession, self.doCreateSession)
def main():
app = QtCore.QCoreApplication([])
socket = QtNetwork.QLocalSocket(app)
smiles = input("Smiles: ")
db_name = sys.argv[1]
socket.connectToServer(db_name)
while smiles and smiles.lower() not in ('quit', 'exit'):
return_count = 20
fp_binary = smiles_to_fingerprint_bin(smiles)
fp_qba = QtCore.QByteArray(fp_binary)
output_qba = QtCore.QByteArray()
output_qds = QtCore.QDataStream(output_qba, QtCore.QIODevice.WriteOnly)
output_qds.writeInt(return_count)
output_qds << fp_qba
socket.write(output_qba)
socket.flush()
socket.waitForReadyRead(30000)
output_qba = socket.readAll()
smiles = []
scores = []
ids = []
data_reader = QtCore.QDataStream(output_qba)
for i in range(return_count):
smiles.append(data_reader.readString())
for i in range(return_count):
ids.append(data_reader.readString().decode("utf-8"))
for i in range(return_count):
scores.append(data_reader.readFloat())
for cid, smi, score in zip(ids, smiles, scores):
print("{0} {1}: {2}".format(cid, smi, score))
smiles = input("Smiles: ")
def __init__(self, argv):
"""
Initialize Eddy.
:type argv: list
"""
super().__init__(argv)
self.openFilePath = None
self.server = None
self.sessions = DistinctList()
self.started = False
self.welcome = None
# APPLICATION INFO
self.setDesktopFileName('{}.{}'.format(ORGANIZATION_REVERSE_DOMAIN,
APPNAME))
self.setOrganizationName(ORGANIZATION)
self.setOrganizationDomain(ORGANIZATION_DOMAIN)
self.setApplicationName(APPNAME)
self.setApplicationDisplayName(APPNAME)
self.setApplicationVersion(VERSION)
# PARSE COMMAND LINE ARGUMENTS
self.options = CommandLineParser()
self.options.process(argv)
# CHECK FOR A RUNNING INSTANCE
self.socket = QtNetwork.QLocalSocket()
self.socket.connectToServer(APPID)
self.running = self.socket.waitForConnected()
if not self.isRunning():
QtNetwork.QLocalServer.removeServer(APPID)
self.server = QtNetwork.QLocalServer()
self.server.listen(APPID)
self.socket = None
connect(self.sgnCreateSession, self.doCreateSession)
connect(self.aboutToQuit, self.onAboutToQuit)
def __init__(self):
super(Server, self).__init__()
self.out_socket = QtNetwork.QLocalSocket()
self.server = None
self.id = 'OpenLPDual'
def __init__(self):
self.cl = QtNetwork.QLocalSocket()
