def _wrap_request(self, request):
req = QNetworkRequest(request)
req_id = next(self._request_ids)
req.setAttribute(self._REQUEST_ID, req_id)
if hasattr(request, 'timeout'):
req.timeout = request.timeout
return req, req_id
def checkPluginUpdatesAvailable(self):
"""
Public method to check the availability of updates of plug-ins.
"""
period = Preferences.getPluginManager("UpdatesCheckInterval")
if period == 0:
return
elif period in [1, 2, 3]:
lastModified = QFileInfo(self.pluginRepositoryFile).lastModified()
if lastModified.isValid() and lastModified.date().isValid():
lastModifiedDate = lastModified.date()
now = QDate.currentDate()
if period == 1 and lastModifiedDate.day() == now.day():
# daily
return
elif period == 2 and lastModifiedDate.daysTo(now) < 7:
# weekly
return
elif period == 3 and \
(lastModifiedDate.daysTo(now) <
lastModifiedDate.daysInMonth()):
# monthly
return
self.__updateAvailable = False
request = QNetworkRequest(
QUrl(Preferences.getUI("PluginRepositoryUrl6")))
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.AlwaysNetwork)
reply = self.__networkManager.get(request)
reply.finished.connect(self.__downloadRepositoryFileDone)
self.__replies.append(reply)
def _makeRequestByType(self, request_type: str) -> None:
Logger.log("i", "Requesting %s metadata from server.", request_type)
request = QNetworkRequest(self._request_urls[request_type])
for header_name, header_value in self._request_headers:
request.setRawHeader(header_name, header_value)
if self._network_manager:
self._network_manager.get(request)
def on_searchPushButton_clicked(self, checked):
if self.categoryID != '' and self.categoryID != '-1':
merchandising = Merchandising(warnings = False)
response = merchandising.execute(
'getMostWatchedItems',
{
'categoryId': self.categoryID,
'maxResults': self.ui.spinBox.value()
}
)
reply = response.reply
itemRecommendations = reply.itemRecommendations.item
row = self.ui.tableWidget.rowCount()
for item in itemRecommendations:
self.ui.tableWidget.insertRow(row)
imageUrl = 'http://thumbs3.ebaystatic.com/pict/%s4040.jpg' % item.itemId
request = QNetworkRequest(QUrl(imageUrl))
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute, QNetworkRequest.PreferCache)
reply = self.manager.get(request)
self.replyMap[reply] = row
viewItemURL = QLabel()
viewItemURL.setOpenExternalLinks(True)
#viewItemURL.setTextInteractionFlags(Qt.TextBrowserInteraction)
title = '<a href="%s">%s</a>' % (item.viewItemURL, item.title)
viewItemURL.setText(title)
self.ui.tableWidget.setCellWidget(row, 1, viewItemURL)
self.ui.tableWidget.setItem(row, 2, QTableWidgetItem(item.primaryCategoryName))
self.ui.tableWidget.setItem(row, 3, QTableWidgetItem(item.buyItNowPrice.value))
self.ui.tableWidget.setItem(row, 4, QTableWidgetItem(item.watchCount))
row += 1
def _createEmptyRequest(self, target: str, content_type: Optional[str] = "application/json") -> QNetworkRequest:
url = QUrl("http://" + self._address + self._api_prefix + target)
request = QNetworkRequest(url)
if content_type is not None:
request.setHeader(QNetworkRequest.ContentTypeHeader, content_type)
request.setHeader(QNetworkRequest.UserAgentHeader, self._user_agent)
return request
def __downloadFile(self, url, filename, doneMethod=None):
"""
Private slot to download the given file.
@param url URL for the download (string)
@param filename local name of the file (string)
@param doneMethod method to be called when done
"""
self.__updateButton.setEnabled(False)
self.__downloadButton.setEnabled(False)
self.__downloadInstallButton.setEnabled(False)
self.__downloadCancelButton.setEnabled(True)
self.statusLabel.setText(url)
self.__doneMethod = doneMethod
self.__downloadURL = url
self.__downloadFileName = filename
self.__downloadIODevice = QFile(self.__downloadFileName + ".tmp")
self.__downloadCancelled = False
request = QNetworkRequest(QUrl(url))
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.AlwaysNetwork)
reply = self.__networkManager.get(request)
reply.finished.connect(self.__downloadFileDone)
reply.downloadProgress.connect(self.__downloadProgress)
self.__replies.append(reply)
def _createRequest(self, url: str, basic_auth_username: str = "", basic_auth_password: str = "") -> QNetworkRequest:
request = QNetworkRequest(url)
request.setRawHeader("User-Agent".encode(), 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("Authorization".encode(), ("Basic %s" % data).encode())
return request
def _wrap_request(self, request):
req = QNetworkRequest(request)
req_id = next(self._request_ids)
req.setAttribute(self._REQUEST_ID, req_id)
for attr in ['timeout', 'track_response_body']:
if hasattr(request, attr):
setattr(req, attr, getattr(request, attr))
return req, req_id
def _createEmptyRequest(self, path: str, content_type: Optional[str] = "application/json") -> QNetworkRequest:
request = QNetworkRequest(QUrl(path))
if content_type:
request.setHeader(QNetworkRequest.ContentTypeHeader, content_type)
access_token = self._account.accessToken
if access_token:
request.setRawHeader(b"Authorization", "Bearer {}".format(access_token).encode())
return request
def _update(self):
## Request 'general' printer data
url = QUrl("http://" + self._address + self._api_prefix + "printer")
self._printer_request = QNetworkRequest(url)
self._printer_request.setRawHeader(self._api_header.encode(), self._api_key.encode())
self._printer_reply = self._manager.get(self._printer_request)
## Request print_job data
url = QUrl("http://" + self._address + self._api_prefix + "job")
self._job_request = QNetworkRequest(url)
self._job_request.setRawHeader(self._api_header.encode(), self._api_key.encode())
self._job_reply = self._manager.get(self._job_request)
def perform_put(self, endpoint, data, url):
"""
Perform an HTTP PUT request.
:param endpoint: the name of the Tribler endpoint.
:param data: the data/body to send with the request.
:param url: the url to send the request to.
"""
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded")
reply = self.put(request, data)
return reply
def _load_content(self, content_type, content):
"""
This method is for displaying some content of
such types: local web pages, remote web pages,
local pdf`s, local videos.
It should be called like in the following example
to work correctly:
self._load_content('local_video', 'some_video.mp4')
"""
self._main_browser_reset_zoom() # reset zoom
if content_type == 'local_url':
source = config['flask_server_home'] + \
config['flask_server_local_page_client'] + \
content # simply get the file from flask-server by its relative path-id
# specify type of currently opened file for zoom and scroll methods
self._cur_filetype = "webpage"
elif content_type == 'external_url':
self._cur_filetype = "webpage"
# no needs required as, link should be given in
# 'http://yoursite.com/yourpage'
source = content
elif content_type == 'local_pdf':
# to render PDF`s we use PDF.js, so we open its page and send it a
# path for the target file.
source = config['flask_server_home'] + \
config['flask_server_local_page_client'] + \
content
self._cur_filetype = "pdf"
elif content_type == 'local_video':
# in case of opening local videos we need to modify the path to the video in the source code of
# the videoplayer, so don`t die after reading this code. It works just in the same style as other
# filetypes, but in a very weird way.
source = config['flask_server_home'] + \
config['flask_server_video_addr_client'] + content
logger.info('Opening video at {}'.format(source))
self._cur_filetype = "video"
# Set a custom user agent to avoid message about deprecated version of
# browser
self._main_browser.page().userAgentForUrl = self._custom_ua
logger.info('Loading data on address: {}'.format(source))
# Create a request to be able to set user-agent data. Without
# it, it`s impossible to customize request data.
request = QNetworkRequest()
request.setUrl(QUrl(source))
request.setRawHeader("USER-AGENT", config['output_user_agent'])
# and finally load the result
self._main_browser.load(request)
def junk(app):
userapi = "https://api.gitter.im/v1/user"
roomapi = "https://api.gitter.im/v1/rooms/{}/rooms"
streamapi = 'https://stream.gitter.im/v1/rooms/{}/chatMessages'
userurl = QUrl(userapi)
#roomsurl = QUrl(roomapi.format(user_id))
#encoded = QUrl(streamapi.format(encoded_id))
req = QNetworkRequest(userurl)
req.setRawHeader("Accept", "application/json")
req.setRawHeader("Authorization", 'Bearer '+token)
resp = app.net.get(req)
resp.readyRead.connect(lambda : viewresp(resp))
def __tabContextMenuClone(self):
"""
Private method to clone the selected tab.
"""
idx = self.__tabContextMenuIndex
if idx < 0:
idx = self.currentIndex()
if idx < 0 or idx > self.count():
return
req = QNetworkRequest(self.widget(idx).url())
req.setRawHeader(b"X-Eric6-UserLoadAction", b"1")
self.newBrowser(None, (req, QNetworkAccessManager.GetOperation, b""))
def _doGet(self, path):
url = urlunsplit(('http', self.addr, path, '', ''))
sig = self._sign(b'GET', path.encode('utf-8'), b'')
headers = {
HMAC_HEADER: b64encode(sig)
}
request = QNetworkRequest(QUrl(url))
for hname in headers:
request.setRawHeader(hname, headers[hname])
reply = self.network.get(request)
return reply
def _doPost(self, path, **params):
url = urlunsplit(('http', self.addr, path, '', ''))
body = json.dumps(params)
sig = self._sign(b'POST', path.encode('utf-8'), body.encode('utf-8'))
headers = {
HMAC_HEADER: b64encode(sig),
'Content-Type': 'application/json'
}
request = QNetworkRequest(QUrl(url))
for hname in headers:
request.setRawHeader(hname, headers[hname])
reply = self.network.post(request, body)
return reply
def post(self, url, param=None, data=None, json=True):
if isinstance(data, dict):
f = ''
for i in data:
f += '{}={}&'.format(i, data[i])
data = f[:-1]
byte_data = QtCore.QByteArray()
byte_data.append(data)
url = QtCore.QUrl(parse_url(url, param))
request = QNetworkRequest(url)
if json:
request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/json')
reply = self.session.post(request, byte_data)
return reply
def __lineEditReturnPressed(self):
"""
Private slot to handle the entering of an URL.
"""
edit = self.sender()
url = self.__guessUrlFromPath(edit.text())
request = QNetworkRequest(url)
request.setRawHeader(b"X-Eric6-UserLoadAction", b"1")
if e5App().keyboardModifiers() == Qt.AltModifier:
self.newBrowser(
None, (request, QNetworkAccessManager.GetOperation, b""))
else:
self.currentBrowser().setSource(
None, (request, QNetworkAccessManager.GetOperation, b""))
self.currentBrowser().setFocus()
def _setJobState(self, job_state):
if not self._selected_printer:
return
selected_printer_uuid = self._printers_dict[self._selected_printer["unique_name"]]["uuid"]
if selected_printer_uuid not in self._print_job_by_printer_uuid:
return
print_job_uuid = self._print_job_by_printer_uuid[selected_printer_uuid]["uuid"]
url = QUrl(self._api_base_uri + "print_jobs/" + print_job_uuid + "/action")
put_request = QNetworkRequest(url)
put_request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json")
data = '{"action": "' + job_state + '"}'
self._manager.put(put_request, data.encode())
def getSearchRequestData(cls, term):
"""
Class method to assemble the search request data structure.
@param term search term (string)
@return tuple of network request object, operation and parameters
(QNetworkRequest, QNetworkAccessManager.Operation, QByteArray)
"""
request = QNetworkRequest(QUrl(cls.SearchUrl))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
op = QNetworkAccessManager.PostOperation
params = QByteArray("chain=").append(QUrl.toPercentEncoding(term))
return (request, op, params)
def download(self, requestOrUrl, requestFileName=False, mainWindow=None):
"""
Public method to download a file.
@param requestOrUrl reference to a request object (QNetworkRequest)
or a URL to be downloaded (QUrl)
@keyparam requestFileName flag indicating to ask for the
download file name (boolean)
@keyparam mainWindow reference to the main window (HelpWindow)
"""
request = QNetworkRequest(requestOrUrl)
if request.url().isEmpty():
return
self.handleUnsupportedContent(
self.__manager.get(request), requestFileName=requestFileName, download=True, mainWindow=mainWindow
)
def acceptNavigationRequest(self,
_frame: QWebFrame,
request: QNetworkRequest,
typ: QWebPage.NavigationType):
"""Override acceptNavigationRequest to handle clicked links.
Setting linkDelegationPolicy to DelegateAllLinks and using a slot bound
to linkClicked won't work correctly, because when in a frameset, we
have no idea in which frame the link should be opened.
Checks if it should open it in a tab (middle-click or control) or not,
and then conditionally opens the URL. Opening it in a new tab/window
is handled in the slot connected to link_clicked.
"""
url = request.url()
target = self._tabdata.combined_target()
log.webview.debug("navigation request: url {}, type {}, "
"target {}".format(
url.toDisplayString(),
debug.qenum_key(QWebPage, typ),
target))
if typ == QWebPage.NavigationTypeReload:
self.reloading.emit(url)
return True
elif typ != QWebPage.NavigationTypeLinkClicked:
return True
self.link_clicked.emit(url)
return url.isValid() and target == usertypes.ClickTarget.normal
def __getFileScanReportUrl(self, scanId):
"""
Private method to get the report URL for a file scan.
@param scanId ID of the scan to get the report URL for (string)
"""
request = QNetworkRequest(QUrl(self.GetUrlReportUrl))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
params = QByteArray("key={0}&resource={1}".format(
Preferences.getHelp("VirusTotalServiceKey"), scanId))
import Helpviewer.HelpWindow
nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager()
reply = nam.post(request, params)
reply.finished.connect(self.__getFileScanReportUrlFinished)
self.__replies.append(reply)
def __init__(self, url):
super(FLNetwork, self).__init__()
self.url = url
from PyQt5.QtNetwork import QNetworkRequest, QNetworkAccessManager
self.request = QNetworkRequest()
self.manager = QNetworkAccessManager()
# self.manager.readyRead.connect(self._slotNetworkStart)
self.manager.finished['QNetworkReply*'].connect(self._slotNetworkFinished)
def get(self, url, *, user_agent=None, **kwargs):
"""Start a download with a link URL.
Args:
url: The URL to get, as QUrl
user_agent: The UA to set for the request, or None.
**kwargs: passed to get_request().
Return:
The created DownloadItem.
"""
if not url.isValid():
urlutils.invalid_url_error(url, "start download")
return None
req = QNetworkRequest(url)
if user_agent is not None:
req.setHeader(QNetworkRequest.UserAgentHeader, user_agent)
return self.get_request(req, **kwargs)
class DownloadManager(QNetworkAccessManager):
def __init__(self, parent=None):
super().__init__(parent)
def addUrl(self, url):
print(url)
self.request = QNetworkRequest(QUrl(url))
self.request.setRawHeader(b"User-Agent", b"Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1")
self.reply = self.get(self.request)
self.reply.downloadProgress.connect(self.setProgress)
return self.request
def setProgress(self, a, s):
print(a, s)
def submitUrl(self, url):
"""
Public method to submit an URL to be scanned.
@param url url to be scanned (QUrl)
"""
request = QNetworkRequest(QUrl(self.ScanUrlUrl))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
params = QByteArray("key={0}&url=".format(
Preferences.getHelp("VirusTotalServiceKey")))\
.append(QUrl.toPercentEncoding(url.toString()))
import Helpviewer.HelpWindow
nam = Helpviewer.HelpWindow.HelpWindow.networkAccessManager()
reply = nam.post(request, params)
reply.finished.connect(self.__submitUrlFinished)
self.__replies.append(reply)
def downloadBinPackage(packageUrl, destinationFileName):
request = QNetworkRequest(QUrl(packageUrl))
request.setRawHeader(b'Accept-Encoding', b'gzip,deflate')
reply = QgsNetworkAccessManager.instance().get(request)
evloop = QEventLoop()
reply.finished.connect(evloop.quit)
evloop.exec_(QEventLoop.ExcludeUserInputEvents)
content_type = reply.rawHeader(b'Content-Type')
if content_type == b'application/zip':
if os.path.isfile(destinationFileName):
os.unlink(destinationFileName)
destinationFile = open(destinationFileName, 'wb')
destinationFile.write(bytearray(reply.readAll()))
destinationFile.close()
else:
ret_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
raise IOError("{} {}".format(ret_code, packageUrl))
def downloadAndInstallPlugin(self, url):
Logger.log("i", "Attempting to download & install plugin from %s", url)
url = QUrl(url)
self._download_plugin_request = QNetworkRequest(url)
self._download_plugin_request.setRawHeader(*self._request_header)
self._download_plugin_reply = self._network_manager.get(self._download_plugin_request)
self._download_progress = 0
self.setIsDownloading(True)
self.onDownloadProgressChanged.emit()
self._download_plugin_reply.downloadProgress.connect(self._onDownloadPluginProgress)
def checkServiceKeyValidity(self, key, protocol=""):
"""
Public method to check the validity of the given service key.
@param key service key (string)
@param protocol protocol used to access VirusTotal (string)
"""
if protocol == "":
urlStr = self.GetFileReportUrl
else:
urlStr = self.GetFileReportPattern.format(protocol)
request = QNetworkRequest(QUrl(urlStr))
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
params = QByteArray("apikey={0}&resource={1}".format(
key, self.TestServiceKeyScanID).encode("utf-8"))
import WebBrowser.WebBrowserWindow
nam = (WebBrowser.WebBrowserWindow.WebBrowserWindow.networkManager())
reply = nam.post(request, params)
reply.finished.connect(
lambda: self.__checkServiceKeyValidityFinished(reply))
self.__replies.append(reply)
def get_update_bg(self):
""" 获取更新时的背景图 """
old_update_file = os.path.join(BASE_DIR, "classini/update_{}_{}.json".format(PLATEFORM, self.sys_bit))
if not os.path.exists(old_update_file):
pixmap = QPixmap('media/update_bg.png')
scaled_map = pixmap.scaled(QSize(500, 200), Qt.KeepAspectRatio)
self.setPixmap(scaled_map)
else:
with open(old_update_file, "r", encoding="utf-8") as old_fp:
old_json = json.load(old_fp)
server = old_json.get("SERVER", "http://210.13.218.130:9004/static/")
url = server + "update_image_bg.png"
reply = self.network_manager.get(QNetworkRequest(QUrl(url)))
reply.finished.connect(self.start_image_reply)
def start(self) -> None:
self.stop() # Ensure that previous requests (if any) are stopped.
if not self._source_url:
Logger.log("w", "Unable to start camera stream without target!")
return
self._started = True
Logger.log("w", "MJPEG starting stream...")
self._image_request = QNetworkRequest(self._source_url)
if self._network_manager is None:
self._network_manager = QNetworkAccessManager()
self._image_reply = self._network_manager.get(self._image_request)
self._image_reply.downloadProgress.connect(self._onStreamDownloadProgress)
def __init__(self, url, parent=None):
"""
Constructor
@param url xmlrpc handler URL (string or QUrl)
@param parent parent object (QObject)
"""
super(E5XmlRpcClient, self).__init__(parent)
# attributes for the network objects
self.__networkManager = QNetworkAccessManager(self)
self.__networkManager.proxyAuthenticationRequired.connect(
proxyAuthenticationRequired)
self.__networkManager.finished.connect(self.__replyFinished)
if SSL_AVAILABLE:
self.__sslErrorHandler = E5SslErrorHandler(self)
self.__networkManager.sslErrors.connect(self.__sslErrors)
self.__callmap = {}
self.__request = QNetworkRequest(QUrl(url))
self.__request.setRawHeader(b"User-Agent", b"E5XmlRpcClient/1.0")
self.__request.setHeader(QNetworkRequest.ContentTypeHeader, "text/xml")
def get_resource(
name: str,
dominode_base_url: str,
network_manager: QgsNetworkAccessManager,
feedback: typing.Optional[QgsFeedback] = None,
) -> typing.Optional[typing.Dict]:
url_query = QUrlQuery()
url_query.addQueryItem('name', name)
url = QUrl(
f'{dominode_base_url}/dominode-validation/api/dominode-resources/')
url.setQuery(url_query)
request = QNetworkRequest(url)
request.setHeader(QNetworkRequest.ContentTypeHeader, 'application/json')
reply = network_manager.blockingGet(request, '', True, feedback=feedback)
status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
result = None
if status_code == 200:
raw_string_contents = bytes(reply.content()).decode('utf-8')
contents = json.loads(raw_string_contents)
exists = contents.get('count', 0) > 0
if exists:
result = contents['results'][0]
return result
def save_option_to_server(self, chart_type):
""" 保存图形的配置到服务器 """
chart_option = self.get_chart_option() # 作图配置
chart_option["chart_category"] = chart_type # 图表类型(普通图形:normal,季节图形:season)
title = chart_option["title"]["text"]
if not title:
QMessageBox.information(self, "提示", "请填写图形标题!")
return
is_private = 1 if self.chart_widget.private_check.checkState() else 0
json_option = {
"title": title,
"variety_en": self.variety_en,
"decipherment": self.chart_widget.decipherment_edit.text().strip(),
"is_private": is_private,
"option": chart_option.copy()
}
network_manager = getattr(qApp, "_network")
url = SERVER_API + "sheet/{}/chart/".format(self.sheet_id)
request = QNetworkRequest(QUrl(url))
user_token = get_user_token()
request.setRawHeader("Authorization".encode("utf-8"), user_token.encode("utf-8"))
reply = network_manager.post(request, json.dumps(json_option).encode("utf-8"))
reply.finished.connect(self.save_option_reply)
def _startCamera(self):
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
if not global_container_stack or not parseBool(
global_container_stack.getMetaDataEntry(
"octoprint_show_camera", False)) or self._camera_url == "":
return
# Start streaming mjpg stream
url = QUrl(self._camera_url)
self._image_request = QNetworkRequest(url)
self._image_reply = self._manager.get(self._image_request)
self._image_reply.downloadProgress.connect(
self._onStreamDownloadProgress)
def connect(self):
self._createNetworkManager()
self.setConnectionState(ConnectionState.connecting)
self._update(
) # Manually trigger the first update, as we don't want to wait a few secs before it starts.
Logger.log("d", "Connection with instance %s with url %s started",
self._key, self._base_url)
self._update_timer.start()
self._last_response_time = None
self.setAcceptsCommands(False)
self.setConnectionText(
i18n_catalog.i18nc("@info:status",
"Connecting to OctoPrint on {0}").format(
self._key))
## Request 'settings' dump
url = QUrl(self._api_url + "settings")
self._settings_request = QNetworkRequest(url)
self._settings_request.setRawHeader(self._api_header.encode(),
self._api_key.encode())
self._settings_reply = self._manager.get(self._settings_request)
def startDownload(self, req):
loop = QtCore.QEventLoop()
QtCore.QTimer.singleShot(5000, loop.quit)
self.reply = self.networkmanager.get(req)
self.reply.metaDataChanged.connect(loop.quit)
loop.exec_()
#wait(1000)
if self.reply.hasRawHeader(b'Location'):
URL = QtCore.QUrl.fromUserInput(
_str(self.reply.rawHeader(b'Location')))
self.reply.abort()
req = QNetworkRequest(URL)
req.setRawHeader(b'User-Agent', self.useragent)
self.startDownload(req)
return
#print(self.reply.url().toString())
if self.reply.isFinished():
self.dataReceived()
self.downloadStopped()
return
self.reply.finished.connect(self.downloadStopped)
#self.reply.readyRead.connect(self.dataReceived)
self.reply.error.connect(self.downloadError)
def get_daily_source_file(self):
""" 获取日交易源数据xls文件 """
if self.date is None:
raise DateValueError("请先使用`set_date`设置`DCESpider`日期.")
url = "http://www.dce.com.cn/publicweb/quotesdata/exportDayQuotesChData.html"
form_params = {
"dayQuotes.variety": "all",
"dayQuotes.trade_type": "0",
"year": str(self.date.year),
"month": str(self.date.month - 1),
"day": self.date.strftime("%d"),
"exportFlag": "excel"
}
form_data = generate_multipart_data(text_dict=form_params)
network_manager = getattr(qApp, "_network")
request = QNetworkRequest(QUrl(url))
request.setHeader(QNetworkRequest.UserAgentHeader,
random.choice(USER_AGENTS))
reply = network_manager.post(request, form_data)
reply.finished.connect(self.daily_source_file_reply)
form_data.setParent(reply)
def _wrap_request(self, request):
req = QNetworkRequest(request)
req_id = next(self._request_ids)
req.setAttribute(self._REQUEST_ID, req_id)
if self.disable_browser_caches:
# disables the network cache
# see http://doc.qt.io/qt-5/qnetworkrequest.html#CacheLoadControl-enum
req.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.AlwaysNetwork)
req.setAttribute(QNetworkRequest.CacheSaveControlAttribute, False)
for attr in ['timeout', 'track_request_body', 'track_response_body']:
if hasattr(request, attr):
setattr(req, attr, getattr(request, attr))
return req, req_id
def __init__(self, scene):
QWidget.__init__(self)
self.scene = scene
self.properties = scene[PROPERTIES]
self.setMouseTracking(True)
datetime = iso8601.parse_date(self.properties["acquired"])
time = datetime.strftime("%H:%M:%S")
date = datetime.strftime("%b %d, %Y")
text = f"""{date}<span style="color: rgb(100,100,100);"> {time} UTC</span><br>
<b>{PlanetClient.getInstance().item_types_names()[self.properties['item_type']]}</b>
"""
self.nameLabel = QLabel(text)
self.iconLabel = QLabel()
self.toolsButton = QLabel()
self.toolsButton.setPixmap(COG_ICON.pixmap(QSize(18, 18)))
self.toolsButton.mousePressEvent = self.showContextMenu
pixmap = QPixmap(PLACEHOLDER_THUMB, "SVG")
thumb = pixmap.scaled(48, 48, Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.iconLabel.setPixmap(thumb)
layout = QHBoxLayout()
layout.setMargin(2)
vlayout = QVBoxLayout()
vlayout.setMargin(0)
vlayout.addWidget(self.iconLabel)
self.iconWidget = QWidget()
self.iconWidget.setFixedSize(48, 48)
self.iconWidget.setLayout(vlayout)
layout.addWidget(self.iconWidget)
layout.addWidget(self.nameLabel)
layout.addStretch()
layout.addWidget(self.toolsButton)
layout.addSpacing(10)
self.setLayout(layout)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.iconDownloaded)
url = f"{scene['_links']['thumbnail']}?api_key={PlanetClient.getInstance().api_key()}"
self.nam.get(QNetworkRequest(QUrl(url)))
self.footprint = QgsRubberBand(iface.mapCanvas(), QgsWkbTypes.PolygonGeometry)
self.footprint.setStrokeColor(PLANET_COLOR)
self.footprint.setWidth(2)
self.geom = qgsgeometry_from_geojson(scene[GEOMETRY])
self.setStyleSheet("SceneItemWidget{border: 2px solid transparent;}")
def __init__(self):
super().__init__()
self.settings = QSettings("tasmotizer.cfg", QSettings.IniFormat)
self.nam = QNetworkAccessManager()
self.nrRelease = QNetworkRequest(
QUrl("http://thehackbox.org/tasmota/release/release.php"))
self.nrDevelopment = QNetworkRequest(
QUrl("http://thehackbox.org/tasmota/development.php"))
self.setWindowTitle("Tasmotizer 1.1")
self.setMinimumWidth(480)
self.mode = 0 # BIN file
self.bin_file = ""
self.release_data = b""
self.development_data = b""
self.createUI()
self.refreshPorts()
self.getHackBoxFeeds()
def start_load(self, url):
"""Create a Poppler.Document from the given URL, QUrl or filename.
Return, then asynchronously call self.load_cb.
"""
# If it's not a local file, we'll need to load it.
# http://doc.qt.io/qt-5/qnetworkaccessmanager.html
qurl = QUrl(url)
if not qurl.scheme():
qurl = QUrl.fromLocalFile(url)
if not self.network_manager:
self.network_manager = QNetworkAccessManager()
self.network_manager.finished.connect(self.download_finished)
self.network_manager.get(QNetworkRequest(qurl))
def login(self, name_field, pass_field):
print("Logging in...")
self.statusBar().showMessage('Logging in...')
self.Username = name_field.text()
url = QtCore.QUrl(self.url_list['login'])
request = QNetworkRequest()
request.setUrl(url)
request.setHeader(QNetworkRequest.ContentTypeHeader,
"application/x-www-form-urlencoded")
data = QtCore.QByteArray()
data.append(''.join(['user='******'&']))
data.append(''.join(['password=', pass_field.text()]))
self.replyObjectLogin = self.manager.post(request, data)
self.replyObjectLogin.finished.connect(self.loginFinalize)
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.connect_timer.setSingleShot(True)
connect(self.connect_timer.timeout, self.connect)
self.notifier = notifier = Notifier()
notifier.add_observer(notifications.events_start, self.on_events_start)
notifier.add_observer(notifications.tribler_exception,
self.on_tribler_exception)
notifier.add_observer(notifications.channel_entity_updated,
self.on_channel_entity_updated)
notifier.add_observer(notifications.tribler_new_version,
self.on_tribler_new_version)
notifier.add_observer(notifications.channel_discovered,
self.on_channel_discovered)
notifier.add_observer(notifications.torrent_finished,
self.on_torrent_finished)
notifier.add_observer(notifications.low_space, self.on_low_space)
notifier.add_observer(notifications.remote_query_results,
self.on_remote_query_results)
notifier.add_observer(notifications.tribler_shutdown_state,
self.on_tribler_shutdown_state)
notifier.add_observer(notifications.report_config_error,
self.on_report_config_error)
def __downloadFile(self, url, filename, doneMethod=None):
"""
Private slot to download the given file.
@param url URL for the download (string)
@param filename local name of the file (string)
@param doneMethod method to be called when done
"""
if self.__networkConfigurationManager.isOnline():
self.__updateButton.setEnabled(False)
self.__downloadButton.setEnabled(False)
self.__downloadInstallButton.setEnabled(False)
self.__downloadCancelButton.setEnabled(True)
self.statusLabel.setText(url)
self.__doneMethod = doneMethod
self.__downloadURL = url
self.__downloadFileName = filename
self.__downloadIODevice = QFile(self.__downloadFileName + ".tmp")
self.__downloadCancelled = False
request = QNetworkRequest(QUrl(url))
request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QNetworkRequest.AlwaysNetwork)
reply = self.__networkManager.get(request)
reply.finished.connect(self.__downloadFileDone)
reply.downloadProgress.connect(self.__downloadProgress)
self.__replies.append(reply)
else:
E5MessageBox.warning(
self,
self.tr("Error downloading file"),
self.tr(
"""<p>Could not download the requested file"""
""" from {0}.</p><p>Error: {1}</p>"""
).format(url, self.tr("Computer is offline.")))
def start(self) -> None:
self.stop() # Ensure that previous requests (if any) are stopped.
if not self._source_url:
Logger.log("w", "Unable to start camera stream without target!")
return
auth_data = ""
if self._source_url.userInfo():
# move auth data to basic authorization header
auth_data = base64.b64encode(
self._source_url.userInfo().encode()).decode("utf-8")
authority = self._source_url.authority()
self._source_url.setAuthority(authority.rsplit("@", 1)[1])
self._image_request = QNetworkRequest(self._source_url)
self._image_request.setAttribute(
QNetworkRequest.FollowRedirectsAttribute, True)
if auth_data:
self._image_request.setRawHeader(b"Authorization",
("basic %s" % auth_data).encode())
if self._source_url.scheme().lower() == "https":
# ignore SSL errors (eg for self-signed certificates)
ssl_configuration = QSslConfiguration.defaultConfiguration()
ssl_configuration.setPeerVerifyMode(QSslSocket.VerifyNone)
self._image_request.setSslConfiguration(ssl_configuration)
if self._network_manager is None:
self._network_manager = QNetworkAccessManager()
self._image_reply = self._network_manager.get(self._image_request)
self._image_reply.downloadProgress.connect(
self._onStreamDownloadProgress)
self._started = True
def download_tile(self, tile: "Tile"):
self.__url = QUrl(self.server_pattern.format(tile.zoom, tile.x,
tile.y))
if (tile.x, tile.y) not in self.__visited:
request = QNetworkRequest()
request.setUrl(self.__url)
request.setAttribute(QNetworkRequest.User, (tile.x, tile.y))
self.__manager.get(request)
self.__visited.add((tile.x, tile.y))
def get(self, url, **kwargs):
"""Start a download with a link URL.
Args:
url: The URL to get, as QUrl
**kwargs: passed to get_request().
Return:
The created DownloadItem.
"""
if not url.isValid():
urlutils.invalid_url_error(url, "start download")
return
req = QNetworkRequest(url)
return self.get_request(req, **kwargs)
def fill_async_data(self):
if self.window.pkgs:
for idx, app_v in enumerate(self.window.pkgs):
if app_v.status == PackageViewStatus.LOADING and app_v.model.status == PackageStatus.READY:
if self.download_icons:
self.network_man.get(
QNetworkRequest(QUrl(app_v.model.icon_url)))
self._update_row(app_v, change_update_col=False)
app_v.status = PackageViewStatus.READY
self.window.resize_and_center()
def download(self, url: str, path: Path):
url = QUrl(url)
req = QNetworkRequest(url)
worker_loop = QEventLoop(self)
reply = self._nam.get(req)
reply.finished.connect(worker_loop.quit)
reply.downloadProgress.connect(self._download_update)
worker_loop.exec()
qbytes = reply.readAll() # type: QByteArray
with path.open("wb") as file:
file.write(qbytes.data())
self.finished.emit()
def start(self):
# Ensure that previous requests (if any) are stopped.
self.stop()
if self._target is None:
Logger.log("w", "Unable to start camera stream without target!")
return
self._started = True
url = QUrl(self._target)
self._image_request = QNetworkRequest(url)
if self._manager is None:
self._manager = QNetworkAccessManager()
self._image_reply = self._manager.get(self._image_request)
self._image_reply.downloadProgress.connect(
self._onStreamDownloadProgress)
def edit_user_module_authority(self):
""" 编辑用户权限 """
row_index = getattr(self.sender(), "row_index")
module_id = self.module_auth.module_auth_table.item(row_index,
0).text()
module_text = self.module_auth.module_auth_table.item(row_index,
1).text()
expire_date = self.module_auth.module_auth_table.item(row_index,
3).text()
body_data = {
"modify_user": self.module_auth.current_user_id,
"module_id": module_id,
"module_text": module_text,
"expire_date": expire_date
}
network_manager = getattr(qApp, "_network")
user_token = get_user_token()
url = SERVER_API + "user/module-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_module_authority_reply)
def confirm_user_variety_authority(self):
""" 确定修改用户的品种权限 """
current_row = getattr(self.sender(), "row_index")
variety_id = self.variety_auth.variety_auth_table.item(current_row,
0).text()
variety_en = self.variety_auth.variety_auth_table.item(current_row,
2).text()
expire_date = self.variety_auth.variety_auth_table.item(
current_row, 6).text()
body_data = {
"modify_user": self.variety_auth.current_user_id,
"variety_id": variety_id,
"variety_en": variety_en,
"expire_date": expire_date
}
network_manager = getattr(qApp, "_network")
user_token = get_user_token()
url = SERVER_API + "user/variety-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_variety_authority_reply)
def _sendRequest(self, url, params, headers={}):
if self.asynchonous:
if self.reply is not None:
self.reply.finished.disconnect(self.reply_finished)
self.reply.abort()
self.reply = None
url = QUrl(url)
q = QUrlQuery(url)
for key, value in params.items():
q.addQueryItem(key, value)
url.setQuery(q)
QgsLogger.debug('Request: {}'.format(url.toEncoded()))
request = QNetworkRequest(url)
for key, value in headers.items():
request.setRawHeader(key, value)
self.reply = QgsNetworkAccessManager.instance().get(request)
self.reply.finished.connect(self.reply_finished)
else:
response = urlopen(self.url + '?' + urllib.urlencode(params))
data = json.load(response)
self.load_data(data)
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
cast(QNetworkRequest, self._download_request).setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
if hasattr(QNetworkRequest, "RedirectPolicyAttribute"):
# Patch for Qt 5.9+
cast(QNetworkRequest, self._download_request).setAttribute(QNetworkRequest.RedirectPolicyAttribute, True)
cast(QNetworkRequest, self._download_request).setRawHeader(*self._request_header)
self._download_reply = cast(QNetworkAccessManager, self._network_manager).get(self._download_request)
self.setDownloadProgress(0)
self.setIsDownloading(True)
cast(QNetworkReply, self._download_reply).downloadProgress.connect(self._onDownloadProgress)
def post(self, url, data=None):
"""Create a new POST request.
Args:
url: The URL to post to, as QUrl.
data: A dict of data to send.
"""
if data is None:
data = {}
encoded_data = urllib.parse.urlencode(data).encode('utf-8')
request = QNetworkRequest(url)
request.setHeader(QNetworkRequest.ContentTypeHeader,
'application/x-www-form-urlencoded;charset=utf-8')
reply = self._nam.post(request, encoded_data)
self._handle_reply(reply)
def _setJobState(self, job_state):
# if job_state == "abort":
# command = "cancel"
# elif job_state == "print":
# if self.jobState == "paused":
# command = "pause"
# else:
# command = "start"
# elif job_state == "pause":
# command = "pause"
urlString = ""
if job_state == "abort":
command = "cancel"
urlString = self._api_url + '?a=stopJob'
elif job_state == "print":
if self.jobState == "paused":
command = "pause"
urlString = self._api_url + '?a=send&data={"cmd":"@pause"}'
else:
command = "start"
urlString = self._api_url + '?a=continueJob'
elif job_state == "pause":
command = "pause"
urlString = self._api_url + '?a=send&data={"cmd":"@pause"}'
Logger.log("d", "XXX:Command:" + command)
Logger.log("d", "XXX:Command:" + urlString)
if urlString:
url = QUrl(urlString)
self._printer_request = QNetworkRequest(url)
self._printer_request.setRawHeader(self._api_header.encode(),
self._api_key.encode())
self._printer_reply = self._manager.get(self._printer_request)
def perform_delete(self, endpoint, data, url):
"""
Perform an HTTP DELETE request.
:param endpoint: the name of the Tribler endpoint.
:param data: the data/body to send with the request.
:param url: the url to send the request to.
"""
buf = QBuffer()
buf.setData(data)
buf.open(QIODevice.ReadOnly)
delete_request = QNetworkRequest(QUrl(url))
reply = self.sendCustomRequest(delete_request, "DELETE", buf)
buf.setParent(reply)
return reply
def send(params):
url = self.formatUrl(endpoint, params)
request = QNetworkRequest(url)
headers['User-Agent'] = 'Divi QGIS Plugin/%s' % PLUGIN_VERSION
QgsMessageLog.logMessage(str(headers), 'DIVI')
for key, value in headers.items():
request.setRawHeader(key.encode('utf-8'), value.encode('utf-8'))
if method == 'delete':
reply = manager.sendCustomRequest(request, 'DELETE'.encode('utf-8'), data)
else:
if not data:
reply = getattr(manager, method)(request)
elif isinstance(data, QHttpMultiPart) == True:
reply = getattr(manager, method)(request, data)
elif isinstance(data, str) == True:
reply = getattr(manager, method)(request, data.encode('utf-8'))
loop = QEventLoop()
reply.uploadProgress.connect(self.uploadProgress)
reply.downloadProgress.connect(self.downloadProgress)
reply.metaDataChanged.connect(self.metaDataChanged)
#reply.error.connect(self._error)
reply.finished.connect(loop.exit)
self.abort_sig.connect( reply.abort )
loop.exec_()
self.abort_sig.disconnect( reply.abort )
return reply
