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