def write(self, widget):
self.settings.beginGroup(widget.objectName())
if isinstance(widget, QtWidgets.QAbstractItemView):
self.settings.setValue("selectionMode", widget.selectionMode())
if isinstance(widget, QtWidgets.QTableWidget):
self.settings.setValue("rowCount", widget.rowCount())
self.settings.setValue("columnCount", widget.columnCount())
items = QtCore.QByteArray()
stream = QtCore.QDataStream(items, QtCore.QIODevice.WriteOnly)
for i in range(widget.rowCount()):
for j in range(widget.columnCount()):
it = widget.item(i, j)
if it is not None:
stream.writeInt(i)
stream.writeInt(j)
stream << it
self.settings.setValue("items", items)
selecteditems = QtCore.QByteArray()
stream = QtCore.QDataStream(
selecteditems, QtCore.QIODevice.WriteOnly
)
for it in widget.selectedItems():
stream.writeInt(it.row())
stream.writeInt(it.column())
self.settings.setValue("selecteditems", selecteditems)
self.settings.endGroup()
def read(self, widget):
self.settings.beginGroup(widget.objectName())
if isinstance(widget, QtWidgets.QAbstractItemView):
selectionMode = self.settings.value(
"selectionMode", type=QtWidgets.QAbstractItemView.SelectionMode
)
widget.setSelectionMode(selectionMode)
if isinstance(widget, QtWidgets.QTableWidget):
rowCount = self.settings.value("rowCount", type=int)
columnCount = self.settings.value("columnCount", type=int)
widget.setRowCount(rowCount)
widget.setColumnCount(columnCount)
items = self.settings.value("items")
if items is None:
self.read_defaults(widget)
else:
stream = QtCore.QDataStream(items, QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
it = QtWidgets.QTableWidgetItem()
i = stream.readInt()
j = stream.readInt()
stream >> it
widget.setItem(i, j, it)
selecteditems = self.settings.value("selecteditems")
stream = QtCore.QDataStream(
selecteditems, QtCore.QIODevice.ReadOnly
)
while not stream.atEnd():
i = stream.readInt()
j = stream.readInt()
it = widget.item(i, j)
if it is not None:
it.setSelected(True)
self.settings.endGroup()
def read_settings(self):
settings = QtCore.QSettings("data.ini", QtCore.QSettings.IniFormat)
childrens = self.findChildren(QtWidgets.QWidget)
for children in childrens:
if isinstance(children,
QtWidgets.QListWidget) and children.objectName():
settings.beginGroup(children.objectName())
items = settings.value("items")
selecteditems = settings.value("selecteditems")
selectionMode = settings.value(
"selectionMode",
type=QtWidgets.QAbstractItemView.SelectionMode)
children.setSelectionMode(selectionMode)
# In the first reading the initial values must be established
if items is None:
if children.objectName() == "listwidget_1":
for i in range(10):
children.addItem(QtWidgets.QListWidgetItem(str(i)))
elif children.objectName() == "listwidget_2":
for i in "abcdefghijklmnopqrstuvwxyz":
children.addItem(QtWidgets.QListWidgetItem(i))
else:
stream = QtCore.QDataStream(items,
QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
it = QtWidgets.QListWidgetItem()
stream >> it
children.addItem(it)
stream = QtCore.QDataStream(selecteditems,
QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
row = stream.readInt()
it = children.item(row)
it.setSelected(True)
settings.endGroup()
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 restoreSession(self):
fname, _ = QFileDialog.getOpenFileName(
self, 'Select session to restore',
(os.path.join(os.path.join(os.path.expanduser('~')), 'Documents',
'Tracker')), 'INI files (*.ini)')
if not os.path.exists(fname):
return
self.settings = QSettings(fname, QSettings.IniFormat)
for name, obj in inspect.getmembers(self):
if isinstance(obj, QLineEdit):
name = obj.objectName()
value = (self.settings.value(name))
obj.setText(value) # restore
# if isinstance(obj, QCheckBox):
# name = obj.objectName()
# value = self.settings.value(name).lower()
# if value != None:
# obj.setChecked(strtobool(value))
# else:
# continue
# if isinstance(obj, QGroupBox):
# name = obj.objectName()
# value = self.settings.value(name).lower()
# if value != None:
# obj.setChecked(strtobool(value))
# else:
# continue
if isinstance(obj, QTableWidget):
rowCount = self.settings.value("rowCount", type=int)
columnCount = self.settings.value("columnCount", type=int)
obj.setRowCount(rowCount)
obj.setColumnCount(columnCount)
items = self.settings.value("items")
if items is None:
continue
else:
stream = QtCore.QDataStream(items,
QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
it = QtWidgets.QTableWidgetItem()
i = stream.readInt()
j = stream.readInt()
stream >> it
obj.setItem(i, j, it)
selecteditems = self.settings.value("selecteditems")
stream = QtCore.QDataStream(selecteditems,
QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
i = stream.readInt()
j = stream.readInt()
it = obj.item(i, j)
if it is not None:
it.setSelected(True)
self.combo()
def done(self):
# writing file
self.__logger.debug("writing the replay")
self.__logger.debug(self.uid)
replay_info = self.db.replay_info(self.uid)
if replay_info is not None:
self.replayInfo.update(replay_info)
# Construct the path where the replay is stored
path = config['global']['content_path'] + "vault/replay_vault"
dirsize = 100
depth = 5
i = depth
dirname = path
while i > 1:
dirname = dirname + "/" + str((self.uid / (dirsize**(i - 1))) % dirsize)
i = i - 1
filename = dirname + "/" + str(self.uid) + ".fafreplay"
self.__logger.debug("filename: " + filename)
if not os.path.exists(dirname):
os.makedirs(dirname)
writeFile = QtCore.QFile(filename)
if writeFile.open(QtCore.QIODevice.WriteOnly):
writeFile.write(json.dumps(self.replayInfo))
writeFile.write('\n')
replayData = QtCore.QByteArray()
replayDataQByte = QtCore.QByteArray()
replayDataStream = QtCore.QDataStream(replayDataQByte, QtCore.QIODevice.WriteOnly)
replayStream = QtCore.QDataStream(self.getReplayData(), QtCore.QIODevice.ReadOnly)
replayStream.device().seek(0)
while not replayStream.atEnd():
timePacket = replayStream.readDouble()
lenData = replayStream.readUInt32()
datas = replayStream.readRawData(lenData)
replayData.append(datas)
replayDataStream.writeUInt32(replayData.size())
replayDataStream.writeRawData(zlib.compress(replayData.data(), 9))
writeFile.write(replayDataQByte.toBase64())
writeFile.close()
self.db.add_replay_entry(self.uid)
self.__logger.debug("fafreplay written")
def __init__(self):
self.smi_byte_data = [QtCore.QByteArray()]
self.smi_qds = QtCore.QDataStream(self.smi_byte_data[0],
QtCore.QIODevice.WriteOnly)
self.id_byte_data = [QtCore.QByteArray()]
self.id_qds = QtCore.QDataStream(self.id_byte_data[0],
QtCore.QIODevice.WriteOnly)
self.fp_byte_data = [QtCore.QByteArray()]
self.fp_qds = QtCore.QDataStream(self.fp_byte_data[0],
QtCore.QIODevice.WriteOnly)
def main():
args = parse_args()
qf = QtCore.QFile(args.outputfile)
qf.open(QtCore.QIODevice.WriteOnly)
count = 0
print("Processing file {0}".format(args.inputfile))
input_fhandle = gzip.open(args.inputfile, 'rb')
print("Processing Smiles...")
smi_byte_data = QtCore.QByteArray()
smi_qds = QtCore.QDataStream(smi_byte_data, QtCore.QIODevice.WriteOnly)
id_byte_data = QtCore.QByteArray()
id_qds = QtCore.QDataStream(id_byte_data, QtCore.QIODevice.WriteOnly)
fp_byte_data = QtCore.QByteArray()
fp_qds = QtCore.QDataStream(fp_byte_data, QtCore.QIODevice.WriteOnly)
print("Reading lines...")
read_bytes = 10000000
count = 0
lines = input_fhandle.readlines(read_bytes)
print(len(lines))
while lines != []:
rows = gpusim_utils.split_lines_add_fp(lines,
dview=dview,
trust_smiles=args.trustSmiles)
filtered_rows = [row for row in rows if row is not None]
count += len(filtered_rows)
for row in filtered_rows:
if row is None:
continue
smi_qds.writeString(row[0])
id_qds.writeString(row[1])
fp_qds.writeRawData(row[2])
print("Processed {0} rows".format(count))
lines = input_fhandle.readlines(read_bytes)
qds = QtCore.QDataStream(qf)
# Set version so that files will be usable cross-release
qds.setVersion(QtCore.QDataStream.Qt_5_2)
size = QtCore.QSize(gpusim_utils.BITCOUNT, count)
qds << size
qds << fp_byte_data
qds << smi_byte_data
qds << id_byte_data
qf.close()
def main():
args = parse_args()
qf = QtCore.QFile(args.outputfile)
qf.open(QtCore.QIODevice.WriteOnly)
qds = QtCore.QDataStream(qf)
# Set version so that files will be usable cross-release
qds.setVersion(QtCore.QDataStream.Qt_5_2)
smi_byte_data = []
id_byte_data = []
fp_byte_data = []
count = 0
bitcount = None
for dbname in args.dbnames:
dbf = QtCore.QFile(dbname)
dbf.open(QtCore.QIODevice.ReadOnly)
dbds = QtCore.QDataStream(dbf)
version = dbds.readInt()
if version != DATABASE_VERSION:
raise RuntimeError("Input database not compatible with this "
"version of GPUSim")
in_bitcount = dbds.readInt()
in_count = dbds.readInt()
if bitcount is None:
bitcount = in_bitcount
elif bitcount != in_bitcount:
raise ValueError("Can't mix databases with different "
"fingerprint bitcounts")
for qba_list in [fp_byte_data, smi_byte_data, id_byte_data]:
list_len = dbds.readInt()
for i in range(list_len):
byte_data = QtCore.QByteArray()
dbds >> byte_data
qba_list.append(byte_data)
count += in_count
print("Writing new database with {0} entries.".format(count))
qds.writeInt(DATABASE_VERSION)
qds.writeInt(bitcount)
qds.writeInt(count)
for qba_list in [fp_byte_data, smi_byte_data, id_byte_data]:
qds.writeInt(len(qba_list))
for byte_data in qba_list:
qds << byte_data
qf.close()
def save_gui(ui, settings):
for name, obj in inspect.getmembers(ui):
if isinstance(obj, QtWidgets.QComboBox):
name = obj.objectName()
index = obj.currentIndex()
text = obj.itemText(index)
settings.setValue(name, text)
if isinstance(obj, QtWidgets.QLineEdit):
name = obj.objectName()
value = obj.text()
settings.setValue(name, value)
if isinstance(obj, QtWidgets.QProgressBar):
name = obj.objectName()
value = obj.value()
settings.setValue(name, value)
if isinstance(obj, QtWidgets.QCheckBox):
name = obj.objectName()
state = obj.isChecked()
settings.setValue(name, state)
if isinstance(obj, QtWidgets.QTabWidget):
name = obj.objectName()
index = obj.currentIndex()
settings.setValue(name, index)
if isinstance(obj, QtWidgets.QTableWidget):
name = obj.objectName()
data = QtCore.QByteArray()
stream = QtCore.QDataStream(data, QtCore.QIODevice.WriteOnly)
rowCount = obj.rowCount()
columnCount = obj.columnCount()
stream.writeInt(rowCount)
stream.writeInt(columnCount)
for row in range(rowCount):
stream.writeQString(obj.verticalHeaderItem(row).text())
for col in range(columnCount):
stream.writeQString(obj.horizontalHeaderItem(col).text())
for row in range(rowCount):
for col in range(columnCount):
if (obj.item(row, col) is not None):
stream.writeQString(obj.item(row, col).text())
else:
cell_obj = obj.cellWidget(row, col)
if isinstance(cell_obj, QtWidgets.QComboBox):
cell_name = cell_obj.objectName()
cell_index = cell_obj.currentIndex()
cell_text = cell_obj.itemText(cell_index)
settings.setValue(cell_name, cell_text)
stream.writeQString(cell_name)
if isinstance(cell_obj, QtWidgets.QCheckBox):
cell_name = cell_obj.objectName()
cell_state = cell_obj.isChecked()
settings.setValue(cell_name, cell_state)
stream.writeQString(cell_name)
settings.setValue('{}/data'.format(name), data)
def _writeToServer(self, action, *args, **kw):
logger.debug(
("writeToServer(" + action + ", [" + ', '.join(args) + "])"))
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.ReadWrite)
out.setVersion(QtCore.QDataStream.Qt_4_2)
out.writeUInt32(0)
out.writeQString(action)
for arg in args:
if type(arg) is int:
out.writeInt(arg)
elif isinstance(arg, str):
out.writeQString(arg)
elif type(arg) is float:
out.writeFloat(arg)
elif type(arg) is list:
out.writeQVariantList(arg)
else:
logger.warning("Uninterpreted Data Type: " + str(type(arg)) +
" of value: " + str(arg))
out.writeQString(str(arg))
out.device().seek(0)
out.writeUInt32(block.size() - 4)
self.replayVaultSocket.write(block)
def decode_data(encoded_data):
"""
Decode QbyteArrayData generated when drop items in table/tree/list view
Parameters
----------
encoded_data: QByteArray
Encoded data of the mime data to be dropped
Returns
-------
data: list
list of dict whose key is the QtRole in the Model, and the value a QVariant
"""
data = []
ds = QtCore.QDataStream(encoded_data, QtCore.QIODevice.ReadOnly)
while not ds.atEnd():
row = ds.readInt32()
col = ds.readInt32()
map_items = ds.readInt32()
item = {}
for ind in range(map_items):
key = ds.readInt32()
value = QVariant()
ds >> value
item[QtCore.Qt.ItemDataRole(key)] = value.value()
data.append(item)
return data
def calculate_polygons(self):
"""
Convert the raw data into a mesh plot
"""
# Then generate a list of polygons for finite regions
logger.debug("Generating Polygons")
self.polygons.clear()
xsize, ysize = self.x_axis.shape[0] - 1, self.y_axis.shape[1] - 1
for (x, y) in itertools.product(range(xsize), range(ysize)):
buf = bytearray(4 + 5 * 16)
buf[3] = 5
struct.pack_into('>2d', buf, 4, self.x_axis[x, y], self.y_axis[x,
y])
struct.pack_into('>2d', buf, 20, self.x_axis[x + 1, y],
self.y_axis[x + 1, y])
struct.pack_into('>2d', buf, 36, self.x_axis[x + 1, y + 1],
self.y_axis[x + 1, y + 1])
struct.pack_into('>2d', buf, 52, self.x_axis[x, y + 1],
self.y_axis[x, y + 1])
struct.pack_into('>2d', buf, 68, self.x_axis[x, y], self.y_axis[x,
y])
ds = QtCore.QDataStream(QtCore.QByteArray.fromRawData(buf))
poly = QtGui.QPolygonF()
ds >> poly # pylint: disable=pointless-statement
self.polygons.append((x * ysize + y, poly))
logger.info("Done")
def onReadyRead(self):
inputStream = QtCore.QDataStream(self.tcpSocket)
while (1):
if len(self.rxBuffer) < Messaging.hdrSize:
if self.tcpSocket.bytesAvailable() < Messaging.hdrSize:
return
self.rxBuffer += inputStream.readRawData(Messaging.hdrSize -
len(self.rxBuffer))
if len(self.rxBuffer) >= Messaging.hdrSize:
hdr = Messaging.hdr(self.rxBuffer)
bodyLen = hdr.GetDataLength()
if len(self.rxBuffer) + self.tcpSocket.bytesAvailable(
) < Messaging.hdrSize + bodyLen:
return
self.rxBuffer += inputStream.readRawData(Messaging.hdrSize +
bodyLen -
len(self.rxBuffer))
# create a new header object with the appended body
hdr = Messaging.hdr(self.rxBuffer)
# if we got this far, we have a whole message! So, emit the signal
self.messagereceived.emit(hdr)
# then clear the buffer, so we start over on the next message
self.rxBuffer = bytearray()
def readFromServer(self):
ins = QtCore.QDataStream(self.socket)
ins.setVersion(QtCore.QDataStream.Qt_4_2)
while not ins.atEnd():
if self.blockSize == 0:
if self.socket.bytesAvailable() < 4:
return
self.blockSize = ins.readUInt32()
if self.socket.bytesAvailable() < self.blockSize:
return
action = ins.readQString()
# logger.debug("Server: '%s'" % action)
if action == "PING":
self.writeToServer("PONG")
self.blockSize = 0
return
elif action == "PONG":
self.blockSize = 0
self.received_pong.emit()
return
try:
self._dispatch(json.loads(action))
except:
logger.error("Error dispatching JSON: " + action,
exc_info=sys.exc_info())
self.blockSize = 0
def dropMimeData(self, data, action, row, column, parent):
if not self.canDropMimeData(data, action, row, column, parent):
return False
if action == Qt.IgnoreAction:
return True
destinationChild = 0
if not row == -1:
destinationChild = row
elif parent.isValid():
destinationChild = parent.row()
else:
destinationChild = self.rowCount(parent)
encoded_data = data.data(self.mimeTypeString)
stream = QtCore.QDataStream(encoded_data, QtCore.QIODevice.ReadOnly)
mime_datas = []
while not stream.atEnd():
variant = QtCore.QVariant()
stream >> variant
mime_datas.append(variant.value())
for parent_rows in mime_datas:
item = self.__root__.child(parent_rows)
index = self.createIndex(parent_rows[-1], 0, item)
sourceParent = index.parent()
sourceRow = parent_rows[-1]
self.moveRow(sourceParent, sourceRow, parent, destinationChild)
return True
def send_to_clients_evt(self):
if len(self.connections) == 0:
return
# Setting up output method
block = QtCore.QByteArray()
out = QtCore.QDataStream(block, QtCore.QIODevice.WriteOnly)
out.setVersion(QtCore.QDataStream.Qt_4_0)
out.writeUInt32(0)
# Preparing output by grabbing screen image
pix = self.rootObjects()[0].screen().grabWindow(
self.rootObjects()[0].winId()).toImage()
pix = pix.mirrored()
img = QtCore.QByteArray()
buffer = QtCore.QBuffer(img)
buffer.open(QtCore.QIODevice.WriteOnly)
pix.save(buffer, "JPG", 95)
out << img
out.device().seek(0)
out.writeUInt32(block.size() - 4)
for con in self.connections:
con.write(block)
def calculate_polygons(self):
"""
Convert the raw data into a voronoi plot
"""
logger.debug("Generating voronoi graph")
if len(self.positions) > 2:
self.voronoi = spatial.Voronoi(self.positions)
else:
return
# Then generate a list of polygons for finite regions
logger.debug("Generating Polygons")
self.polygons.clear()
for ind, p in enumerate(self.voronoi.point_region):
p_vertices = self.voronoi.regions[p]
n_vertices = len(p_vertices)
buf = bytearray(4 + n_vertices*16)
struct.pack_into('>i', buf, 0, n_vertices)
for i, point in enumerate(p_vertices):
if point == -1:
break
point = self.voronoi.vertices[point]
struct.pack_into('>2d', buf, 4+i*16, point[0], point[1])
else:
ds = QtCore.QDataStream(QtCore.QByteArray.fromRawData(buf))
poly = QtGui.QPolygonF()
ds >> poly # pylint: disable=pointless-statement
self.polygons.append((ind, poly))
logger.debug("Clearing Voronoi")
# Clear the voronoi
del self.voronoi
self.voronoi = None
logger.info("Done")
def send(self, value):
"""
Sends a message by serializing, compressing and wrapping to a QByteArray, then streaming over the TCP socket.
:param value: The message to send.
"""
if not self.is_connected():
raise RuntimeError('Try to send on unconnected socket.')
logger.debug('socket send: %s', value)
# serialize value to yaml
stream = StringIO()
yaml.dump(value, stream)
serialized = stream.getvalue()
# encode to utf-8 bytes and compress
compressed = zlib.compress(serialized.encode())
# wrap in QByteArray
bytearray = QtCore.QByteArray(compressed)
# write using a data stream
writer = QtCore.QDataStream(self.socket)
writer.setVersion(QtCore.QDataStream.Qt_5_5)
writer << bytearray
def _receive(self):
"""
Called by the sockets readyRead signal. Not intended for outside use.
While there are messages available read them and process them.
Reading is reading of a QByteArray from the TCPSocket, un-compressing and de-serializing.
"""
while self.socket.bytesAvailable() > 0:
print('socket will receive')
# read a QByteArray using a data stream
reader = QtCore.QDataStream(self.socket)
bytearray = QtCore.QByteArray()
reader >> bytearray
# uncompress bytes from bytearray
uncompressed = zlib.decompress(bytearray.data())
# security validator (check for everything that we do not like (!!python)
# TODO implement this
# decode from utf-8 bytes to unicode and deserialize from yaml
value = yaml.load(uncompressed.decode())
print(('socket received {}'.format(value)))
# print('connection id {} received {}'.format(self.id, value))
self.received.emit(value)
def save(self):
exception = None
fh = None
try:
if not self.filename:
raise IOError("no filename specified for saving")
fh = QtCore.QFile(self.filename)
if not fh.open(QtCore.QIODevice.WriteOnly):
raise IOError(fh.errorString())
stream = QtCore.QDataStream(fh)
stream.writeInt32(MAGIC_NUMBER)
stream.writeInt16(FILE_VERSION)
stream.setVersion(QtCore.QDataStream.Qt_4_5)
for ship in self.ships:
stream.writeQString(ship.name)
stream.writeQString(ship.owner)
stream.writeQString(ship.country)
stream.writeQString(ship.description)
stream.writeInt32(ship.teu)
self.dirty = False
except IOError as e:
exception = e
finally:
if fh is not None:
fh.close()
if exception is not None:
raise exception
def get_data(self, dbnames, dbkeys, src_smiles, return_count,
similarity_cutoff, request_num):
global socket
fp_binary, canon_smile = gpusim_utils.smiles_to_fingerprint_bin(src_smiles)
fp_qba = QtCore.QByteArray(fp_binary)
output_qba = QtCore.QByteArray()
output_qds = QtCore.QDataStream(output_qba, QtCore.QIODevice.WriteOnly)
output_qds.writeInt(len(dbnames))
for name, key in zip(dbnames, dbkeys):
output_qds.writeString(name.encode())
output_qds.writeString(key.encode())
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()
return output_qba
def onReadyRead(self):
inputStream = QtCore.QDataStream(self.socket)
while (1):
if len(self.rxBuffer) < BluetoothHeader.SIZE:
if self.socket.bytesAvailable() < BluetoothHeader.SIZE:
return
self.rxBuffer += inputStream.readRawData(BluetoothHeader.SIZE -
len(self.rxBuffer))
if len(self.rxBuffer) >= BluetoothHeader.SIZE:
hdr = BluetoothHeader(self.rxBuffer)
bodyLen = hdr.GetDataLength()
if len(self.rxBuffer) + self.socket.bytesAvailable(
) < BluetoothHeader.SIZE + bodyLen:
return
self.rxBuffer += inputStream.readRawData(BluetoothHeader.SIZE +
bodyLen -
len(self.rxBuffer))
# create a new header object with the appended body
btHdr = BluetoothHeader(self.rxBuffer)
# if we got this far, we have a whole message! So, emit the signal
networkMsg = self.hdrTranslator.translate(btHdr)
self.messagereceived.emit(networkMsg)
# then clear the buffer, so we start over on the next message
self.rxBuffer = bytearray()
def readRxBuffer(self):
input_stream = QtCore.QDataStream(self.connection)
while(self.connection.bytesAvailable() > 0):
# read the header, unless we have the header
if(len(self.rxBuf) < Messaging.hdrSize):
#print("reading", Messaging.hdrSize - len(self.rxBuf), "bytes for header")
self.rxBuf += input_stream.readRawData(Messaging.hdrSize - len(self.rxBuf))
#print("have", len(self.rxBuf), "bytes")
# if we still don't have the header, break
if(len(self.rxBuf) < Messaging.hdrSize):
print("don't have full header, quitting")
return
hdr = Messaging.hdr(self.rxBuf)
# need to decode body len to read the body
bodyLen = hdr.GetDataLength()
# read the body, unless we have the body
if(len(self.rxBuf) < Messaging.hdrSize + bodyLen):
#print("reading", Messaging.hdrSize + bodyLen - len(self.rxBuf), "bytes for body")
self.rxBuf += input_stream.readRawData(Messaging.hdrSize + bodyLen - len(self.rxBuf))
# if we still don't have the body, break
if(len(self.rxBuf) < Messaging.hdrSize + bodyLen):
print("don't have full body, quitting")
return
# Process what we assume to be a full message...
self.processBinaryMessage(self.rxBuf)
# then clear the buffer, so we start over on the next message
self.rxBuf = bytearray()
def dropMimeData(self, data, action, row, column, parent):
if parent and parent.isValid():
target = self.itemFromIndex(parent)
else:
target = self
encoded_data = data.data(self.MIME_TYPE)
stream = QtCore.QDataStream(encoded_data, QtCore.QIODevice.ReadOnly)
items = []
while not stream.atEnd():
variant = QtCore.QVariant()
stream >> variant
rows = variant.value()
item = self
for i in rows:
item = item.item(i)
items.append(item)
command = CommandMove(items, target, row, self.parent(),
"Move {} elements".format(len(items)))
self.parent().undo_stack.push(command)
return False
def insert(self, key, d):
if isinstance(d, str):
fileCache = self.AQ_DISKCACHE_DIRPATH + '/' + key
fi = QtCore.QFile(fileCache)
drc = QtCore.QDir(self.AQ_DISKCACHE_DIRPATH)
if not drc.exists():
drc.mkdir(self.AQ_DISKCACHE_DIRPATH)
elif fi.exists():
return True
if d and d != "":
if fi.open(self.IO_WriteOnly):
t = QtCore.QTextStream(fi)
t << d
fi.close()
return True
return False
else:
fileCache = self.AQ_DISKCACHE_DIRPATH + '/' + key + "-BIN"
fi = QtCore.QFile(fileCache)
drc = QtCore.QDir(self.AQ_DISKCACHE_DIRPATH)
if not drc.exists():
drc.mkdir(self.AQ_DISKCACHE_DIRPATH)
elif fi.exists():
return True
if not d.isEmpty():
if fi.open(self.IO_WriteOnly):
dat = QtCore.QDataStream(fi)
dat << d
fi.close()
return True
return False
def dropMimeData(self, data, action, row, _, parent):
if action == Qt.IgnoreAction:
return True
if not data.hasFormat(self.internalMoveMimeType()):
return False
if action != Qt.MoveAction:
_LOGGER.warning("unhandled action: %s", action)
return False
self.beginResetModel()
## adding child to parent
targetParent = parent.internalPointer()
encodedData = data.data(self.internalMoveMimeType())
stream = QtCore.QDataStream(encodedData, QtCore.QIODevice.ReadOnly)
while not stream.atEnd():
value = QtCore.QVariant()
# pylint: disable=W0104
stream >> value
itemCoords = value.value()
self.moveItem(itemCoords, targetParent, row)
self.endResetModel()
return True
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if not isinstance(child, DragLabel):
return
hotSpot = event.pos() - child.pos()
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
dataStream.writeQString(child.labelText())
dataStream << QtCore.QPoint(hotSpot)
mimeData = QtCore.QMimeData()
mimeData.setData(fridgetMagnetsMimeType(), itemData)
mimeData.setText(child.labelText())
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(child.pixmap())
drag.setHotSpot(hotSpot)
child.hide()
if drag.exec_(QtCore.Qt.MoveAction | QtCore.Qt.CopyAction,
QtCore.Qt.CopyAction) == QtCore.Qt.MoveAction:
child.close()
else:
child.show()
def newStream(self):
try:
if self.neverSwitch == True:
self.__logger.debug("We are trying to switch a completed replay")
return
self.replaydatas = QtCore.QDataStream(self.replay.getReplayData(), QtCore.QIODevice.ReadOnly)
if self.replaySent.length() == 0:
return
old_replay_sent = self.stripHeader(QtCore.QByteArray(self.replaySent))
self.replaySent = QtCore.QByteArray()
while True:
if self.replaydatas.atEnd():
break
self.replaydatas.readDouble()
lenData = self.replaydatas.readUInt32()
data = self.replaydatas.readRawData(lenData)
self.replaySent.append(data)
if self.replaySent.contains(old_replay_sent):
# we are at a point where the old replay was already sent.
# We check if we miss some datas.
if old_replay_sent.length() != (self.replaySent.length() - self.replaySent.indexOf(old_replay_sent)):
# if the length of the old replay is different than the current one minus the header..
self.session.getSocket().write(self.replaySent[self.replaySent.indexOf(old_replay_sent) + old_replay_sent.length():])
# we send it !
self.__logger.info("Sending left over")
# and we stop sending more.
break
self.packetTimeRead = False
except:
self.__logger.exception("Something awful happened while switching threads !")
def readDataFromServer(self):
self.handler.atConnectionRead()
ins = QtCore.QDataStream(self.updateSocket)
ins.setVersion(QtCore.QDataStream.Qt_4_2)
while not ins.atEnd():
# Nothing was read yet, commence a new block.
if self.blockSize == 0:
# wait for enough bytes to piece together block size information
if self.updateSocket.bytesAvailable() < 4:
return
self.blockSize = ins.readUInt32()
self.handler.atNewBlock(self.blockSize)
avail = self.updateSocket.bytesAvailable()
# We have an incoming block, wait for enough bytes to accumulate
if avail < self.blockSize:
self.handler.atBlockProgress(avail, self.blockSize)
return # until later, this slot is reentrant
# Enough bytes accumulated. Carry on.
self.handler.atBlockComplete(self.blockSize, ins)
# Prepare to read the next block
self.blockSize = 0
