def fromUrl(url, pos, editor):
cache = imageTooltiper.cache
imageTooltiper.editor = editor
if url in cache:
if not cache[url][0]: # error, image was not found
imageTooltiper.tooltipError(cache[url][1], pos)
else:
imageTooltiper.tooltip(cache[url][1], pos)
return
try:
imageTooltiper.manager.finished.connect(imageTooltiper.finished,
F.AUC)
except:
pass
request = QNetworkRequest(QUrl(url))
imageTooltiper.data[QUrl(url)] = (pos, url)
imageTooltiper.manager.get(request)
def showEvent(self, event):
if not self.shown:
temp_dl_dir = tempfile.mkdtemp(prefix=cons.TEMP_PREFIX)
exe_name = os.path.basename(sys.executable)
self.downloaded_file = os.path.join(temp_dl_dir, exe_name)
self.downloading_file = open(self.downloaded_file, 'wb')
self.download_last_read = datetime.utcnow()
self.download_last_bytes_read = 0
self.download_speed_count = 0
self.download_aborted = False
self.http_reply = self.qnam.get(QNetworkRequest(QUrl(self.url)))
self.http_reply.finished.connect(self.http_finished)
self.http_reply.readyRead.connect(self.http_ready_read)
self.http_reply.downloadProgress.connect(self.dl_progress)
self.shown = True
def query_variety_sum(self):
""" 查询各品种的合计数 """
if not self.is_allow_query():
return
# 清除table
self.tip_timer.start(400)
self.show_table.clear()
self.show_table.setRowCount(0)
self.show_table.setColumnCount(0)
# 查询数据进行展示
current_date = self.query_date_edit.text()
# app = QApplication.instance()
network_manger = getattr(qApp, "_network")
url = SERVER_API + "exchange/" + self.current_exchange + "/" + self.current_action + "/variety-sum/?date=" + current_date
if self.rank_select.isEnabled():
url += "&rank=" + str(self.rank_select.value())
request = QNetworkRequest(QUrl(url))
reply = network_manger.get(request)
reply.finished.connect(self.query_result_reply)
def __init__(self, url, parent=None):
"""Resolve a PAC proxy from URL.
Args:
url: QUrl of a PAC proxy.
"""
super().__init__(parent)
pac_prefix = "pac+"
assert url.scheme().startswith(pac_prefix)
url.setScheme(url.scheme()[len(pac_prefix):])
self._pac_url = url
self._manager = QNetworkAccessManager()
self._manager.setProxy(QNetworkProxy(QNetworkProxy.NoProxy))
self._reply = self._manager.get(QNetworkRequest(url))
self._reply.finished.connect(self._finish)
self._pac = None
self._error_message = None
def startDownload(self, url: str) -> None:
Logger.log(
"i", "Toolbox: Attempting to download & install package from %s.",
url)
url = QUrl(url)
self._download_request = QNetworkRequest(url)
if hasattr(QNetworkRequest, "FollowRedirectsAttribute"):
# Patch for Qt 5.6-5.8
self._download_request.setAttribute(
QNetworkRequest.FollowRedirectsAttribute, True)
if hasattr(QNetworkRequest, "RedirectPolicyAttribute"):
# Patch for Qt 5.9+
self._download_request.setAttribute(
QNetworkRequest.RedirectPolicyAttribute, True)
self._download_request.setRawHeader(*self._request_header)
self._download_reply = self._network_manager.get(
self._download_request)
self.setDownloadProgress(0)
self.setIsDownloading(True)
self._download_reply.downloadProgress.connect(self._onDownloadProgress)
def __init__(self, *args, **kwargs):
super(OpencvWidget, self).__init__(*args, **kwargs)
self.httpRequestAborted = False
self.fps = 24
self.resize(800, 600)
if not os.path.exists("Data/shape_predictor_68_face_landmarks.dat"):
self.setText("正在下载数据文件。。。")
self.outFile = QFile(
"Data/shape_predictor_68_face_landmarks.dat.bz2")
if not self.outFile.open(QIODevice.WriteOnly):
QMessageBox.critical(self, '错误', '无法写入文件')
return
self.qnam = QNetworkAccessManager(self)
self._reply = self.qnam.get(QNetworkRequest(QUrl(URL)))
self._reply.finished.connect(self.httpFinished)
self._reply.readyRead.connect(self.httpReadyRead)
self._reply.downloadProgress.connect(self.updateDataReadProgress)
else:
self.startCapture()
def get_analysis_data(self):
""" 获取结果数据 """
if not self.contract_combobox.currentText():
QMessageBox.information(self, '错误', '请先选择合约后再操作.')
return
self.show_loading('正在获取资源数据')
min_date = int(datetime.datetime.strptime(self.start_date.text(), '%Y-%m-%d').timestamp())
max_date = int(datetime.datetime.strptime(self.end_date.text(), '%Y-%m-%d').timestamp())
if self.query_type == 'contract':
url = SERVER_API + 'price-position/?contract={}&min_date={}&max_date={}'.format(
self.contract_combobox.currentText(), min_date, max_date
)
elif self.query_type == 'variety':
url = SERVER_2_0 + 'dsas/price-position/?ds={}&de={}&c={}'.format(
self.start_date.text(), self.end_date.text(), self.contract_combobox.currentText()
)
else:
return
reply = self.network_manager.get(QNetworkRequest(QUrl(url)))
reply.finished.connect(self.price_position_reply)
def createRequest(self, op, request, outgoingData=None):
"""
Public method to create a request.
@param op the operation to be performed
(QNetworkAccessManager.Operation)
@param request reference to the request object (QNetworkRequest)
@param outgoingData reference to an IODevice containing data to be sent
(QIODevice)
@return reference to the created reply object (QNetworkReply)
"""
if self.primaryManager is not None:
pageRequest = QNetworkRequest(request)
if self.__webPage is not None:
self.__webPage.populateNetworkRequest(pageRequest)
return self.primaryManager.createRequest(op, pageRequest,
outgoingData)
else:
return QNetworkAccessManager.createRequest(self, op, request,
outgoingData)
def stopPrint(self):
self._post_multi_part = QHttpMultiPart(QHttpMultiPart.FormDataType)
## Create parts (to be placed inside multipart)
self._post_part = QHttpPart()
self._post_part.setHeader(QNetworkRequest.ContentDispositionHeader,
"form-data; name=\"cool\"")
self._post_part.setBody(b"true")
self._post_multi_part.append(self._post_part)
url = QUrl(self._base_url + "stop_print")
## Create the QT request
self._post_request = QNetworkRequest(url)
self._post_request.setRawHeader(self._api_header.encode(),
self._api_key.encode())
## Post request + data
self._post_reply = self._manager.post(self._post_request,
self._post_multi_part)
def http_finished(self):
self.downloading_file.close()
if self.download_aborted:
download_dir = os.path.dirname(self.downloaded_file)
delete_path(download_dir)
else:
redirect = self.http_reply.attribute(
QNetworkRequest.RedirectionTargetAttribute)
if redirect is not None:
download_dir = os.path.dirname(self.downloaded_file)
delete_path(download_dir)
os.makedirs(download_dir)
redirected_url = urljoin(
self.http_reply.request().url().toString(),
redirect.toString())
self.downloading_file = open(self.downloaded_file, 'wb')
self.download_last_read = datetime.utcnow()
self.download_last_bytes_read = 0
self.download_speed_count = 0
self.download_aborted = False
self.progress_bar.setValue(0)
self.http_reply = self.qnam.get(
QNetworkRequest(QUrl(redirected_url)))
self.http_reply.finished.connect(self.http_finished)
self.http_reply.readyRead.connect(self.http_ready_read)
self.http_reply.downloadProgress.connect(self.dl_progress)
else:
# Download completed
if getattr(sys, 'frozen', False):
# Launch self.downloaded_file and close
subprocess.Popen([self.downloaded_file])
self.updated = True
self.done(0)
def startRequest(self, url):
# just some debugging to see were we are
self.ui.logOutput.insertPlainText("startRequest ...\n")
# get the URL
self.ui.logOutput.insertPlainText("get page ...\n")
self.reply = self.qnam.get(QNetworkRequest(url))
# not sure if here correct or better somwhere else
# do we need authorization
self.qnam.authenticationRequired.connect(
self.slotAuthenticationRequired)
# do we got ssl errors
self.qnam.sslErrors.connect(self.sslErrors)
# after loading the page do some hadling of the output via the pyslot
self.reply.finished.connect(self.httpFinished)
# we should be able to read the stuff
self.ui.logOutput.insertPlainText("before httpReady ...\n")
self.reply.readyRead.connect(self.httpReadyRead)
# not sure if the return is needed
return
def updateNow(self):
"""
Public method to update the subscription immediately.
"""
if self.__downloading is not None:
return
if not self.location().isValid():
return
if self.location().scheme() == "file":
self.__lastUpdate = QDateTime.currentDateTime()
self.__loadRules()
return
from WebBrowser.WebBrowserWindow import WebBrowserWindow
reply = WebBrowserWindow.networkManager().get(
QNetworkRequest(self.location()))
reply.finished.connect(
lambda: self.__rulesDownloaded(reply))
self.__downloading = reply
def get(self, requestUrl, extraHeaders=None):
"""
Public method to issue a GET request.
@param requestUrl URL of the request (QUrl)
@keyparam extraHeaders list of tuples of additional headers giving
header name (string) and header value (string)
@return server response (QByteArray) or error message (string)
"""
request = QNetworkRequest(requestUrl)
request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
if extraHeaders:
for name, value in extraHeaders:
request.setRawHeader(name, value)
reply = self.__networkManager.get(request)
if not self.__loop.isRunning():
self.__loop.exec_()
if reply.error() != QNetworkReply.NoError:
return reply.errorString(), False
else:
return reply.readAll(), True
def confirm_current_folder(self):
""" 确定当前配置 """
# 发起配置的请求
folder_path = self.folder_edit.text()
if not folder_path:
return
body_data = {
"client": get_client_uuid(),
"folder_path": folder_path,
"variety_en": self.variety_en,
"group_id": self.group_id
}
network_manager = getattr(qApp, "_network")
url = SERVER_API + "industry/user-folder/"
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded")
request.setRawHeader("Authorization".encode("utf-8"), get_user_token().encode("utf-8"))
reply = network_manager.post(request, json.dumps(body_data).encode("utf-8"))
reply.finished.connect(self.create_update_folder_reply)
""" 本地保存(为了更新好处理和用户重新安装程序也存在这个配置,2020-09-29采用线上服务器保存)
def _createRequest(self,
url: str,
basic_auth_username: str = "",
basic_auth_password: str = "") -> QNetworkRequest:
request = QNetworkRequest(url)
request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
request.setRawHeader(b"User-Agent", self._user_agent)
if basic_auth_username and basic_auth_password:
data = base64.b64encode(
("%s:%s" % (basic_auth_username,
basic_auth_password)).encode()).decode("utf-8")
request.setRawHeader(b"Authorization",
("Basic %s" % data).encode())
# ignore SSL errors (eg for self-signed certificates)
ssl_configuration = QSslConfiguration.defaultConfiguration()
ssl_configuration.setPeerVerifyMode(QSslSocket.VerifyNone)
request.setSslConfiguration(ssl_configuration)
return request
def asyncFetchIssueCoverURLs(self, issue_id):
self.issue_id = issue_id
details = self.fetchCachedIssueSelectDetails(issue_id)
if details["image_url"] is not None:
self.urlFetchComplete.emit(details["image_url"], details["thumb_image_url"], self.issue_id)
return
issue_url = (
self.api_base_url
+ "/issue/"
+ CVTypeID.Issue
+ "-"
+ str(issue_id)
+ "/?api_key="
+ self.api_key
+ "&format=json&field_list=image,cover_date,site_detail_url"
)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.asyncFetchIssueCoverURLComplete)
self.nam.get(QNetworkRequest(QUrl(issue_url)))
def confirm_user_client_authority(self):
""" 确定修改用户客户端登录权限 """
current_row = getattr(self.sender(), "row_index")
client_id = self.client_auth.client_auth_table.item(current_row,
0).text()
expire_date = self.client_auth.client_auth_table.item(current_row,
4).text()
body_data = {
"modify_user": self.client_auth.current_user_id,
"client_id": client_id,
"expire_date": expire_date
}
network_manager = getattr(qApp, "_network")
user_token = get_user_token()
url = SERVER_API + "user/client-authenticate/"
request = QNetworkRequest(QUrl(url))
request.setRawHeader("Authorization".encode("utf-8"),
user_token.encode("utf-8"))
reply = network_manager.put(request,
json.dumps(body_data).encode("utf-8"))
reply.finished.connect(self.modify_client_authority_reply)
def send_network_report(self, body_data):
""" 使用网络文件创建 """
def create_report_reply():
if reply.error():
message = "创建报告失败!"
else:
message = "创建报告成功!"
self.file_table.removeRow(self.file_table.currentRow())
self.clear_relative_variety()
reply.deleteLater()
p = InformationPopup(message, self)
p.exec_()
url = SERVER_API + "wechat-files/{}".format(self.selected_file_path)
request = QNetworkRequest(QUrl(url))
request.setRawHeader("Authorization".encode("utf-8"),
get_user_token().encode("utf-8"))
network_manager = getattr(qApp, "_network")
reply = network_manager.post(request,
json.dumps(body_data).encode("utf-8"))
reply.finished.connect(create_report_reply)
def SearchPTH(queryString, language):
request = QNetworkRequest()
request.setUrl(QUrl("https://paikkatietojentuottajat-koekaytto.maanmittauslaitos.fi/api/public/v1/search?X-CLIENT-LANG=FI"))
request.setHeader(request.ContentTypeHeader, "application/json")
jsonByteArray = QJsonDocument(createJson(queryString, language)).toJson()
blockingNetworkRequest = QgsBlockingNetworkRequest()
err = blockingNetworkRequest.post(request, jsonByteArray, True)
if not err:
response = blockingNetworkRequest.reply().content()
dict_str = response.data().decode("utf-8")
if dict_str:
resp_json = json.loads(dict_str)
return resp_json.get("hits")
else:
#No result returned
LOG("Nothing returned")
pass
else:
LOG(blockingNetworkRequest.errorMessage())
def modify_row_data(self):
""" 修改数据表的单元格点击 """
btn = self.sender()
row = getattr(btn, 'row_index')
# 获取组织数据
item = {
"id": int(self.modify_table.item(row, 0).text()),
"date": self.modify_table.item(row, 1).text(),
"variety_en": self.modify_table.item(row, 2).text(),
"spot_price": float(self.modify_table.item(row, 3).text()),
"price_increase": float(self.modify_table.item(row, 4).text())
}
network_manager = getattr(qApp, "_network")
url = SERVER_API + "spot-price/{}/".format(item["id"])
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/json;charset=utf-8")
reply = network_manager.put(request, json.dumps(item).encode("utf-8"))
reply.finished.connect(self.modify_spot_price_reply)
def __replyFinished(self):
"""
Private slot handling the receipt of the requested data.
"""
replyStatus = self.__reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
if (replyStatus != 301 and replyStatus != 302) or \
self.__redirectCount == self.__maxRedirects:
self.finished.emit()
return
self.__redirectCount += 1
redirectUrl = self.__reply.attribute(
QNetworkRequest.RedirectionTargetAttribute)
self.__reply.close()
self.__reply.deleteLater()
self.__reply = None
self.__reply = self.__manager.get(QNetworkRequest(redirectUrl))
self.__reply.finished.connect(self.__replyFinished)
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)
request = QNetworkRequest()
request.setUrl(self._url)
request.setRawHeader(b'User-Agent', b'Nokia (PyQt) Graphics Dojo 1.0')
request.setAttribute(QNetworkRequest.User, grab)
self._manager.get(request)
def to_variety_authority(self):
""" 跳转品种权限页面 """
current_row = getattr(self.sender(), "row_index")
if current_row is None:
return
current_user_id = self.user_list_widget.show_user_table.item(
current_row, 0).text()
# 请求当前用户的客户端登录权限情况
network_manager = getattr(qApp, "_network")
url = SERVER_API + "user/variety-authenticate/?query_user="******"Authorization".encode("utf-8"),
user_token.encode("utf-8"))
reply = network_manager.get(request)
reply.finished.connect(self.user_variety_authority_reply)
tab_index = self.addTab(self.variety_auth, "品种权限")
self.setCurrentIndex(tab_index)
def start(self):
"""Run the routing request using parameters.
"""
# TODO: do something with parameters
verb = "GET"
url = "https://google.com/"
qUrl = QUrl(url)
qRequest = QNetworkRequest(qUrl)
self.qRequest = qRequest
qReply = self.client.qnam.sendCustomRequest(qRequest, verb, None)
# Create a thread and worker for the transfer
# QThread* thread = new QThread;
self.thread = QThread(self, objectName="routingTransferThread")
# Worker* worker = new Worker();
# docs say: "The object cannot be moved if it has a parent."
self.worker = TransferWorker(qReply)
# worker->moveToThread(thread);
self.worker.moveToThread(self.thread)
# When QNetworkReply is finished, worker emits this with its QReply
self.worker.received.connect(self.receive)
self.worker.updated.connect(self.update)
# connect(worker, SIGNAL (error(QString)), this, SLOT (errorString(QString)));
# self.worker.errored.connect(self.error)
# connect(thread, SIGNAL (started()), worker, SLOT (process()));
self.thread.started.connect(self.worker.run)
# connect(worker, SIGNAL (finished()), thread, SLOT (quit()));
# self.worker.finished.connect(self.thread.quit)
# connect(worker, SIGNAL (finished()), worker, SLOT (deleteLater()));
# self.worker.finished.connect(self.worker.deleteLater)
# connect(thread, SIGNAL (finished()), thread, SLOT (deleteLater()));
# self.thread.finished.connect(self.thread.deleteLater)
# thread->start();
self.thread.start()
def fill_async_data(self):
if self.window.apps:
for idx, app_v in enumerate(self.window.apps):
if app_v.visible and app_v.status == ApplicationViewStatus.LOADING and app_v.model.status == ApplicationStatus.READY:
if self.download_icons:
self.network_man.get(
QNetworkRequest(
QUrl(app_v.model.base_data.icon_url)))
app_name = self.item(idx, 0).text()
if not app_name or app_name == '...':
self.item(idx, 0).setText(app_v.model.base_data.name)
self._set_col_version(idx, app_v)
self._set_col_description(idx, app_v)
app_v.status = ApplicationViewStatus.READY
self.window.resize_and_center()
def _post_data(url: str,
data_: typing.Dict,
network_manager: QgsNetworkAccessManager,
auth_config: str,
feedback: typing.Optional[QgsFeedback] = None):
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/json')
reply = network_manager.blockingPost(request,
json.dumps(data_).encode('utf-8'),
auth_config,
True,
feedback=feedback)
status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
raw_string_contents = bytes(reply.content()).decode('utf-8')
if status_code == 201:
result = json.loads(raw_string_contents)
else:
raise QgsProcessingException(f'POST request failed. '
f'status_code: {status_code} - '
f'error_string: {reply.errorString()} - '
f'reply_contents: {raw_string_contents}')
return result
def geocode(self, location):
url = QUrl("http://maps.googleapis.com/maps/api/geocode/xml")
query = QUrlQuery()
query.addQueryItem("address", location)
query.addQueryItem("sensor", "false")
url.setQuery(query)
"""
url = QUrl("http://maps.google.com/maps/geo/")
url.addQueryItem("q", location)
url.addQueryItem("output", "csv")
url.addQueryItem("sensor", "false")
"""
request = QNetworkRequest(url)
reply = self.get(request)
while reply.isRunning():
QApplication.processEvents()
reply.deleteLater()
self.deleteLater()
return self._parseResult(reply)
def startDownload(self, qurl):
self.url = qurl
fileInfo = QFileInfo(self.url.path())
fileName = fileInfo.fileName()
filePath = os.join(QDir.homePath(), fileName)
if QFile.exists(filePath):
QFile.remove(filePath)
self.audioFile = QFile(filePath)
self.audioFile.open(QIODevice.WriteOnly)
self.nameLabel.setText(fileName)
self.statusLabel.setText(self.tr("Downloading..."))
self.request = QNetworkRequest(qurl)
self.request.setRawHeader("User-Agent", "Domestic Browser 1.0")
self.reply = self.manager.get(self.request)
self.reply.downloadProgress.connect(self.setProgress)
self.reply.readyRead.connect(self.fileReadyRead)
self.reply.finished.connect(self.finishDownload)
def make_request(self, *args, **kwargs):
"""Make the actual network request."""
url = QUrl(kwargs['url'])
request = QNetworkRequest(url)
for k, v in kwargs['headers'].items():
request.setRawHeader(k.encode(), v.encode())
start = arrow.utcnow().timestamp
reply = self.network_manager.sendCustomRequest(
request, kwargs['method'].encode(), kwargs['data'])
while reply.isRunning():
now = arrow.utcnow().timestamp
if now - start > 30:
print('make_request timed out.')
reply.abort()
else:
QCoreApplication.processEvents(QEventLoop.AllEvents, 100)
return reply
def __init__(self, api_port, api_key, error_handler):
QNetworkAccessManager.__init__(self)
url = QUrl("http://localhost:%d/events" % api_port)
self.request = QNetworkRequest(url)
self.request.setRawHeader(b'X-Api-Key', api_key.encode('ascii'))
self.remaining_connection_attempts = CORE_CONNECTION_ATTEMPTS_LIMIT
self.connect_timer = QTimer()
self.current_event_string = ""
self.reply = None
self.shutting_down = False
self.error_handler = error_handler
self._logger = logging.getLogger(self.__class__.__name__)
# This flag is used to prevent race condition when starting GUI tests
self.tribler_started_flag = False
self.reactions_dict = {
NTFY.CHANNEL_ENTITY_UPDATED.value:
self.node_info_updated.emit,
NTFY.TRIBLER_NEW_VERSION.value:
lambda data: self.new_version_available.emit(data["version"]),
NTFY.CHANNEL_DISCOVERED.value:
self.discovered_channel.emit,
NTFY.TORRENT_FINISHED.value:
self.torrent_finished.emit,
NTFY.LOW_SPACE.value:
self.low_storage_signal.emit,
NTFY.REMOTE_QUERY_RESULTS.value:
self.received_remote_query_results.emit,
NTFY.TRIBLER_SHUTDOWN_STATE.value:
self.tribler_shutdown_signal.emit,
NTFY.EVENTS_START.value:
self.events_start_received,
NTFY.REPORT_CONFIG_ERROR.value:
self.config_error_signal.emit,
NTFY.TRIBLER_EXCEPTION.value:
lambda data: self.error_handler.core_error(ReportedError(**data)),
}
self.connect_timer.setSingleShot(True)
connect(self.connect_timer.timeout, self.connect)
