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 get_network_manager(): # Create network access manager network_manager = QNetworkAccessManager() # Get proxy settings data settings = QSettings("labsquare", "cutevariant") settings.beginGroup("proxy") p_type_index = settings.value("type", 0) p_host = settings.value("host") p_port = settings.value("port", 80) p_username = settings.value("username") p_password = settings.value("password") settings.endGroup() try: p_type = list(PROXY_TYPES.values())[int(p_type_index)] if p_port: p_port = int(p_port) if p_type is not QNetworkProxy.NoProxy: proxy = QNetworkProxy(p_type, p_host, p_port, p_username, p_password) network_manager.setProxy(proxy) except Exception as e: LOGGER.exception(e) pass return network_manager
def __init__(self, *args, **kargs): super().__init__(*args, **kargs) # lazy creation of the NetworkManager global _manager if _manager is None: _manager = QNetworkAccessManager() # open the destination file for writing if self.dest and self.dest != '::mem::': try: self._dest_fp = open(self.dest, 'wb') except OSError: self._notify_done(False) return else: self._dest_fp = None # build and send the GET request request = QNetworkRequest(self.url) if self._headers is not None: for key in self._headers: request.setHeader(key, self._headers[key]) self._reply = _manager.get(request) self._reply.finished.connect(self._finished_cb) self._reply.downloadProgress.connect(self._progress_cb) if self.dest != '::mem::': self._reply.readyRead.connect(self._data_ready_cb)
class WPAPI(QObject): done = Signal(list) def __init__(self): QObject.__init__(self) self._nam = QNetworkAccessManager(self) self._nam.finished.connect(self._on_fetched) def fetch(self, page=1, perpage=10): url = QUrl(WPAPI_ROOT.format(page=page, perpage=perpage)) request = QNetworkRequest(url) self._nam.get(request) def _on_fetched(self, reply): content = reply.readAll() try: js = json.loads(bytes(content).decode('utf-8')) posts = [] for post in js: content = { 'title': post.get('title', {}).get('rendered'), 'body': post.get('content', {}).get('rendered'), 'date': post.get('date'), 'excerpt': post.get('excerpt', {}).get('rendered'), 'author': post.get('_embedded', {}).get('author') } posts.append(content) self.done.emit(posts) except Exception: pass
def __init__(self, parent=None): """ :param parent: """ super(SlippyMap, self).__init__(parent) self._offset = QPoint() self._tiles_rectangle = QRect() self._tile_pixmaps = {} # Point(x, y) to QPixmap mapping self._manager = QNetworkAccessManager() self._url = QUrl() # public vars self.width = 400 self.height = 300 self.zoom = 4 self.latitude = 59.9138204 self.longitude = 10.7387413 self._emptyTile = QPixmap(TDIM, TDIM) self._emptyTile.fill(Qt.lightGray) self.request = QNetworkRequest() self.cache = QNetworkDiskCache() self.cache.setCacheDirectory( QStandardPaths.writableLocation(QStandardPaths.CacheLocation)) self._manager.setCache(self.cache) self._manager.finished.connect(self.handle_network_data)
def __init__(self, *args, **kwargs): super(UpdatePage, self).__init__(*args, *kwargs) self.setWindowFlags(Qt.FramelessWindowHint) self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle('分析决策系统自动更新程序') self.request_stack = list() self.update_error = False self.current_count = 0 self.update_count = 0 self._pressed = False self._mouse_pos = None self.sys_bit = "32" if sys.maxsize < 2**32 else "64" self._server = "" self.network_manager = QNetworkAccessManager(self) icon_path = os.path.join(BASE_DIR, "icons/app.png") pix_path = os.path.join(BASE_DIR, "images/update_bg.png") self.setWindowIcon(QIcon(icon_path)) self.setPixmap(QPixmap(pix_path)) self.red = QPalette() self.red.setColor(QPalette.WindowText, Qt.red) self.blue = QPalette() self.blue.setColor(QPalette.WindowText, Qt.blue) font = QFont() font.setPointSize(16) font.setBold(True) font.setWeight(75) self.setFixedSize(500, 200) self.setScaledContents(True) self.setFont(font) self.show_text = QLabel("系统正在下载新版本文件...", self) self.show_text.setFont(font) self.show_text.setFixedSize(self.width(), self.height()) self.show_text.setAlignment(Qt.AlignCenter) self.show_text.setPalette(self.blue) self.update_process_bar = QProgressBar(self) self.update_process_bar.setGeometry(1, 160, 498, 12) self.update_process_bar.setObjectName('processBar') self.setStyleSheet(""" #processBar{ text-align:center; font-size: 12px; font-weight:100; border: 1px solid #77d333; border-radius: 5px; background-color:none; } #processBar::chunk { background-color: #77d363; border-radius: 3px; margin:2px } """) self._updating()
def createRequest(self, operation, request, data): if self._regex and self._regex.findall(str(request.url().toString())): return QNetworkAccessManager.createRequest( self, QNetworkAccessManager.GetOperation, QNetworkRequest(QUrl())) reply = QNetworkAccessManager.createRequest( self, operation, request, data ) reply.readyRead.connect(lambda reply=reply: replyReadyRead(reply)) time.sleep(0.001) return reply
def start_fetch(self, network_manager: QtNetwork.QNetworkAccessManager): """Asynchronously begin the network access. Intended as a set-and-forget black box for downloading files.""" self.request = QtNetwork.QNetworkRequest(QtCore.QUrl(self.url)) self.request.setAttribute( QtNetwork.QNetworkRequest.RedirectPolicyAttribute, QtNetwork.QNetworkRequest.UserVerifiedRedirectPolicy, ) self.fetch_task = network_manager.get(self.request) self.fetch_task.finished.connect(self.resolve_fetch) self.fetch_task.redirected.connect(self.on_redirect) self.fetch_task.sslErrors.connect(self.on_ssl_error)
def __init__(self, row, col, img_url, parent=None): super(Tile, self).__init__(parent=parent) self.row = row self.col = col self.setGeometry(0, 0, 200, 200) self.setMargin(10) self.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter) self.mousePressEvent = lambda event: self.handle_mouse_pressed(event) self.setStyleSheet("border: 1px dotted gray;") # load the image manager = QNetworkAccessManager(self) manager.finished[QNetworkReply].connect(self.disp_image) manager.get(QNetworkRequest(QUrl("https://images.dog.ceo/breeds/groenendael/n02105056_6127.jpg"))) # default pixmap self.default_pixmap = QPixmap(200, 200) self.default_pixmap.fill(Qt.gray) self.setPixmap(self.default_pixmap) # second pixmap self.dog_pixmap = QPixmap(200, 200) self.anim = QVariantAnimation() self.anim.setDuration(500) self.anim.setEasingCurve(QEasingCurve.Linear) self.anim.valueChanged.connect(self.anim_value_changed) self.anim.setStartValue(float(0)) self.anim.setEndValue(float(180)) self.anim1 = QVariantAnimation() self.anim1.setDuration(500) self.anim1.setEasingCurve(QEasingCurve.Linear) self.anim1.valueChanged.connect(self.anim1_value_changed) self.anim1.setStartValue(float(180)) self.anim1.setEndValue(float(0)) self.resize(200, 200) self.anim1.start()
def __init__(self, parent=None): QObject.__init__(self, parent) self.parent = parent self.usuario = "" self.password = "" self.token = [] self.mmethod = "" self.mpid = "" self.mparams = [] self.mid = 0 self.boolConnect = False self.intCountConnect = 0 self.intReply = 0 self.intReplyMax = 2 self.urlServer = QUrl() self.versionct = "4" #trytond self.mhost = "" self.mdbase = "" self.mport = "" self.preferences = {} self.boolRun = False self.boolDirect = False self.boolRecursive = False self.mtypeCall = "order" self.mDir = QDir.currentPath() self.tempCallData = QJsonArray() self.tempCallFunctionArgs = QJsonArray() self.m_engine = QQmlApplicationEngine() # connect(managerAccess, SIGNAL(finished(QNetworkReply*)), # this, SLOT(replyFinishedOrder(QNetworkReply*))); self.managerAccess = QNetworkAccessManager(self) self.managerAccess.finished[QNetworkReply].connect( self.replyFinishedOrder)
def __init__(self): self.window = MainWindow() self.network_access_manager = QNetworkAccessManager(self.window) self.window.controllers_mdi.tileSubWindows() self.ping_timer = QTimer(self.window) self.detected_devices = {} self.open_devices = {} self.ssdp_interface = SSDPInterface(parent=self.window) self.ssdp_interface.new_device.connect(self.device_info_received) self.window.refresh_button.clicked.connect(self.refresh_clicked) self.ping_timer.timeout.connect(self.ssdp_interface.ping_devices) self.window.auto_ping.stateChanged.connect(self.auto_ping_changed) self.window.camera_list.itemDoubleClicked.connect( self.item_double_clicked) if self.window.auto_ping.isChecked(): print("Starting auto ping") self.ping_timer.start(MainController.PING_RATE_MS)
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)
def manager(cls): if cls.__instance is None: cls.__instance = QNetworkAccessManager() return cls.__instance
def testSetNetworkAccessManager(self): page = QWebPage() manager = QNetworkAccessManager() page.setNetworkAccessManager(manager)
def __init__(self): super(FileDownloader, self).__init__(None) self.manager = QNetworkAccessManager() self.current_download = None
class UpdatePage(QLabel): def __init__(self, *args, **kwargs): super(UpdatePage, self).__init__(*args, *kwargs) self.setWindowFlags(Qt.FramelessWindowHint) self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle('分析决策系统自动更新程序') self.request_stack = list() self.update_error = False self.current_count = 0 self.update_count = 0 self._pressed = False self._mouse_pos = None self.sys_bit = "32" if sys.maxsize < 2**32 else "64" self._server = "" self.network_manager = QNetworkAccessManager(self) icon_path = os.path.join(BASE_DIR, "icons/app.png") pix_path = os.path.join(BASE_DIR, "images/update_bg.png") self.setWindowIcon(QIcon(icon_path)) self.setPixmap(QPixmap(pix_path)) self.red = QPalette() self.red.setColor(QPalette.WindowText, Qt.red) self.blue = QPalette() self.blue.setColor(QPalette.WindowText, Qt.blue) font = QFont() font.setPointSize(16) font.setBold(True) font.setWeight(75) self.setFixedSize(500, 200) self.setScaledContents(True) self.setFont(font) self.show_text = QLabel("系统正在下载新版本文件...", self) self.show_text.setFont(font) self.show_text.setFixedSize(self.width(), self.height()) self.show_text.setAlignment(Qt.AlignCenter) self.show_text.setPalette(self.blue) self.update_process_bar = QProgressBar(self) self.update_process_bar.setGeometry(1, 160, 498, 12) self.update_process_bar.setObjectName('processBar') self.setStyleSheet(""" #processBar{ text-align:center; font-size: 12px; font-weight:100; border: 1px solid #77d333; border-radius: 5px; background-color:none; } #processBar::chunk { background-color: #77d363; border-radius: 3px; margin:2px } """) self._updating() def mousePressEvent(self, event): super(UpdatePage, self).mousePressEvent(event) if event.button() == Qt.LeftButton: self._pressed = True self._mouse_pos = event.pos() def mouseReleaseEvent(self, event): super(UpdatePage, self).mouseReleaseEvent(event) self._pressed = False self._mouse_pos = None def mouseMoveEvent(self, event): if event.buttons() == Qt.LeftButton and self._mouse_pos: self.move(self.mapToGlobal(event.pos() - self._mouse_pos)) event.accept() def _updating(self): """ 更新 """ # 读取更新的文件信息 new_update_file = os.path.join( BASE_DIR, "classini/for_update_{}.json".format(self.sys_bit)) old_update_file = os.path.join( BASE_DIR, "classini/update_{}.json".format(self.sys_bit)) if not os.path.exists(new_update_file) or not os.path.exists( old_update_file): self.show_text.setText("更新信息文件丢失...") self.show_text.setPalette(self.red) return with open(new_update_file, "r", encoding="utf-8") as new_f: new_json = json.load(new_f) with open(old_update_file, "r", encoding="utf-8") as old_f: old_json = json.load(old_f) self._server = new_json["SERVER"] for_update_dict = new_json["FILES"] old_dict = old_json["FILES"] self.update_count = len(for_update_dict) self.update_process_bar.setMaximum(self.update_count) for file_path, file_hash in for_update_dict.items(): old_hash = old_dict.get(file_path, None) if old_hash is not None and old_hash == file_hash: # print(file_path, "hash相等") self.current_count += 1 self.update_process_bar.setValue(self.current_count) if self.current_count >= self.update_count: self.update_finished_restart_app() continue # 生成请求对象 self.generate_requests(file_path) # 执行下载 self.exec_downloading() 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 generate_requests(self, file_path): """ 生成请求对象 """ url = self._server + "{}/{}".format(self.sys_bit, file_path) self.request_stack.append(QNetworkRequest(url=QUrl(url))) def exec_downloading(self): """ 开始文件下载 """ for request_item in self.request_stack: reply = self.network_manager.get(request_item) reply.finished.connect(self.received_file) def update_finished_restart_app(self): self.show_text.setText("更新完成!") if not self.update_error: # 下载完毕后且之间无发生过错误,将新文件内容复制到旧文件,真正完成更新 new_update_file = os.path.join( BASE_DIR, "classini/for_update_{}.json".format(self.sys_bit)) old_update_file = os.path.join( BASE_DIR, "classini/update_{}.json".format(self.sys_bit)) with open(new_update_file, "r", encoding="utf-8") as new_f: new_json = json.load(new_f) del new_json["SERVER"] with open(old_update_file, "w", encoding="utf-8") as old_f: json.dump(new_json, old_f, indent=4, ensure_ascii=False) os.remove(new_update_file) # 重新启动主程序 script_path = os.path.join(BASE_DIR, "ADClient.exe") if os.path.exists(script_path): Popen(script_path, shell=False) self.close() sys.exit() else: self.show_text.setText("更新成功\n执行文件不存在!") self.show_text.setPalette(self.red)
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)
from PySide2.QtCore import QObject, Signal from PySide2.QtNetwork import QNetworkAccessManager, QNetworkReply NETWORK_MANAGER = QNetworkAccessManager() FALLBACK_BATCH_SIZE = 50 def ParseNetworkError(error): return str(error).split(".")[-1] class Fetcher(QObject): FetchingStarted = Signal() BatchProgress = Signal(int, int) BatchReady = Signal(dict) FetchingFinished = Signal(int) FetchingStopped = Signal() FetchingError = Signal(str) def __init__(self, parent=None): super().__init__(parent) self._manager = NETWORK_MANAGER self._plugin = None self._search_string = None self._batch_size = None self._page = None self._reply = None
class QJsonNetwork(QObject): def __init__(self, parent=None): QObject.__init__(self, parent) self.parent = parent self.usuario = "" self.password = "" self.token = [] self.mmethod = "" self.mpid = "" self.mparams = [] self.mid = 0 self.boolConnect = False self.intCountConnect = 0 self.intReply = 0 self.intReplyMax = 2 self.urlServer = QUrl() self.versionct = "4" #trytond self.mhost = "" self.mdbase = "" self.mport = "" self.preferences = {} self.boolRun = False self.boolDirect = False self.boolRecursive = False self.mtypeCall = "order" self.mDir = QDir.currentPath() self.tempCallData = QJsonArray() self.tempCallFunctionArgs = QJsonArray() self.m_engine = QQmlApplicationEngine() # connect(managerAccess, SIGNAL(finished(QNetworkReply*)), # this, SLOT(replyFinishedOrder(QNetworkReply*))); self.managerAccess = QNetworkAccessManager(self) self.managerAccess.finished[QNetworkReply].connect( self.replyFinishedOrder) # self.connect(self.managerAccess, SIGNAL("finished(QNetworkReply*)"), # self, self.replyFinishedOrder) ##ifndef QT_NO_SSL # self.connect(self.managerAccess, SIGNAL("sslErrors(QNetworkReply *, const QList<QSslError> &)"), # self, self.slotSslError) @Slot(str) def setVersionTryton(self, ver): self.versionct = ver def setEngine(self, engine): #QQmlApplicationEngine *engine=nullptr); self.m_engine = engine def clearMessagesWarning(self): root = self.m_engine.rootObjects()[0] QMetaObject.invokeMethod(root, "clearMessages") @Slot() def saveLastCall(self): self.tempCallData.append(self.boolDirect) self.tempCallData.append(self.mtypeCall) self.tempCallData.append(self.mpid) self.tempCallData.append(self.mmethod) self.tempCallData.append(self.mparams) @Slot() def runLastCall(self): if not self.tempCallData.isEmpty(): if self.tempCallData.count() == 5: if str(self.tempCallData.at(1).toString()) == "order": if self.tempCallData.at(0).toBool( ) == True: #// call direct obsolete, betterbetter to use recursivecall if not self.tempCallFunctionArgs.isEmpty(): nameObject = self.tempCallFunctionArgs.at( 0).toString() nameFunction = self.tempCallFunctionArgs.at( 1).toString() root = self.m_engine.rootObjects()[0] object_qml = root.findChild(QObject, nameObject) if self.tempCallFunctionArgs.at(2).isArray(): args = self.tempCallFunctionArgs.at( 2).toArray() #.toVariantList() if args.count() == 0: QMetaObject.invokeMethod( object_qml, nameFunction) else: root.setProperty("argsFucntionLastCall", args) QMetaObject.invokeMethod( object_qml, nameFunction) # https://bugreports.qt.io/browse/PYSIDE-1262 # Q_ARG missing, invokeMethod doesn't work currently with arguments in PySide2. # if args.count()==1: # print("\nnnn",args.at(0),"\nnnnn") # QMetaObject.invokeMethod(object_qml, nameFunction, # QGenericArgument(QByteArray(b'QVariant'), 69)) # # if args.count()==2: # QMetaObject.invokeMethod(object_qml, nameFunction, # QGenericArgument('QVariant', args.at(0)), # QGenericArgument('QVariant', args.at(1))) # # if args.count()==3: # QMetaObject.invokeMethod(object_qml, nameFunction, # QGenericArgument('QVariant', args.at(0)), # QGenericArgument('QVariant', args.at(1)), # QGenericArgument('QVariant', args.at(2))) # # if args.count()==4: # QMetaObject.invokeMethod(object_qml, nameFunction, # QGenericArgument('QVariant', args.at(0)), # QGenericArgument('QVariant', args.at(1)), # QGenericArgument('QVariant', args.at(2)), # QGenericArgument('QVariant', args.at(3))) # else: self.call( self.tempCallData.at(2).toString(), self.tempCallData.at(3).toString(), self.tempCallData.at(4).toArray()) if self.tempCallData.at(1).toString() == "report": self.runReport( self.tempCallData.at(2).toString(), self.tempCallData.at(3).toString(), self.tempCallData.at(4).toArray()) self.tempCallData = QJsonArray() self.tempCallFunctionArgs = QJsonArray() @Slot("QNetworkReply*") def replyFinishedOrder(self, reply): if self.boolDirect == False: data = reply.readAll() self.processingData(data, reply) # reply.deleteLater() @Slot("QNetworkReply*", "const QList<QSslError> &") def slotSslError(self, reply, errors): for error in errors: print("ssl error", error.errorString()) # foreach (const QSslError &error, errors) # fprintf(stderr, "SSL error: %s\n", qPrintable(error.errorString())); signalResponse = Signal(str, int, "QJsonObject") def getId(self): self.mid += 1 return self.mid #QUrl redirectUrlComp(const QUrl& possibleRedirectUrl,const QUrl& oldRedirectUrl) const; def redirectUrlComp(self, possibleRedirectUrl, oldRedirectUrl): redirectUrl = QUrl() if possibleRedirectUrl.isEmpty( ) == False and possibleRedirectUrl != oldRedirectUrl: redirectUrl = possibleRedirectUrl return redirectUrl @Slot(result=bool) def isRunning(self): if self.boolRecursive == True: return True return self.boolRun @Slot(str, str, str, str, str) @Slot(str, str, str, str, str, bool) def openConect(self, usu, passw, host, port, dbase, direct=False): self.usuario = usu self.password = passw self.mhost = host self.mdbase = dbase self.mport = port url = host + ":" + port + "/" + dbase + "/" self.urlServer = QUrl(url) self.token.clear() self.boolConnect = False marray = QJsonArray() if self.versionct == "4": marray.append(self.usuario) marray.append(self.password) if direct: return self.callDirect("open@", "common.db.login", marray) else: self.call("open@", "common.db.login", marray) else: marray.append(self.usuario) marray.append({"password": self.password}) # mapass = QJsonValue({"password",self.password}) # marray.append(mapass.toObject()) if direct: return self.callDirect("open@", "common.db.login", marray) else: self.call("open@", "common.db.login", marray) @Slot(str, str, QJsonArray) def call(self, pid, method, par): self.clearMessagesWarning() if self.boolRun == False: self.boolRun = True self.boolDirect = False self.mtypeCall = "order" self.mpid = pid self.mmethod = method self.mparams = par self.initOrderConnect() else: if pid != self.mpid: self.signalResponse.emit("run@", 8, {}) @Slot() def initOrderConnect(self): bparams = self.prepareParams() request = self.prepareRequest() self.managerAccess.post(request, bparams) # reply.readyRead.connect(self.slotReadyRead) # reply.error[QNetworkReply.NetworkError].connect(self..slotError) # reply.sslErrors.connect(self.slotSslErrors) @Slot(QJsonArray) def saveFunction(self, by403): if by403.count() == 3: #objectqml functon args self.tempCallFunctionArgs = by403 else: self.tempCallFunctionArgs = QJsonArray() @Slot(str, str, QJsonArray, result="QJsonObject") def callDirect(self, pid, method, par): if self.boolRecursive == False: self.clearMessagesWarning() resultObject = {} if self.boolRun == False: self.boolRun = True self.boolDirect = True self.mtypeCall = "order" self.mpid = pid self.mmethod = method self.mparams = par bparams = self.prepareParams() request = self.prepareRequest() reply = self.data_request(request, bparams) data = reply.readAll() ## QByteArray parseError = QJsonParseError() resultObject["data"] = "error" document = QJsonDocument.fromJson(data, parseError) error = reply.error() statusCode = reply.attribute( QNetworkRequest.HttpStatusCodeAttribute) if QNetworkReply.NoError == error: if parseError.error == True: resultObject["data"] = "error" else: if document.isObject(): jv = document.object() if jv.__contains__("result"): resultObject["data"] = jv else: if self.boolRecursive: if jv.__contains__("error"): if jv["error"].__class__() == []: if jv["error"].__contains__( "UserWarning" ) or jv["error"][0].__contains__( "403") or jv["error"][ 0].__contains__("401"): resultObject["data"] = jv elif self.mpid == "open@": resultObject["data"] = jv else: if document.isArray() == True: resultObject["data"] = document.array() else: resultObject["data"] = "error" else: if statusCode == 401 or statusCode == 403: resultObject["data"] = statusCode self.processingData(data, reply) # cath return resultObject else: resultObject["data"] = "error" if pid != self.mpid: self.signalResponse.emit("run@", 8, {}) return resultObject def data_request(self, request, bparams): connection_loop = QEventLoop() QObject.connect(self.managerAccess, SIGNAL("finished( QNetworkReply* )"), connection_loop, SLOT("quit()")) reply = self.managerAccess.post(request, bparams) connection_loop.exec_() #sleep #reply->bytesAvailable(); #reply.deleteLater() return reply def processingData(self, data, reply): parseError = QJsonParseError() error = reply.error() errorString = reply.errorString() statusCode = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute) fraseStatusCode = reply.attribute( QNetworkRequest.HttpReasonPhraseAttribute) redirectUrl = QUrl( reply.attribute(QNetworkRequest.RedirectionTargetAttribute)) redirectUrlFix = self.redirectUrlComp(redirectUrl, self.urlServer) # print(errorString, statusCode) resultObject = { "status": statusCode, "fraseStatus": fraseStatusCode, "errorString": errorString } result = False # QJsonValue result=false; Bug QJsonValue(True) if self.mpid == "open@": resultObject["credentials"] = False if QNetworkReply.NoError == error: if redirectUrlFix.isEmpty() == False: if self.boolDirect == False: print("se redireciona", redirectUrl) self.urlServer = redirectUrl self.initOrderConnect() self.signalResponse.emit(self.mpid, 1, resultObject) else: document = QJsonDocument.fromJson(data, parseError) if parseError.error == True: resultObject["data"] = data.__str__() self.signalResponse.emit(self.mpid, 4, resultObject) #redireccion else: if document.isArray() == True: result = document.array() else: #supuestamente es un object json if self.mpid == "open@": if document.object().__contains__( "result") == True: if document.object()["result"].__class__( ) == []: if document.object()["result"].__len__( ) == 2: self.token = document.object( )["result"] self.boolConnect = True self.intCountConnect += 1 resultObject["credentials"] = True result = document.object() resultObject["data"] = result if self.boolDirect == False: self.signalResponse.emit(self.mpid, 2, resultObject) #ok else: #and report if self.mpid == "open@" and result.__contains__( "error") == False and self.boolRecursive == False: resultObject["extra"] = "direct" self.signalResponse.emit(self.mpid, 2, resultObject) # elif self.mpid=="open@" and result.__contains__("error")==False and resultObject["credentials"] == False and self.boolRecursive == True: # self.signalResponse.emit(self.mpid, 2, resultObject) elif result.__contains__("error") == True: if self.boolRecursive == True: if result["error"].__class__( ) == [] and result["error"].__contains__( "UserWarning" ) == False and result["error"][0].__contains__( "403") == False and result["error"][ 0].__contains__("401") == False: self.signalResponse.emit( self.mpid, 2, resultObject) elif document.isObject(): self.signalResponse.emit(self.mpid, 2, resultObject) else: print(error, statusCode, errorString) #, resultObject) if self.boolRecursive == True: if resultObject['status'] != 401 and resultObject[ 'status'] != 403: self.signalResponse.emit( self.mpid, 3, resultObject) #//error comunicacion else: self.signalResponse.emit(self.mpid, 3, resultObject) #//error comunicacion self.boolRun = False reply.deleteLater() # void processingData(const QByteArray &data, QNetworkReply *reply); @Slot(str, str, QJsonArray) 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 prepareRequest(self): request = QNetworkRequest() request.setUrl(self.urlServer) request.setRawHeader(QByteArray(b"content-type"), QByteArray(b"application/json")) request.setRawHeader(QByteArray(b"charset"), QByteArray(b"utf-8")) if self.mpid != "open@": tokenStr = self.usuario + ":" + str(int( self.token[0])) + ":" + str( self.token[1]) if self.token != [] else "" tokenByte = QByteArray(tokenStr.encode()) tokenByteComplete = QByteArray(b"Session ") + tokenByte.toBase64() request.setRawHeader(QByteArray(b"authorization"), tokenByteComplete) return request def prepareParams(self): objParams = { "method": self.mmethod, "params": self.mparams, "id": self.getId() } return QJsonDocument(objParams).toJson(QJsonDocument.Compact) @Slot("QJsonObject") def setPreferences(self, preferences): self.preferences = preferences @Slot(str, str, QJsonArray, result="QJsonObject") def recursiveCall(self, pid, method, par): self.clearMessagesWarning() self.boolRecursive = True result = self.callDirect(pid, method, par) if result["data"].__contains__("result"): if self.mpid != "open@": self.boolRecursive = False return result not_complete = True while not_complete: reValue = result["data"] if reValue.__class__() == 0 and (reValue == 401 or reValue == 403): mok = False textinput = self.tr("Re-enter Password:"******"Password", textinput, QLineEdit.Password) if mok: result = self.openConect(self.usuario, inputPass, self.mhost, self.mport, self.mdbase, True) else: not_complete = False result['data'] = 'error' self.boolRecursive = False root = self.m_engine.rootObjects()[0] QMetaObject.invokeMethod(root, "backLogin") elif reValue.__class__() == {}: if reValue.__contains__("result"): if self.mpid != "open@": not_complete = False else: if self.boolConnect: result = self.callDirect(pid, method, par) else: mok = False textinput = self.tr( "Incorrect, Re-enter Password:"******"Incorrect Password", textinput, QLineEdit.Password) if mok: result = self.openConect( self.usuario, inputPass, self.mhost, self.mport, self.mdbase, True) else: not_complete = False self.boolRecursive = False result['data'] = 'error' root = self.m_engine.rootObjects()[0] QMetaObject.invokeMethod(root, "backLogin") elif reValue.__contains__("error"): if reValue["error"].__class__() == []: if 'UserWarning' in reValue["error"]: cb = QCheckBox("Always ignore this warning.") msgBox = QMessageBox() msgBox.setText(reValue["error"][1][0]) msgBox.setInformativeText(reValue["error"][1][1]) msgBox.setStandardButtons(QMessageBox.No | QMessageBox.Yes) msgBox.setDefaultButton(QMessageBox.Yes) msgBox.setCheckBox(cb) rbox = msgBox.exec_() if rbox == QMessageBox.Yes: result = self.callDirect( pid, 'model.res.user.warning.create', [[{ 'always': cb.isChecked(), 'user': self.token[0], 'name': reValue["error"][1][0] }], self.preferences]) if result["data"].__contains__("result"): result = self.callDirect(pid, method, par) else: not_complete = False result['data'] = 'error' elif reValue["error"][0].__contains__( "403") or reValue["error"][0].__contains__( "401"): mok = False textinput = self.tr("Re-enter Password:"******"error"][0].__contains__("401"): textinput = "Authorization Required \n" + textinput inputPass, mok = QInputDialog.getText( None, "Password", textinput, QLineEdit.Password) if mok: result = self.openConect( self.usuario, inputPass, self.mhost, self.mport, self.mdbase, True) else: not_complete = False result['data'] = 'error' self.boolRecursive = False root = self.m_engine.rootObjects()[0] QMetaObject.invokeMethod(root, "backLogin") else: not_complete = False else: not_complete = False else: not_complete = False self.boolRecursive = False return result
class SlippyMap(QObject): updated = Signal(QRect) def __init__(self, parent=None): super(SlippyMap, self).__init__(parent) self._offset = QPoint() self._tilesRect = QRect() self._tilePixmaps = {} # Point(x, y) to QPixmap mapping self._manager = QNetworkAccessManager() self._url = QUrl() # public vars self.width = 400 self.height = 300 self.zoom = 15 self.latitude = 59.9138204 self.longitude = 10.7387413 self._emptyTile = QPixmap(TDIM, TDIM) self._emptyTile.fill(Qt.lightGray) self.request = QNetworkRequest() self.cache = QNetworkDiskCache() self.cache.setCacheDirectory( QStandardPaths.writableLocation(QStandardPaths.CacheLocation)) self._manager.setCache(self.cache) self._manager.finished.connect(self.handleNetworkData) def invalidate(self): if self.width <= 0 or self.height <= 0: return ct = tileForCoordinate(self.latitude, self.longitude, self.zoom) tx = ct.x() ty = ct.y() # top-left corner of the center tile xp = int(self.width / 2 - (tx - math.floor(tx)) * TDIM) yp = int(self.height / 2 - (ty - math.floor(ty)) * TDIM) # first tile vertical and horizontal xa = (xp + TDIM - 1) / TDIM ya = (yp + TDIM - 1) / TDIM xs = int(tx) - xa ys = int(ty) - ya # offset for top-left tile self._offset = QPoint(xp - xa * TDIM, yp - ya * TDIM) # last tile vertical and horizontal xe = int(tx) + (self.width - xp - 1) / TDIM ye = int(ty) + (self.height - yp - 1) / TDIM # build a rect self._tilesRect = QRect(xs, ys, xe - xs + 1, ye - ys + 1) if self._url.isEmpty(): self.download() self.updated.emit(QRect(0, 0, self.width, self.height)) def render(self, p, rect): for x in range(self._tilesRect.width()): for y in range(self._tilesRect.height()): tp = Point(x + self._tilesRect.left(), y + self._tilesRect.top()) box = self.tileRect(tp) if rect.intersects(box): p.drawPixmap(box, self._tilePixmaps.get(tp, self._emptyTile)) def pan(self, delta): dx = QPointF(delta) / float(TDIM) center = tileForCoordinate(self.latitude, self.longitude, self.zoom) - dx self.latitude = latitudeFromTile(center.y(), self.zoom) self.longitude = longitudeFromTile(center.x(), self.zoom) self.invalidate() # slots def handleNetworkData(self, reply): img = QImage() tp = Point(reply.request().attribute(QNetworkRequest.User)) url = reply.url() if not reply.error(): if img.load(reply, None): self._tilePixmaps[tp] = QPixmap.fromImage(img) reply.deleteLater() self.updated.emit(self.tileRect(tp)) # purge unused tiles bound = self._tilesRect.adjusted(-2, -2, 2, 2) for tp in list(self._tilePixmaps.keys()): if not bound.contains(tp): del self._tilePixmaps[tp] self.download() def download(self): grab = None for x in range(self._tilesRect.width()): for y in range(self._tilesRect.height()): tp = Point(self._tilesRect.topLeft() + QPoint(x, y)) if tp not in self._tilePixmaps: grab = QPoint(tp) break if grab is None: self._url = QUrl() return path = 'http://tile.openstreetmap.org/%d/%d/%d.png' % ( self.zoom, grab.x(), grab.y()) self._url = QUrl(path) self.request = QNetworkRequest() self.request.setUrl(self._url) self.request.setRawHeader(b'User-Agent', b'Nokia (PyQt) Graphics Dojo 1.0') self.request.setAttribute(QNetworkRequest.User, grab) self._manager.get(self.request) def tileRect(self, tp): t = tp - self._tilesRect.topLeft() x = t.x() * TDIM + self._offset.x() y = t.y() * TDIM + self._offset.y() return QRect(x, y, TDIM, TDIM)
class SlippyMap(QObject): updated = Signal(QRect) def __init__(self, parent=None): """ :param parent: """ super(SlippyMap, self).__init__(parent) self._offset = QPoint() self._tiles_rectangle = QRect() self._tile_pixmaps = {} # Point(x, y) to QPixmap mapping self._manager = QNetworkAccessManager() self._url = QUrl() # public vars self.width = 400 self.height = 300 self.zoom = 4 self.latitude = 59.9138204 self.longitude = 10.7387413 self._emptyTile = QPixmap(TDIM, TDIM) self._emptyTile.fill(Qt.lightGray) self.request = QNetworkRequest() self.cache = QNetworkDiskCache() self.cache.setCacheDirectory( QStandardPaths.writableLocation(QStandardPaths.CacheLocation)) self._manager.setCache(self.cache) self._manager.finished.connect(self.handle_network_data) def invalidate(self): """ :return: """ if self.width <= 0 or self.height <= 0: return ct = tile_for_coordinate(self.latitude, self.longitude, self.zoom) tx = ct.x() ty = ct.y() # top-left corner of the center tile xp = int(self.width / 2 - (tx - math.floor(tx)) * TDIM) yp = int(self.height / 2 - (ty - math.floor(ty)) * TDIM) # first tile vertical and horizontal xa = (xp + TDIM - 1) / TDIM ya = (yp + TDIM - 1) / TDIM xs = int(tx) - xa ys = int(ty) - ya # offset for top-left tile self._offset = QPoint(int(xp - xa * TDIM), int(yp - ya * TDIM)) # last tile vertical and horizontal xe = int(tx) + (self.width - xp - 1) / TDIM ye = int(ty) + (self.height - yp - 1) / TDIM # build a rect self._tiles_rectangle = QRect(int(xs), int(ys), int(xe - xs + 1), int(ye - ys + 1)) if self._url.isEmpty(): self.download() self.updated.emit(QRect(0, 0, self.width, self.height)) def render(self, p: QPainter, rect: QRect): """ Render a tile :param p: QPainter instance, place where to pain the tiles :param rect: QRect instance, dimensions of the painter (the window that renders the tiles) :return: Nothing """ rx = range(self._tiles_rectangle.width()) ry = range(self._tiles_rectangle.height()) for x, y in product(rx, ry): tp = Point(x + self._tiles_rectangle.left(), y + self._tiles_rectangle.top()) box = self.tile_rectangle(tp) if rect.intersects(box): p.drawPixmap(box, self._tile_pixmaps.get(tp, self._emptyTile)) def pan(self, delta: QPoint): """ Move the map :param delta: x, y delta as a QPoint instance :return: Nothing """ dx = QPointF(delta) / float(TDIM) center = tile_for_coordinate(self.latitude, self.longitude, self.zoom) - dx self.latitude = latitude_from_tile(center.y(), self.zoom) self.longitude = longitude_from_tile(center.x(), self.zoom) self.invalidate() # slots def handle_network_data(self, reply: QNetworkReply): """ This function is called automatically by a QNetworkAccessManager object (self._manager) :param reply: QNetworkReply instance :return: Nothing """ img = QImage() tp = Point(reply.request().attribute(QNetworkRequest.User)) url = reply.url() if not reply.error(): # if there was no url error... if img.load(reply, None): # if the image loading went well... self._tile_pixmaps[tp] = QPixmap.fromImage( img) # store the image in the tiles dictionary reply.deleteLater() self.updated.emit(self.tile_rectangle(tp)) # purge unused tiles bound = self._tiles_rectangle.adjusted(-2, -2, 2, 2) for tp in list(self._tile_pixmaps.keys()): if not bound.contains(tp): del self._tile_pixmaps[tp] self.download() def download(self): """ Download tile :return: Nothing """ grab = None rx = range(self._tiles_rectangle.width()) ry = range(self._tiles_rectangle.height()) for x, y in product(rx, ry): tp = Point(self._tiles_rectangle.topLeft() + QPoint(x, y)) if tp not in self._tile_pixmaps: grab = QPoint(tp) break if grab is None: self._url = QUrl() return path = 'http://tile.openstreetmap.org/%d/%d/%d.png' % ( self.zoom, grab.x(), grab.y()) self._url = QUrl(path) self.request = QNetworkRequest() self.request.setUrl(self._url) self.request.setRawHeader(b'User-Agent', b'Nokia (PyQt) Graphics Dojo 1.0') self.request.setAttribute(QNetworkRequest.User, grab) self._manager.get(self.request) print('downloading z:', self.zoom, 'x:', grab.x(), 'y:', grab.y()) def tile_rectangle(self, tp: Point): """ Get tile rectangle :param tp: Tile point :return: QRect instance """ t = tp - self._tiles_rectangle.topLeft() x = t.x() * TDIM + self._offset.x() y = t.y() * TDIM + self._offset.y() return QRect(x, y, TDIM, TDIM)
self.update_data(data) def update_data(self, data): vehicles = data['Vehicles'] self.beginRemoveRows( self.index(0).parent(), 0, len(self.vehicle_list) - 1) self.vehicle_list = [] self.endRemoveRows() self.beginInsertRows(self.index(0).parent(), 0, len(vehicles) - 1) for v in vehicles: pos = QGeoCoordinate(float(v['Lat']), float(v['Lng'])) aid = v['ID'] self.vehicle_list.append(Vehicle(pos, aid)) self.endInsertRows() print(self.vehicle_list) app = QGuiApplication(sys.argv) view = QQuickView() url = QUrl(VIEW_URL) na_manager = QNetworkAccessManager() vehicles_model = VehiclesModel(na_manager) ctxt = view.rootContext() ctxt.setContextProperty("vehiclesModel", vehicles_model) view.setSource(url) view.show() app.exec_()
def __init__(self): QObject.__init__(self) self._nam = QNetworkAccessManager(self) self._nam.finished.connect(self._on_fetched)
def createRequest(self, op, req, data=None): print(">> createRequest ", self, op, req.url(), data) return QNetworkAccessManager.createRequest(self, op, req, data)
def _init_network_manager(self): """ 初始化异步网库管理器 """ app = QApplication.instance() if not hasattr(app, "_network"): network_manager = QNetworkAccessManager(self) setattr(app, "_network", network_manager)