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)
