def rank_source_file_reply(self): """ 获取日排名请求返回 """ reply = self.sender() request_url = reply.request().url().url() # 解析出请求的品种 request_filename = request_url.rsplit("/", 1)[1] request_variety = request_filename.split("_")[0] if reply.error(): reply.deleteLater() self.spider_finished.emit( "获取{}排名数据文件。\n失败:{}".format(request_variety[:2], str(reply.error())), True) logger.error("获取{}排名数据文件失败了!".format(request_url[:2])) return save_path = os.path.join( LOCAL_SPIDER_SRC, 'cffex/rank/{}_{}.csv'.format(request_variety, self.date.strftime("%Y-%m-%d"))) file_data = reply.readAll() file_obj = QFile(save_path) is_open = file_obj.open(QFile.WriteOnly) if is_open: file_obj.write(file_data) file_obj.close() reply.deleteLater() tip = "获取中金所{}_{}日持仓排名数据保存到文件成功!".format( request_variety, self.date.strftime("%Y-%m-%d")) if request_variety == "T": tip = "获取中金所{}日所有品种持仓排名数据保存到文件成功!".format( self.date.strftime("%Y-%m-%d")) self.spider_finished.emit(tip, True) self.event_loop.quit()
def slotTestStoped(self): self.testStatus[0] = False self.setItemEnable(True) self.timer.stop() self.updateMessage() self.thread.quit() # save Test log if self.saveTestLog: fileName = time.strftime("%Y_%m_%d.%H_%M_%S.",time.localtime()) if self.radioReboot.isChecked(): fileName += "reboot" elif self.radioProvision: fileName += "provision" else: fileName += "factoryReset" fileName += ".htm" if self.saveLogPath == "": self.outputWarning("日志地址没有设置,无法保存") else: fileName = self.saveLogPath + "\\" + fileName print(fileName) file = QFile(fileName) if not file.open(QIODevice.WriteOnly): self.outputError("打开文件错误,保存日志失败") return byteArr = bytes(self.messageBox.toHtml(),"utf-8") file.write(QByteArray(byteArr)) file.close()
def received_file(self): """ 接收到文件 """ reply = self.sender() # 从路径中解析要保存的位置 request_url = reply.request().url().url() split_ = request_url.split("/{}/".format(self.sys_bit)) save_file_path = os.path.join(BASE_DIR, split_[1]) # 文件夹不存在创建 save_dir = os.path.split(save_file_path)[0] if not os.path.exists(save_dir): os.makedirs(save_dir) file_data = reply.readAll() if reply.error(): # print("更新错误", reply.error()) self.update_error = True file_obj = QFile(save_file_path) is_open = file_obj.open(QFile.WriteOnly) if is_open: file_obj.write(file_data) file_obj.close() else: self.update_error = True self.current_count += 1 self.update_process_bar.setValue(self.current_count) reply.deleteLater() if self.current_count >= self.update_count: self.update_finished_restart_app()
def saveCache(self): file = QFile("cache") if not file.open(QIODevice.WriteOnly): return content = self.ipLineEdit.text() + "\n" content += self.passwordLineEdit.text() + "\n" content += self.userLineEdit.text() + "\n" content += self.ver1LineEdit.text() + "\n" content += self.dir1LineEdit.text() + "\n" content += self.ver2LineEdit.text() + "\n" content += self.dir2LineEdit.text() + "\n" content += self.ver3LineEdit.text() + "\n" content += self.dir3LineEdit.text() + "\n" content += str(self.intervalSpinBox.value()) + "\n" content += str(self.loopSpinBox.value()) + "\n" if self.gxpAction.isChecked(): content += "gxpAction\n" else: content += "grp2602Action\n" if self.radioReboot.isChecked(): content += "reboot\n" elif self.radioProvision.isChecked(): content += "provision\n" else: content += "factory\n" if self.radioHttp.isChecked(): content += "Http\n" elif self.radioHttps.isChecked(): content += "Https\n" elif self.radioTftp.isChecked(): content += "Tftp\n" elif self.radioFtp.isChecked(): content += "Ftp\n" elif self.radioFtps.isChecked(): content += "Ftps\n" else : content += "Window\n" content += str(self.findCoreStop) + "\n" content += str(self.cleanCacheSet) + "\n" content += str(self.useApiTest) + "\n" content += str(self.showTestProgress) + "\n" content += str(self.showChrome) + "\n" content += self.chromePath +"\n" content += str(self.saveTestLog) +"\n" content += self.saveLogPath +"\n" content += self.coreDumpPath +"\n" byteArr = bytes(content,"utf-8") file.write(QByteArray(byteArr)) file.close()
def runReport(self, pid, method, par): self.boolDirect = True self.mtypeCall = "report" self.mpid = pid self.mmethod = method self.mparams = par # bparams = self.prepareParams() request = self.prepareRequest() # reply = self.data_request(request, bparams) data = reply.readAll() parseError = QJsonParseError() resultObject = {} resultObject["data"] = "error" document = QJsonDocument.fromJson(data, parseError) if parseError.error == True: resultObject["data"] = "error" else: if document.isObject(): jv = document.object() if jv.__contains__( "result") == True and jv["result"].__class__() == []: #tryton 4.0 #'result': ['pdf', {'base64':wwwwww, '__class__':'bytes'}, False,'Printis'] jre = jv["result"] namesecs = "tryton_" + self.mpid + str( QDateTime.currentMSecsSinceEpoch()) + "." + jre[0] mdir = QDir(self.mDir + QDir.separator() + "tempReports") if mdir.exists() == False: s = QDir(self.mDir) s.mkdir("tempReports") filename = self.mDir + QDir.separator( ) + "tempReports" + QDir.separator() + namesecs file = QFile(filename) if file.open(QIODevice.WriteOnly) == False: #error self.signalResponse.emit(self.mpid, 7, {}) print("error", filename, file.errorString()) else: bafile = QByteArray.fromBase64( jre[1]["base64"].encode()) file.write(bafile) file.close() QDesktopServices.openUrl(QUrl(filename)) else: if document.isArray() == True: self.signalResponse.emit(self.mpid, 7, {}) self.processingData(data, reply)
def save_default_parameters(self): base_path = Path(__file__).parent settings_path = str( (base_path / '../resources/PRINTER_SETTINGS.json').resolve()) settings_file = QFile(settings_path) file_data = {} if settings_file.open(QIODevice.ReadOnly | QIODevice.Text): file_data = QJsonDocument.fromJson( settings_file.readAll()).object() settings_file.close() if settings_file.open(QIODevice.ReadWrite | QIODevice.Text | QIODevice.Truncate): file_data["printer_type"] = "DLP" file_data["dlp_settings"] = self.__default_parameters settings_file.write(QJsonDocument(file_data).toJson()) settings_file.close()
class Receiver(): def __init__(self, socket): self._socket = socket self._transaction = None self._sender = None self._file_name = None self._socket.readyRead.connect(self.start) self._receiving_file = None self._bytearray_to_file = QByteArray() self._file_size = 0 def get_file_name(self): return self._file_name def get_file_size(self): return self._file_size def get_sender(self): return self._sender def start(self): self._sender = self._socket.peerAddress() stream = QDataStream(self._socket) if (self._file_size == 0): if (self._socket.bytesAvailable() < getsizeof(int)): return self._file_size = stream.readUInt32() if (self._socket.bytesAvailable() < self._file_size): return self._file_name = stream.readString() line = QByteArray() line = self._socket.readAll() directory = Path(Setup().get_download_dir()) if not (directory.exists() and directory.is_dir()): directory.mkdir() self._receiving_file = QFile(Setup().get_download_dir() + str(self._file_name)) print(Setup().get_download_dir() + str(self._file_name)) if not (self._receiving_file.open(QIODevice.WriteOnly)): print("can't open file") return self._receiving_file.write(line) self._receiving_file.close() self._socket.disconnectFromHost() print("finished") return self._receiving_file
def daily_source_file_reply(self): reply = self.sender() if reply.error(): reply.deleteLater() self.spider_finished.emit("失败:" + str(reply.error()), True) return save_path = os.path.join( LOCAL_SPIDER_SRC, 'czce/daily/{}.xls'.format(self.date.strftime("%Y-%m-%d"))) file_data = reply.readAll() file_obj = QFile(save_path) is_open = file_obj.open(QFile.WriteOnly) if is_open: file_obj.write(file_data) file_obj.close() reply.deleteLater() self.spider_finished.emit( "获取郑商所{}日交易数据源文件成功!".format(self.date.strftime("%Y-%m-%d")), True)
class FileDownload(QObject): def __init__(self, manager: QNetworkAccessManager, url: str, output_url: str): super(FileDownload, self).__init__(None) request = QNetworkRequest(url) self.output_url = output_url self.output = QFile(self.output_url) self.logger = create_logger(__name__) if not self.output.open(QIODevice.WriteOnly): self.logger.info( "Could not open: {url}".format(url=self.output_url)) return self.current_download = manager.get(request) self.current_download_progress = FileDownloadProgress() self.current_download.downloadProgress.connect( self.current_download_progress.update) self.current_download.readyRead.connect(self.saveFile) self.current_download.finished.connect(self.download_finished) @Property(str, constant=True) def outputUrl(self) -> str: return self.output_url @Property(QObject, constant=True) def progress(self) -> QObject: return self.current_download_progress @Slot() def saveFile(self) -> None: self.output.write(self.current_download.readAll()) @Slot() def download_finished(self) -> None: self.output.close()
class DownloadDialog(QDialog): """Summary A dialog to download file and display progression Attributes: source (QUrl): url of file to download destination (QDir): destination folder of downloaded file """ def __init__(self, parent=None): super().__init__(parent) self.file_label = QLabel() self.progress = QProgressBar() self.info_label = QLabel() self.btn_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.net = QNetworkAccessManager() font = QFont() font.setBold(True) self.file_label.setFont(font) v_layout = QVBoxLayout() v_layout.addWidget(self.file_label) v_layout.addWidget(self.progress) v_layout.addWidget(self.info_label) v_layout.addStretch() v_layout.addWidget(self.btn_box) self.btn_box.accepted.connect(self.close) self.btn_box.rejected.connect(self.cancel) self.btn_box.button(QDialogButtonBox.Ok).setVisible(False) self.setLayout(v_layout) self.setFixedSize(450, 150) self.setWindowTitle(self.tr("Download file")) def set_source(self, url: QUrl): """Set file url to download Args: url (QUrl) """ self.source = url self.file_label.setText(self.source.fileName()) def set_destination(self, directory: QDir): """Set folder path where download the file Args: directory (QDir) """ self.destination = directory def start(self): """ Start downloading the file specify by set_source """ filepath = self.destination.absoluteFilePath(self.source.fileName()) if QFile(filepath).exists(): QFile.remove(filepath) self._file = QFile(filepath) # open the file to write in if self._file.open(QIODevice.WriteOnly): print("open file", filepath) # Create a Qt Request request = QNetworkRequest() request.setUrl(self.source) self.time = QTime.currentTime() self.reply = self.net.get(request) # Connect reply to different slots self.reply.downloadProgress.connect(self.on_update_progress) self.reply.finished.connect(self.on_finished) self.reply.error.connect(self.on_error) def cancel(self): """Cancel download """ if hasattr(self, "reply"): self.reply.abort() self._file.remove() self.close() @Slot(int, int) def on_update_progress(self, read, total): """This methods is called by self.reply.downloadProgress signal Args: read (int): Number of bytes readed total (int): Total bytes to download """ if read <= 0: return if self.reply.error() != QNetworkReply.NoError: return self._file.write(self.reply.readAll()) # compute speed duration = self.time.secsTo(QTime.currentTime()) + 1 speed = read / duration remaining = (total - read) / speed h_remaining = QTime(0, 0, 0, 0).addSecs(remaining).toString() h_total = self.human_readable_bytes(total) h_read = self.human_readable_bytes(read) h_speed = self.human_readable_bytes(speed) + "/sec" self.info_label.setText( f"Time remaining {h_remaining} - {h_read} of {h_total} ({h_speed})" ) # Set progression self.progress.setRange(0, total) self.progress.setValue(read) @Slot() def on_finished(self): """This methods is called by self.reply.finished signal """ if self.reply.error() == QNetworkReply.NoError: self._file.close() self.reply.deleteLater() self.btn_box.button(QDialogButtonBox.Ok).setVisible(True) @Slot(QNetworkReply.NetworkError) def on_error(self, err: QNetworkReply.NetworkError): """This method is called by self.reply.error signal Args: err (QNetworkReply.NetworkError) """ self.reply.deleteLater() def human_readable_bytes(self, num, suffix="B"): for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]: if abs(num) < 1024.0: return "%3.1f%s%s" % (num, unit, suffix) num /= 1024.0 return "%.1f%s%s" % (num, "Yi", suffix)
def rechargeNet(self, preferences, username): #version 1.1 up thesamodule data = self.m_qjsonnetwork.callDirect( "version internal", "model.thesamodule.config.search_read", [[], 0, 1, [], ["internal_version"], preferences]) if not data["data"] == "error": self.internal_version = data["data"]["result"][0][ "internal_version"] if float(self.internal_version) > 1.0: data = self.m_qjsonnetwork.callDirect( "cachedel", "model.thesamodule.config.search_read", [[], 0, 1, [], ["deletecache"], preferences]) if not data["data"] == "error": if data["data"]["result"][0]["deletecache"] == True: self.actionCache_ = "deleteOnCompleted" else: self.actionCache_ = "notDelete" sysdir = QDir(self.mDir + QDir.separator() + _dirSystem) DIR_QML_SYS = sysdir.path() DIR_QML_SYS_LOST = DIR_QML_SYS + QDir.separator() + "lost" sysdirlost = QDir(DIR_QML_SYS_LOST) #revisar folder systemnet if sysdir.exists() == False: s = QDir(self.mDir) s.mkdir(_dirSystem) #revisar folder systemnet lost if sysdirlost.exists() == False: sl = QDir(DIR_QML_SYS) sl.mkdir("lost") #find all files en folder net listSysFiles = os.listdir(DIR_QML_SYS) if "lost" in listSysFiles: listSysFiles.remove("lost") # data = {} data["data"] = "error" if float(self.internal_version) > 1.1: data = self.m_qjsonnetwork.callDirect( "findforuser", "model.thesamodule.usersfolder.search_read", [[ "AND", ["users.user.name", "=", username], ["activefolder", "=", True] ], 0, 1, [], ["qmlfiles"], preferences]) if not data["data"] == "error": result = data["data"]["result"] if len(result) > 0: idfiles = result[0]["qmlfiles"] data = self.m_qjsonnetwork.callDirect( "rechargeNetStep1", "model.thesamodule.thesamodule.read", [idfiles, [ "checksum", "filename", ], preferences]) if len(idfiles) == 0: self.m_qjsonnetwork.signalResponse.emit( "systemnet", 15, {"noqmlfiles": ""}) else: #buscar default data = self.m_qjsonnetwork.callDirect( "findforuser", "model.thesamodule.usersfolder.search_read", [[ "AND", ["type", "=", "default"], ["activefolder", "=", True] ], 0, 1, [], ["qmlfiles"], preferences]) if not data["data"] == "error": result = data["data"]["result"] if len(result) > 0: idfiles = result[0]["qmlfiles"] data = self.m_qjsonnetwork.callDirect( "rechargeNetStep1", "model.thesamodule.thesamodule.read", [ idfiles, [ "checksum", "filename", ], preferences ]) if len(idfiles) == 0: self.m_qjsonnetwork.signalResponse.emit( "systemnet", 15, {"noqmlfiles": ""}) else: self.m_qjsonnetwork.signalResponse.emit( "systemnet", 12, {"noqmlfiles": ""}) else: self.m_qjsonnetwork.signalResponse.emit( "systemnet", 13, {"error": ""}) else: self.m_qjsonnetwork.signalResponse.emit( "systemnet", 13, {"error": ""}) else: data = self.m_qjsonnetwork.callDirect( "rechargeNetStep1", "model.thesamodule.thesamodule.search_read", [[], 0, 1000, [], ["checksum", "filename"], preferences]) if not data["data"] == "error": resultnet = data["data"]["result"] mapnet = {} mapids = {} listNetFiles = [] for file in resultnet: mapnet[file["filename"]] = file["checksum"] mapids[file["filename"]] = file["id"] listNetFiles.append(file["filename"]) #buscar faltantes en system y los updates #buscar los que ya no deben estar mapsysnet = {} listToUpdate = set() #new or update listToErase = [] for file in listSysFiles: try: with open(DIR_QML_SYS + QDir.separator() + file, "rb") as binary_file: data = binary_file.read() chek = hashlib.md5(data).hexdigest() mapsysnet[file] = chek except: listToUpdate.add(file) for file in listNetFiles: if file in listSysFiles: if mapnet[file] != mapsysnet[file]: listToUpdate.add(file) # update else: listToUpdate.add(file) # new for file in listSysFiles: if not file in listNetFiles: listToErase.append(file) # erase listToUpdate = list(listToUpdate) ids = [] for file in listToUpdate: ids.append(mapids[file]) data = self.m_qjsonnetwork.callDirect( "rechargeNetStep2", "model.thesamodule.thesamodule.read", [ids, [ "filebinary", "filename", ], preferences]) errors = [] if not data["data"] == "error": resultnet = data["data"]["result"] for file in resultnet: filename = DIR_QML_SYS + QDir.separator( ) + file["filename"] qfile = QFile(filename) if qfile.open(QIODevice.WriteOnly) == False: errors.append(filename) print("error", filename, qfile.errorString()) else: print("update", file["filename"]) bafile = QByteArray.fromBase64( file["filebinary"]["base64"].encode()) qfile.write(bafile) qfile.close() if len(errors) > 0: self.m_qjsonnetwork.signalResponse.emit( "systemnet", 33, {"error": errors}) return False #erase for file in listToErase: print("moviendo", file) shutil.move(DIR_QML_SYS + QDir.separator() + file, DIR_QML_SYS_LOST + QDir.separator() + file) return True else: #erase all files, no conexion con thesa module for file in listSysFiles: print("moviendo", file) shutil.move(DIR_QML_SYS + QDir.separator() + file, DIR_QML_SYS_LOST + QDir.separator() + file) self.m_qjsonnetwork.signalResponse.emit("systemnet", 34, {"error": ""}) return False
def save_current_parameters(self): current_parameters = { 'printer_setup': self.printer_setup, 'projector_setup': self.projector_setup, 'motor_setup': self.motor_setup, # Support Parameters 'support_thickness (mm)': self.support_thickness, # mm 'support_exposure (ms)': self.support_exposure, # ms 'support_amplitude': self.support_amplitude, 'support_burn_layers': self.support_burn_layers, 'support_burn_exposure (ms)': self.support_burn_exposure, # ms 'support_burn_amplitude': self.support_burn_amplitude, # Features Parameters 'features_thickness (mm)': self.features_thickness, # mm 'features_exposure (ms)': self.features_exposure, # ms 'features_amplitude': self.features_amplitude, 'features_burn_layers': self.features_burn_layers, 'features_burn_exposure (ms)': self.features_burn_exposure, # ms 'features_burn_amplitude': self.features_burn_amplitude, # Advanced Parameters 'incremental_thickness': self.incremental_thickness, 'incremental_exposure': self.incremental_exposure, 'incremental_amplitude': self.incremental_amplitude, 'starting_incremental_thickness (mm)': self.starting_incremental_thickness, # mm 'incremental_step_thickness (mm)': self.incremental_step_thickness, # mm 'starting_incremental_exposure (ms)': self.starting_incremental_exposure, # ms 'incremental_step_exposure (ms)': self.incremental_step_exposure, # ms 'starting_incremental_amplitude': self.starting_incremental_amplitude, 'incremental_step_amplitude': self.incremental_step_amplitude, 'fixed_layer': self.fixed_layer, 'grayscale_correction': self.grayscale_correction, 'grayscale_alpha': self.grayscale_alpha, 'grayscale_beta': self.grayscale_beta, 'grayscale_gamma': self.grayscale_gamma, # Others 'projector_amplitude': self.projector_amplitude, 'feed_rate (mm/min)': self.__motor_controller.feed_rate, # mm/min 'spindle_pitch_microns': self.spindle_pitch_microns, 'motor_steps_per_revolution': self.motor_steps_per_revolution, 'projector_feed_rate (mm/min)': self.__motor_controller.projector_feed_rate, 'repositioning_delay (ms)': self.__motor_controller.repositioning_delay, # ms 'repositioning_offset (mm)': self.__motor_controller.repositioning_offset, # mm 'projector_pixel_size (mm)': self.projector_pixel_size, # mm 'projector_width': self.projector_width, 'projector_height': self.projector_height, 'horizontal_mirror': self.__projector_controller.horizontal_mirror, 'vertical_mirror': self.__projector_controller.vertical_mirror, 'samples_per_pixel': self.samples_per_pixel } base_path = Path(__file__).parent log_path = str((base_path / '../resources/PRINT_LOG.json').resolve()) log_file = QFile(log_path) file_data = {} # if log_file.open(QIODevice.ReadOnly | QIODevice.Text): # file_data = QJsonDocument.fromJson(log_file.readAll()).object() # log_file.close() if log_file.open(QIODevice.ReadWrite | QIODevice.Append): # Print Job Parameters file_data['date (yyyy.MM.dd)'] = self.printing_date file_data['time (hh.mm.ss)'] = self.printing_time file_data['username'] = self.username file_data['print_job_name'] = self.print_job_name file_data['print_job_status'] = self.print_status file_data['total_layers'] = self.number_of_layers file_data['support_layers'] = len(self.support_file_names) file_data['features_layers'] = len(self.features_file_names) file_data['printed_layers'] = self.current_layer file_data["printer_type"] = "DLP" if self.print_status == "FAILED": file_data["error_message"] = self.error_message file_data["dlp_settings"] = current_parameters log_file.write(QJsonDocument(file_data).toJson()) log_file.close()