def get_stations(self, transport_type):
self.__url = QUrl(
self.stations_pattern.format(self.str_type[transport_type]))
request = QNetworkRequest()
request.setUrl(self.__url)
request.setAttribute(QNetworkRequest.User, (Station, transport_type))
self.__manager.get(request)
def post(self, requestUrl, requestData, dataType="form",
extraHeaders=None):
"""
Public method to issue a POST request.
@param requestUrl URL of the request (QUrl)
@param requestData data of the request (QByteArray)
@keyparam dataType type of the request data (string)
@keyparam extraHeaders list of tuples of additional headers giving
header name (string) and header value (string)
@return tuple of server response (string) and flag indicating
success (boolean)
"""
request = QNetworkRequest(requestUrl)
request.setRawHeader(b"User-Agent",
b"Mozilla/5.0")
request.setRawHeader(b"Content-Type",
self.__contentTypes[dataType])
request.setRawHeader(b"Content-Length",
QByteArray.number(requestData.size()))
request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
if extraHeaders:
for name, value in extraHeaders:
request.setRawHeader(name, value)
request.setUrl(requestUrl)
reply = self.__networkManager.post(request, requestData)
if not self.__loop.isRunning():
self.__loop.exec_()
if reply.error() != QNetworkReply.NoError:
return reply.errorString(), False
else:
return str(reply.readAll(), "utf-8", "replace"), True
def make_request(cit):
org_cities = "|".join(cit[self.cluster_i_index])
dest_cities = "|".join(cit[self.cluster_j_index])
if self.cluster_i_index == len(
cit) - 1 and self.cluster_j_index == len(cit) - 1:
self.addicional_args.append(
[self.cluster_i_index, self.cluster_j_index, True])
else:
self.addicional_args.append(
[self.cluster_i_index, self.cluster_j_index, False])
url_text = url_header + "&origins=" + org_cities + "&destinations=" + dest_cities + "&key=" + self.key
url = QUrl(url_text)
nr = QNetworkRequest()
nr.setUrl(url)
self.redirect_fun = self._distance_matrix
self._busy = True
self.get_request(nr)
self.cluster_j_index += 1
if self.cluster_j_index == len(cit):
self.cluster_j_index = 0
self.cluster_i_index += 1
if self.cluster_i_index == len(cit):
self.timer.stop()
self.cluster_i_index = 0
self.cluster_j_index = 0
def getContent(self):
print("Getting content...")
url = PyQt5.QtCore.QUrl(self.url_list['content'])
request = QNetworkRequest()
request.setUrl(url)
self.replyObject = self.manager.get(request)
self.replyObject.finished.connect(self.populateTable)
def get_transports(self, transport_type, route):
self.__url = QUrl(
self.ettu_pattern_receiver.format(transport_type.value, route))
request = QNetworkRequest()
request.setUrl(self.__url)
request.setAttribute(QNetworkRequest.User, (Transport, transport_type))
self.__manager.get(request)
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 login(self, name_field, pass_field):
print("Logging in...")
self.Username = name_field.text()
url = PyQt5.QtCore.QUrl(self.url_list['login'])
request = QNetworkRequest()
request.setUrl(url)
request.setHeader(PyQt5.QtNetwork.QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded")
data = PyQt5.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 get_path_beetween_cities(self, city1, city2):
url_header = "https://maps.googleapis.com/maps/api/directions/json?language=pl"
url_text = url_header + "&origin=" + city1 + "&destination=" + city2 + "&key=" + self.key
url = QUrl(url_text)
nr = QNetworkRequest()
nr.setUrl(url)
self.dir_points = []
self.addicional_args.append([None])
self.redirect_fun = self._directions
self._busy = True
self.get_request(nr)
pass
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 _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 _download_signal(self, url):
request = QNetworkRequest()
request.setRawHeader(
str("Range").encode(),
str("bytes=" + str(self.attributes.preProgress) + "-").encode())
# 设置自动重定向,之前自己实现的链接跳转就可以去掉了
request.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
request.setUrl(QUrl(url))
self.changeState(DownloaderAttributes.States.downloading)
self._reply = self._manager.get(request)
self._reply.downloadProgress.connect(self.writeFile)
self._reply.finished.connect(self.downloadError)
return True
def download_chlists(self, subscriptions):
self.load_user_chlist()
self.load_cached_chlists(subscriptions)
urls = []
for subscription in subscriptions:
if subscription[0] == True:
urls.append(QUrl(subscription[1]))
self.access_manager = QNetworkAccessManager()
self.access_manager.finished.connect(self.handle_response)
for url in urls:
request = QNetworkRequest()
request.setUrl(url)
self.access_manager.get(request)
def make_request(cities):
url_text = url_header + "&address=" + cities[
self.geo_city_index] + "&key=" + self.key
if self.geo_city_index == len(cities) - 1:
self.addicional_args.append([True])
else:
self.addicional_args.append([False])
url = QUrl(url_text)
nr = QNetworkRequest()
nr.setUrl(url)
self.redirect_fun = self._geocoding
self._busy = True
self.get_request(nr)
self.geo_city_index += 1
if self.geo_city_index == len(cities):
self.timer.stop()
def request_obj(self, url, headers=None, body=None):
""" Return a QNetworkRequest object """
request = QNetworkRequest()
request.setUrl(to_qurl(url))
request.setOriginatingObject(self.web_page.mainFrame())
if headers is not None:
self.web_page.skip_custom_headers = True
self._set_request_headers(request, headers)
if body and not request.hasRawHeader(b"content-type"):
# there is POST body but no content-type
# QT will set this header, but it will complain so better to do this here
request.setRawHeader(b"content-type", b"application/x-www-form-urlencoded")
return request
def run(self):
req = QNetworkRequest()
req.setUrl(QUrl(f'{self.base_url}/data/styles'))
res = QgsNetworkAccessManager.blockingGet(req, forceRefresh=True)
if self.isCanceled():
return False
self.setProgress(50)
_, tmp_file_name = tempfile.mkstemp(suffix='.zip')
with open(tmp_file_name, 'w+b') as fp:
fp.write(res.content().data())
with zipfile.ZipFile(tmp_file_name, 'r') as zip_ref:
zip_ref.extractall(self.target_dir)
os.remove(tmp_file_name)
if self.isCanceled():
return False
styles_dir = os.path.join(self.target_dir, 'styles')
for file_name in os.listdir(styles_dir):
layer_name = os.path.splitext(file_name)[0]
self.style_files[layer_name] = os.path.join(styles_dir, file_name)
os.makedirs(self.svg_dir, exist_ok=True)
symbols_dir = os.path.join(self.target_dir, 'symbols')
for symbol_file_name in os.listdir(symbols_dir):
shutil.copy(os.path.join(symbols_dir, symbol_file_name),
self.svg_dir)
with open(os.path.join(self.target_dir, 'layers.json'),
'r') as layer_order_file:
data = json.loads(layer_order_file.read())
self.layer_order = data
if self.isCanceled():
return False
self.setProgress(100)
return True
def request_obj(self, url, headers=None, body=None):
""" Return a QNetworkRequest object """
request = QNetworkRequest()
request.setUrl(to_qurl(url))
request.setOriginatingObject(self.web_page.mainFrame())
if headers is not None:
self.web_page.skip_custom_headers = True
self._set_request_headers(request, headers)
if body and not request.hasRawHeader(b"content-type"):
# there is POST body but no content-type
# QT will set this header, but it will complain so better to do this here
request.setRawHeader(b"content-type",
b"application/x-www-form-urlencoded")
return request
def create_client(self):
# print(home)
self.web = QWebView()
req = QNetworkRequest()
req.setUrl(QUrl(self.boot_url))
# arr = QByteArray()
# arr.append(bytes(self.boot_args,encoding="utf-8"))
self.web.load(req, QNetworkAccessManager.Operation,
QByteArray(str(self.boot_args)))
# self.web.load(QUrl('http://127.0.0.1:8080/snspro/shareFileController.do?boot_home'))
# self.web.setHtml(home)
self.web.settings().setAttribute(
QWebSettings.LocalContentCanAccessRemoteUrls, True)
# self.center()
# self.web.show()
self.web.closeEvent = self.closeEvent
def download(self):
grab = QPoint(0, 0)
for x in range(self.m_tilesRect.width() + 1):
for y in range(self.m_tilesRect.height() + 1):
tp = self.m_tilesRect.topLeft() + QPoint(x, y)
if QPointH(tp) not in self.m_tilePixmaps:
grab = tp
break
if grab == QPoint(0, 0):
self.m_url = QUrl()
return
path = "http://tile.openstreetmap.org/%d/%d/%d.png"
self.m_url = QUrl(path % (self.zoom, grab.x(), grab.y()))
request = QNetworkRequest()
request.setUrl(self.m_url)
request.setRawHeader(b"User-Agent", b"The Qt Company (Qt) Graphics Dojo 1.0")
request.setAttribute(QNetworkRequest.User, grab)
self.m_manager.get(request)
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 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 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 getImage(self, networkAccessManager):
if not self.image_data.isNull():
log.debug("Image data for %s is null...", self)
return self.image_data
if "multiverseid" not in self._data.keys():
log.warn("%s does not have a multiverseid, cannot download image.", self)
return self.image_data
request = QNetworkRequest()
log.debug("Checking image cache for %s.png", self.multiverse_id)
cardURI = self.cachedImageURI.path()[1:] #fix for windows file system
if os.path.exists(cardURI):
log.debug("Found %s", cardURI)
request.setUrl(self.cachedImageURI)
else:
log.debug("Downloading image %s", self.imageURL.toString())
request.setUrl(self.imageURL)
reply = networkAccessManager.get(request)
reply.setAttribute(QNetworkRequest.User, self)
return reply
from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply, QSslConfiguration, QSsl from PyQt5.QtCore import QUrl class ForRec(QNetworkAccessManager): def Reqest(self,reply): print(reply.readAll()) if __name__ == '__main__': url = "https://api.telegram.org/bot" manager = QNetworkAccessManager() request = QNetworkRequest() config = QSslConfiguration.defaultConfiguration() config.setProtocol(QSsl.SecureProtocols) request.setSslConfiguration(config) request.setUrl(QUrl(url)); request.setHeader(QNetworkRequest.ServerHeader, "getUpdates") #manager.get(request)
class FlashingDialog(QDialog):
def __init__(self, parent):
super().__init__()
self.setWindowTitle("Tasmotizing...")
esptool.sw.read_start.connect(self.read_start)
esptool.sw.read_progress.connect(self.read_progress)
esptool.sw.read_finished.connect(self.read_finished)
esptool.sw.erase_start.connect(self.erase_start)
esptool.sw.erase_finished.connect(self.erase_finished)
esptool.sw.write_start.connect(self.write_start)
esptool.sw.write_progress.connect(self.write_progress)
esptool.sw.write_finished.connect(self.write_finished)
self.setFixedWidth(400)
self.nrBinFile = QNetworkRequest()
self.parent = parent
vl = VLayout(10, 10)
self.setLayout(vl)
self.bin_data = b""
self.error_msg = None
self.progress_task = QProgressBar()
self.progress_task.setFixedHeight(45)
self.task = QLabel()
self.erase_timer = QTimer()
self.erase_timer.setSingleShot(False)
self.erase_timer.timeout.connect(self.erase_progress)
self.btns = QDialogButtonBox(QDialogButtonBox.Abort)
vl.addWidgets([
QLabel("Tasmotizing in progress..."), self.task,
self.progress_task, self.btns
])
self.btns.rejected.connect(self.abort)
# process starts
if parent.mode in (1, 2):
self.bin_file = parent.cbHackboxBin.currentData().split(";")[1]
self.nrBinFile.setUrl(
QUrl(parent.cbHackboxBin.currentData().split(";")[0]))
self.bin_reply = parent.nam.get(self.nrBinFile)
self.task.setText("Downloading binary from thehackbox.org...")
self.bin_reply.readyRead.connect(self.appendBinFile)
self.bin_reply.downloadProgress.connect(self.updateBinProgress)
self.bin_reply.finished.connect(self.saveBinFile)
else:
self.bin_file = parent.bin_file
self.run_esptool()
def appendBinFile(self):
self.bin_data += self.bin_reply.readAll()
def saveBinFile(self):
if self.bin_reply.error() == QNetworkReply.NoError:
with open(self.bin_file, "wb") as f:
f.write(self.bin_data)
self.progress_task.setValue(0)
self.task.setText("Connecting to ESP...")
self.run_esptool()
else:
QMessageBox.critical(self, "Network error",
self.bin_reply.errorString())
def updateBinProgress(self, recv, total):
self.progress_task.setValue(recv // total * 100)
def read_start(self):
self.progress_task.setValue(0)
self.task.setText("Saving image backup...")
def read_progress(self, value):
self.progress_task.setValue(value)
def read_finished(self):
self.progress_task.setValue(100)
self.task.setText("Writing done.")
def erase_start(self):
self.btns.setEnabled(False)
self.progress_task.setValue(0)
self.task.setText("Erasing flash... (this may take a while)")
self.erase_timer.start(1000)
def erase_progress(self):
self.progress_task.setValue(self.progress_task.value() + 5)
def erase_finished(self):
self.progress_task.setValue(100)
self.task.setText("Erasing done.")
self.erase_timer.stop()
self.btns.setEnabled(True)
def write_start(self):
self.progress_task.setValue(0)
self.task.setText("Writing image...")
def write_progress(self, value):
self.progress_task.setValue(value)
def write_finished(self):
self.progress_task.setValue(100)
self.task.setText("Writing done.")
self.accept()
def run_esptool(self):
self.espthread = QThread()
self.espworker = ESPWorker(self.parent.cbxPort.currentData(),
self.bin_file,
self.parent.cbBackup.isChecked(),
self.parent.cbErase.isChecked())
self.espworker.port_error.connect(self.error)
self.espworker.moveToThread(self.espthread)
self.espthread.started.connect(self.espworker.execute)
self.espthread.start()
def abort(self):
self.espworker.stop()
self.espthread.quit()
self.espthread.wait(2000)
self.reject()
def error(self, e):
self.error_msg = e
self.reject()
def accept(self):
self.espworker.stop()
self.espthread.quit()
self.espthread.wait(2000)
self.done(QDialog.Accepted)
def _make_request(self, url):
request = QNetworkRequest()
request.setUrl(QUrl(url))
return request
def request(self,
url,
method="GET",
body=None,
headers=None,
redirections=DEFAULT_MAX_REDIRECTS,
connection_type=None,
blocking=True):
"""
Make a network request by calling QgsNetworkAccessManager.
redirections argument is ignored and is here only for httplib2 compatibility.
"""
self.http_call_result.url = url
self.msg_log(u'http_call request: {0}'.format(url))
self.blocking_mode = blocking
req = QNetworkRequest()
# Avoid double quoting form QUrl
url = urllib.parse.unquote(url)
req.setUrl(QUrl(url))
if headers is not None:
# This fixes a weird error with compressed content not being correctly
# inflated.
# If you set the header on the QNetworkRequest you are basically telling
# QNetworkAccessManager "I know what I'm doing, please don't do any content
# encoding processing".
# See: https://bugs.webkit.org/show_bug.cgi?id=63696#c1
try:
del headers['Accept-Encoding']
except KeyError:
pass
for k, v in list(headers.items()):
self.msg_log("Setting header %s to %s" % (k, v))
req.setRawHeader(k, v)
if self.authid:
self.msg_log("Update request w/ authid: {0}".format(self.authid))
QgsAuthManager.instance().updateNetworkRequest(req, self.authid)
if self.reply is not None and self.reply.isRunning():
self.reply.close()
if method.lower() == 'delete':
func = getattr(QgsNetworkAccessManager.instance(),
'deleteResource')
else:
func = getattr(QgsNetworkAccessManager.instance(), method.lower())
# Calling the server ...
# Let's log the whole call for debugging purposes:
self.msg_log("Sending %s request to %s" %
(method.upper(), req.url().toString()))
self.on_abort = False
headers = {str(h): str(req.rawHeader(h)) for h in req.rawHeaderList()}
for k, v in list(headers.items()):
self.msg_log("%s: %s" % (k, v))
if method.lower() in ['post', 'put']:
if isinstance(body, file):
body = body.read()
self.reply = func(req, body)
else:
self.reply = func(req)
if self.authid:
self.msg_log("Update reply w/ authid: {0}".format(self.authid))
QgsAuthManager.instance().updateNetworkReply(
self.reply, self.authid)
# necessary to trap local timeout manage by QgsNetworkAccessManager
# calling QgsNetworkAccessManager::abortRequest
QgsNetworkAccessManager.instance().requestTimedOut.connect(
self.requestTimedOut)
self.reply.sslErrors.connect(self.sslErrors)
self.reply.finished.connect(self.replyFinished)
self.reply.downloadProgress.connect(self.downloadProgress)
# block if blocking mode otherwise return immediately
# it's up to the caller to manage listeners in case of no blocking mode
if not self.blocking_mode:
return None, None
# Call and block
self.el = QEventLoop()
self.reply.finished.connect(self.el.quit)
# Catch all exceptions (and clean up requests)
try:
self.el.exec_(QEventLoop.ExcludeUserInputEvents)
except Exception as e:
raise e
if self.reply:
self.reply.finished.disconnect(self.el.quit)
# emit exception in case of error
if not self.http_call_result.ok:
if self.http_call_result.exception and not self.exception_class:
raise self.http_call_result.exception
elif self.exception_class:
raise self.exception_class(self.http_call_result.reason)
else:
raise RequestsException('Unknown reason')
return self.http_call_result, self.http_call_result.content
class ProcessDialog(QDialog):
def __init__(self, port, **kwargs):
super().__init__()
self.setWindowTitle('Cooking your TinyGS station...')
self.setFixedWidth(400)
self.exception = None
esptool.sw.progress.connect(self.update_progress)
self.nam = QNetworkAccessManager()
self.nrBinFile = QNetworkRequest()
self.bin_data = b''
self.setLayout(VLayout(5, 5))
self.actions_layout = QFormLayout()
self.actions_layout.setSpacing(5)
self.layout().addLayout(self.actions_layout)
self._actions = []
self._action_widgets = {}
self.port = port
self.auto_reset = kwargs.get('auto_reset', False)
self.file_path = kwargs.get('file_path')
if self.file_path and self.file_path.startswith('http'):
self._actions.append('download')
self.backup = kwargs.get('backup')
if self.backup:
self._actions.append('backup')
self.backup_size = kwargs.get('backup_size')
self.erase = kwargs.get('erase')
if self.erase:
self._actions.append('erase')
if self.file_path:
self._actions.append('write')
self.create_ui()
self.start_process()
def create_ui(self):
for action in self._actions:
pb = QProgressBar()
pb.setFixedHeight(35)
self._action_widgets[action] = pb
self.actions_layout.addRow(action.capitalize(), pb)
self.btns = QDialogButtonBox(QDialogButtonBox.Abort)
self.btns.rejected.connect(self.abort)
self.layout().addWidget(self.btns)
self.sb = QStatusBar()
self.layout().addWidget(self.sb)
def appendBinFile(self):
self.bin_data += self.bin_reply.readAll()
def saveBinFile(self):
if self.bin_reply.error() == QNetworkReply.NoError:
self.file_path = self.file_path.split('/')[-1]
with open(self.file_path, 'wb') as f:
f.write(self.bin_data)
self.run_esp()
else:
raise NetworkError
def updateBinProgress(self, recv, total):
self._action_widgets['download'].setValue(recv // total * 100)
def download_bin(self):
self.nrBinFile.setAttribute(QNetworkRequest.FollowRedirectsAttribute,
True)
self.nrBinFile.setUrl(QUrl(self.file_path))
self.bin_reply = self.nam.get(self.nrBinFile)
self.bin_reply.readyRead.connect(self.appendBinFile)
self.bin_reply.downloadProgress.connect(self.updateBinProgress)
self.bin_reply.finished.connect(self.saveBinFile)
def show_connection_state(self, state):
self.sb.showMessage(state, 0)
def run_esp(self):
params = {
'file_path': self.file_path,
'auto_reset': self.auto_reset,
'erase': self.erase
}
if self.backup:
backup_size = f'0x{2 ** self.backup_size}00000'
params['backup_size'] = backup_size
self.esp_thread = QThread()
self.esp = ESPWorker(self.port, self._actions, **params)
esptool.sw.connection_state.connect(self.show_connection_state)
self.esp.waiting.connect(self.wait_for_user)
self.esp.done.connect(self.accept)
self.esp.error.connect(self.error)
self.esp.moveToThread(self.esp_thread)
self.esp_thread.started.connect(self.esp.run)
self.esp_thread.start()
def start_process(self):
if 'download' in self._actions:
self.download_bin()
self._actions = self._actions[1:]
else:
self.run_esp()
def update_progress(self, action, value):
self._action_widgets[action].setValue(value)
@pyqtSlot()
def wait_for_user(self):
dlg = QMessageBox.information(
self, 'User action required',
'Please power cycle the device, wait a moment and press OK',
QMessageBox.Ok | QMessageBox.Cancel)
if dlg == QMessageBox.Ok:
self.esp.continue_ok()
elif dlg == QMessageBox.Cancel:
self.esp.abort()
self.esp.continue_ok()
self.abort()
def stop_thread(self):
self.esp_thread.wait(2000)
self.esp_thread.exit()
def accept(self):
self.stop_thread()
self.done(QDialog.Accepted)
def abort(self):
self.sb.showMessage('Aborting...', 0)
QApplication.processEvents()
self.esp.abort()
self.stop_thread()
self.reject()
def error(self, e):
self.exception = e
self.abort()
def closeEvent(self, e):
self.stop_thread()
class E5XmlRpcClient(QObject):
"""
Class implementing a xmlrpc client for Qt.
"""
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 setUrl(self, url):
"""
Public slot to set the xmlrpc handler URL.
@param url xmlrpc handler URL (string or QUrl)
"""
url = QUrl(url)
if url.isValid():
self.__request.setUrl(url)
def call(self, method, args, responseCallback, errorCallback):
"""
Public method to call the remote server.
@param method name of the remote method to be called (string)
@param args tuple of method arguments (tuple)
@param responseCallback method to be called with the returned
result as a tuple (function)
@param errorCallback method to be called in case of an error
with error code and error string (function)
"""
assert isinstance(args, tuple), \
"argument must be tuple or Fault instance"
data = xmlrpc.dumps(args, method).encode("utf-8")
reply = self.__networkManager.post(
self.__request, QByteArray(data))
self.__callmap[reply] = (responseCallback, errorCallback)
def abort(self):
"""
Public method to abort all calls.
"""
for reply in list(self.__callmap):
if reply.isRunning():
reply.abort()
def __sslErrors(self, reply, errors):
"""
Private slot to handle SSL errors.
@param reply reference to the reply object (QNetworkReply)
@param errors list of SSL errors (list of QSslError)
"""
ignored = self.__sslErrorHandler.sslErrorsReply(reply, errors)[0]
if ignored == E5SslErrorHandler.NotIgnored and reply in self.__callmap:
self.__callmap[reply][1](xmlrpc.TRANSPORT_ERROR, self.tr(
"SSL Error"))
def __replyFinished(self, reply):
"""
Private slot handling the receipt of a reply.
@param reply reference to the finished reply (QNetworkReply)
"""
if reply not in self.__callmap:
return
if reply.error() != QNetworkReply.NoError:
self.__callmap[reply][1](xmlrpc.TRANSPORT_ERROR,
reply.errorString())
else:
data = bytes(reply.readAll()).decode("utf-8")
try:
data = xmlrpc.loads(data)[0]
self.__callmap[reply][0](data)
except xmlrpc.Fault as fault:
self.__callmap[reply][1](fault.faultCode, fault.faultString)
reply.deleteLater()
del self.__callmap[reply]
class E5XmlRpcClient(QObject):
"""
Class implementing a xmlrpc client for Qt.
"""
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 setUrl(self, url):
"""
Public slot to set the xmlrpc handler URL.
@param url xmlrpc handler URL (string or QUrl)
"""
url = QUrl(url)
if url.isValid():
self.__request.setUrl(url)
def call(self, method, args, responseCallback, errorCallback):
"""
Public method to call the remote server.
@param method name of the remote method to be called (string)
@param args tuple of method arguments (tuple)
@param responseCallback method to be called with the returned
result as a tuple (function)
@param errorCallback method to be called in case of an error
with error code and error string (function)
"""
assert isinstance(args, tuple), \
"argument must be tuple or Fault instance"
data = xmlrpc.dumps(args, method).encode("utf-8")
reply = self.__networkManager.post(
self.__request, QByteArray(data))
self.__callmap[reply] = (responseCallback, errorCallback)
def abort(self):
"""
Public method to abort all calls.
"""
for reply in list(self.__callmap):
if reply.isRunning():
reply.abort()
def __sslErrors(self, reply, errors):
"""
Private slot to handle SSL errors.
@param reply reference to the reply object (QNetworkReply)
@param errors list of SSL errors (list of QSslError)
"""
ignored = self.__sslErrorHandler.sslErrorsReply(reply, errors)[0]
if ignored == E5SslErrorHandler.NotIgnored and reply in self.__callmap:
self.__callmap[reply][1](xmlrpc.TRANSPORT_ERROR, self.tr(
"SSL Error"))
def __replyFinished(self, reply):
"""
Private slot handling the receipt of a reply.
@param reply reference to the finished reply (QNetworkReply)
"""
if reply not in self.__callmap:
return
if reply.error() != QNetworkReply.NoError:
self.__callmap[reply][1](xmlrpc.TRANSPORT_ERROR,
reply.errorString())
else:
data = bytes(reply.readAll()).decode("utf-8")
try:
data = xmlrpc.loads(data)[0]
self.__callmap[reply][0](data)
except xmlrpc.Fault as fault:
self.__callmap[reply][1](fault.faultCode, fault.faultString)
reply.deleteLater()
del self.__callmap[reply]
class SearchThread(QThread):
domain = 'kyfw.12306.cn' #请求域名（真实连接地址）
host='kyfw.12306.cn' #请求的域名（host）
http = requests.session()
stopSignal=False
threadId=1
leftTicketUrl="leftTicket/query"
requests.packages.urllib3.disable_warnings()
searchThreadCallback= pyqtSignal(list)
def __init__(self,from_station,to_station,train_date,threadId,leftTicketUrl,interval=2,domain=''):
super(SearchThread,self).__init__()
if domain!='':
self.domain=domain
self.threadId=threadId
self.from_station=from_station
self.to_station=to_station
self.train_date=train_date
self.interval=interval
self.leftTicketUrl=leftTicketUrl
def run(self):
time.sleep(self.threadId)
userAgent="Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2062.120 Safari/537.36"
headers={'Referer':'https://kyfw.12306.cn/otn/leftTicket/init',"host":self.host\
,'Cache-Control':'no-cache','Pragma':"no-cache","User-Agent":userAgent,"X-Requested-With":"XMLHttpRequest"}
t=str(random.random())
dataUrl='?leftTicketDTO.train_date='+self.train_date\
+"&leftTicketDTO.from_station="+self.stationCode[self.from_station]+"&leftTicketDTO.to_station="+\
self.stationCode[self.to_station]+"&purpose_codes=ADULT"
logUrl='https://' + self.domain + '/otn/leftTicket/log'+dataUrl
url='https://' + self.domain + '/otn/'+self.leftTicketUrl+dataUrl
self.http.get(logUrl,verify=False,headers=headers)
jc_fromStation=xxtea.unicodeStr(self.from_station+","+self.stationCode[self.from_station])
jc_toStation=xxtea.unicodeStr(self.to_station+","+self.stationCode[self.to_station])
self.http.cookies.set("_jc_save_fromStation",jc_fromStation)
self.http.cookies.set("_jc_save_toStation",jc_toStation)
self.http.cookies.set('_jc_save_fromDate',self.train_date)
self.http.cookies.set('_jc_save_toDate',"2014-01-01")
self.http.cookies.set('_jc_save_wfdc_flag','dc')
ret=self.http.get(url,verify=False,headers=headers)
ticketInfo=ret.json()
if ticketInfo['status']!=True :
print(ticketInfo)
cookies=self.http.cookies.get_dict()
cookieStr=";".join('%s=%s' % (key, value) for (key, value) in cookies.items())
self.http.get(logUrl,verify=False,headers=headers)
self.req=QNetworkRequest()
self.req.setUrl(QUrl(url))
self.req.setRawHeader("Referer","https://kyfw.12306.cn/otn/leftTicket/init")
self.req.setRawHeader("host",self.host)
self.req.setRawHeader("Cache-Control","no-cache")
self.req.setRawHeader("Pragma","no-cache")
self.req.setRawHeader("User-Agent",userAgent)
self.req.setRawHeader("Cookie",cookieStr)
while not self.stopSignal:
mutex.acquire(1)
self.search_ticket(self.from_station,self.to_station,self.train_date)
mutex.release(1)
time.sleep(self.interval)
def search_ticket(self, fromStation, toStation, date):
try:
self.netWorkManager=QNetworkAccessManager()
self.reply=self.netWorkManager.get(self.req)
self.reply.ignoreSslErrors()
self.reply.finished.connect(self.search_finished)
self.exec()
except Exception as e:
print("ip:"+self.domain+"查询发生错误："+e.__str__())
return False
def search_finished(self):
try:
ret=self.reply.readAll()
ret=str(ret,'utf8')
ticketInfo=json.loads(ret)
self.reply=None
self.netWorkManager=None
self.exit()
if ticketInfo['status']!=True or ticketInfo['messages']!=[] :
print(self.domain)
print(ticketInfo)
return False
if len(ticketInfo['data'])<=0:
return False
data=ticketInfo['data']
ret=None
ticketInfo=None
self.searchThreadCallback.emit(data)
except Exception as e:
print(e.__str__())
def load_station_code(self,stationCode):
self.stationCode = stationCode
return True
def stop(self):
self.stopSignal=True
def _injectApiToken(request: QNetworkRequest) -> None:
current_url = request.url().toString()
operator = "&" if current_url.find("?") > 0 else "?"
new_url = QUrl("{}{}key={}".format(current_url, operator,
Settings.MYMINIFACTORY_API_TOKEN))
request.setUrl(new_url)
class HttpClient(QObject):
sig_ended = pyqtSignal(bool)
def __init__(self):
super().__init__()
self.network_manager = QNetworkAccessManager()
self.request = QNetworkRequest()
self.request.setRawHeader(b"accept", b"application/json")
self.request.setRawHeader(
b'user-agent',
b'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_4) AppleWebKit/537.36 (KHTML, '
b'like Gecko) Chrome/66.0.3359.139 Safari/537.36')
self._ended = True
self._reply = None
self._text = b''
self._string = ''
self._status_code = None
self._json = None
self._headers = None
self._connect_to_slot()
def reply(self):
return self._reply
def json(self):
return self._json
def status(self):
return self._status_code
def text(self):
return self._string
def headers(self):
return self._headers
def content_type(self):
content_type = self._headers['content-type']
if 'text/html' in content_type:
return 'html'
elif 'test/plain' in content_type:
return 'text'
elif 'application/json' in content_type:
return 'json'
def _save_header(self, raw_headers):
h = {}
for t in raw_headers:
h.update({str.lower(bytes(t[0]).decode()): bytes(t[1]).decode()})
self._headers = h
def set_header(self, header):
"""
header must consist of strings of dict
:param header: dict
"""
if isinstance(header, dict):
for k in header:
self.request.setRawHeader(k.encode(), header[k].encode())
def get(self, url: str, header=None):
"""
Get http request
:param url:
:param header:
"""
self.request.setUrl(QUrl(url))
self.set_header(header)
self.network_manager.get(self.request)
def post(self, url: str, header: list(tuple()) = None, data: bytes = None):
self.request.setUrl(QUrl(url))
self.set_header(header)
self.network_manager.post(self.request, data)
def put(self, url: str, header: list(tuple()) = None, data: bytes = None):
self.request.setUrl(QUrl(url))
self.set_header(header)
self.network_manager.put(self.request, data)
def delete(self, url: str, header: list(tuple()) = None):
self.request.setUrl(QUrl(url))
self.set_header(header)
self.network_manager.deleteResource(self.request)
def _connect_to_slot(self):
self.network_manager.finished.connect(self.slot_reply_finished)
def slot_reply_finished(self, data: QNetworkReply):
self._reply = data
self._text = data.readAll()
self._string = bytes(self._text).decode()
self._status_code = data.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
self._save_header(data.rawHeaderPairs())
if self.content_type() == 'json':
if len(self._string):
self._json = json.loads(self._string)
else:
self._json = None
if self._status_code >= 400:
print(self._string)
self.sig_ended.emit(True)
data.deleteLater()
def _make_request(self, url):
request = QNetworkRequest()
request.setUrl(QUrl(url))
return request
def execute_request(self, url, **kwargs):
"""
Uses QgsNetworkAccessManager and QgsAuthManager.
"""
method = kwargs.get('http_method', 'get')
headers = kwargs.get('headers', {})
# This fixes a weird error with compressed content not being correctly
# inflated.
# If you set the header on the QNetworkRequest you are basically telling
# QNetworkAccessManager "I know what I'm doing, please don't do any content
# encoding processing".
# See: https://bugs.webkit.org/show_bug.cgi?id=63696#c1
try:
del headers[b'Accept-Encoding']
except KeyError as ke:
# only debugging here as after 1st remove it isn't there anymore
self.util.msg_log_debug(
u'unexpected error deleting request header: {}'.format(ke))
pass
# Avoid double quoting form QUrl
url = unquote(url)
self.util.msg_log_debug(u'http_call request: {} {}'.format(
method, url))
class Response:
status_code = 200
status_message = 'OK'
text = ''
ok = True
headers = {}
reason = ''
exception = None
def iter_content(self, _):
return [self.text]
self.http_call_result = Response()
url = self.util.remove_newline(url)
req = QNetworkRequest()
req.setUrl(QUrl(url))
req.setAttribute(QNetworkRequest.FollowRedirectsAttribute, True)
for k, v in headers.items():
self.util.msg_log_debug("%s: %s" % (k, v))
try:
req.setRawHeader(k, v)
except:
self.util.msg_log_error(
u'FAILED to set header: {} => {}'.format(k, v))
self.util.msg_log_last_exception()
if self.settings.authcfg:
self.util.msg_log_debug(u'before updateNetworkRequest')
QgsApplication.authManager().updateNetworkRequest(
req, self.settings.authcfg)
self.util.msg_log_debug(u'before updateNetworkRequest')
if self.reply is not None and self.reply.isRunning():
self.reply.close()
self.util.msg_log_debug(u'getting QgsNetworkAccessManager.instance()')
#func = getattr(QgsNetworkAccessManager.instance(), method)
#func = QgsNetworkAccessManager().get(req)
#manager = QNetworkAccessManager()
#event = QEventLoop()
#response = manager.get(QNetworkRequest(QUrl(url)))
#response.downloadProgress.connect(self.download_progress)
#response.finished.connect(event.quit)
#event.exec()
#response_msg = response.readAll()
##response_msg = str(response_msg)
#response_msg = str(response_msg, encoding='utf-8')
##response_msg = response_msg.decode('utf-8')
#response.deleteLater()
#self.util.msg_log_debug(u'response message:\n{} ...'.format(response_msg[:255]))
#self.http_call_result.text = response_msg # in Python3 all strings are unicode, so QString is not defined
#return self.http_call_result
# Calling the server ...
self.util.msg_log_debug('before self.reply = func(req)')
#self.reply = func(req)
#self.reply = QgsNetworkAccessManager.instance().get(req)
method_call = getattr(QgsNetworkAccessManager.instance(), method)
self.reply = method_call(req)
#self.reply.setReadBufferSize(1024*1024*1024)
#self.reply.setReadBufferSize(1024 * 1024 * 1024 * 1024)
self.reply.setReadBufferSize(0)
self.util.msg_log_debug('after self.reply = func(req)')
# Let's log the whole call for debugging purposes:
if self.settings.debug:
self.util.msg_log_debug("\nSending %s request to %s" %
(method.upper(), req.url().toString()))
headers = {
str(h): str(req.rawHeader(h))
for h in req.rawHeaderList()
}
for k, v in headers.items():
try:
self.util.msg_log_debug("%s: %s" % (k, v))
except:
self.util.msg_log_debug('error logging headers')
if self.settings.authcfg:
self.util.msg_log_debug("update reply w/ authcfg: {0}".format(
self.settings.authcfg))
QgsApplication.authManager().updateNetworkReply(
self.reply, self.settings.authcfg)
self.util.msg_log_debug('before connecting to events')
# connect downloadProgress event
try:
self.reply.downloadProgress.connect(self.download_progress)
#pass
except:
self.util.msg_log_error(
'error connecting "downloadProgress" event')
self.util.msg_log_last_exception()
# connect reply finished event
try:
self.reply.finished.connect(self.reply_finished)
#pass
except:
self.util.msg_log_error(
'error connecting reply "finished" progress event')
self.util.msg_log_last_exception()
self.util.msg_log_debug('after connecting to events')
# Call and block
self.event_loop = QEventLoop()
try:
self.reply.finished.connect(self.event_loop.quit)
except:
self.util.msg_log_error(
'error connecting reply "finished" progress event to event loop quit'
)
self.util.msg_log_last_exception()
self.mb_downloaded = 0
# Catch all exceptions (and clean up requests)
self.event_loop.exec()
# Let's log the whole response for debugging purposes:
if self.settings.debug:
self.util.msg_log_debug(
u'\nGot response [{}/{}] ({} bytes) from:\n{}\nexception:{}'.
format(self.http_call_result.status_code,
self.http_call_result.status_message,
len(self.http_call_result.text),
self.reply.url().toString(),
self.http_call_result.exception))
headers = {
str(h): str(self.reply.rawHeader(h))
for h in self.reply.rawHeaderList()
}
for k, v in headers.items():
self.util.msg_log_debug("%s: %s" % (k, v))
self.util.msg_log_debug("Payload :\n%s ......" %
self.http_call_result.text[:255])
self.reply.close()
self.util.msg_log_debug("Deleting reply ...")
try:
self.reply.deleteLater()
except:
self.util.msg_log_error('unexpected error deleting QNetworkReply')
self.util.msg_log_last_exception()
self.reply = None
if self.http_call_result.exception is not None:
self.util.msg_log_error('http_call_result.exception is not None')
self.http_call_result.ok = False
# raise self.http_call_result.exception
return self.http_call_result
def request(self,
op: str,
url: typing.Union[QtCore.QUrl, str],
*,
params: typing.Dict[str, str] = None,
headers: typing.Dict[typing.AnyStr, typing.AnyStr] = None,
data: typing.Union[str, bytes, QtCore.QBuffer] = None,
request: QtNetwork.QNetworkRequest = None):
"""Issues a new request.
This method was designed to mimic standard synchronous libraries on PyPi,
but on the Qt5 event loop.
If request is passed, `url`, `params`, and `headers` will be ignored."""
# Request object validation
if request is not None:
return self._request(op.upper(), request, data=data)
else:
request = QtNetwork.QNetworkRequest()
# Url conversion
if isinstance(url, str):
url = QtCore.QUrl(url)
# Url assignment
request.setUrl(url)
# Parameter stitching
if params is not None:
# Declaration and assignment
q = QtCore.QUrlQuery()
url.setQuery(q)
# Populate the QUrlQuery
for k, v in params.items():
q.addQueryItem(k, v)
# Header stitching
if headers is not None:
for k, v in headers.items():
# Declarations
key, value = None, None
# Item validation
if not isinstance(k, bytes):
key = k.encode(encoding='UTF-8')
if not isinstance(v, bytes):
value = v.encode(encoding='UTF-8')
# Populate request header
request.setRawHeader(key, value)
if data is not None:
# Declarations
buffer: typing.Optional[QtCore.QBuffer] = None
# Buffer validation
if isinstance(data, QtCore.QBuffer):
buffer = data
else:
buffer = QtCore.QBuffer()
# Data validation
if isinstance(data, str):
buffer.setData(data.encode(encoding='UTF-8'))
elif isinstance(data, bytes):
buffer.setData(data)
else:
buffer = None
return self._request(op.upper(), request, data=buffer)
class Browser(QObject):
comment_postdata_example = {
'ft_ent_identifier': '735272899920440', # ИД сообщения
'comment_text': 'Cool))', # Текст коментария
'source': '22',
'client_id': '1429632677205%3A3425397009',
'reply_fbid': '',
'parent_comment_id': '',
'rootid': 'u_ps_0_0_k',
'clp': '',
'attached_sticker_fbid': '0',
'attached_photo_fbid': '0',
'feed_context': '%7B%22fbfeed_context%22%3Atrue%2C%22location_type%22%3A36%2C%22is_starred%22%3Afalse%2C%22is_pinned_post%22%3Afalse%2C%22can_moderate_timeline_story%22%3Afalse%2C%22profile_id%22%3A308106089303792%2C%22outer_object_element_id%22%3A%22u_ps_0_0_0%22%2C%22object_element_id%22%3A%22u_ps_0_0_0%22%2C%22is_ad_preview%22%3Afalse%2C%22is_editable%22%3Afalse%7D',
'ft[tn]': '[]',
'ft[top_level_post_id]': '750869418360788',
'ft[fbfeed_location]': '36',
'nctr[_mod]': 'pagelet_timeline_main_column',
'av': '100009110845526',
'__user': '******',
'__a': '1',
'__dyn': '', #пустой
'__req': 'c',
'fb_dtsg': 'AQEkxiOYhtrJ', # инпут в теле документа
'ttstamp': '26581716611911872109105876676',
'__rev': '1713404',
}
def __init__(self, parent):
super().__init__(parent)
self.set_url('http://google.ru')
conn = QNetworkAccessManager()
self.conn = conn
self.r = QNetworkRequest()
self.r.attribute(QNetworkRequest.CookieSaveControlAttribute, QVariant(True))
# self.r.setHeader(QNetworkRequest.ContentTypeHeader, "application/x-www-form-urlencoded")
# self.r.setRawHeader("Referer", "http://www.facebook.com/")
# self.r.setRawHeader("Host", "www.facebook.com")
self.cj = QNetworkCookieJar()
conn.setCookieJar(self.cj)
conn.createRequest = self._create_request
self.wv = WebView()
self.wv.show()
self.wv.page().setNetworkAccessManager(conn)
# self.wv.auth()
self.loop = QEventLoop()
pass
def _create_request(self, operation, request, data):
# print(data)
reply = QNetworkAccessManager.createRequest(self.conn,
operation,
request,
data)
self.conn.new_reply = reply
self.wv_reply = reply
return reply
def set_url(self, url):
if isinstance(url, QByteArray):
self.url = QUrl().fromEncoded(url)
else:
self.url = QUrl(url)
def send_request(self, post=None, data={}):
loop = QEventLoop()
self.r.setUrl(self.url)
if post:
encoded_data = self._urlencode_post_data(data)
pprint(encoded_data)
self.reply_post = self.conn.post(self.r, encoded_data)
self.reply_post.downloadProgress.connect(self.prepare_responce)
else:
self.reply = self.conn.get(self.r)
self.reply.finished.connect(self.prepare_responce)
# return \
loop.exec()
def prepare_responce(self):
# self.check_redirect()
self.responce = self.reply_post.readAll()#.data().decode('utf-8')
pprint(self.responce)
sys.exit()
def check_redirect(self):
print(self.url)
a = self.reply.rawHeader('Location')
if len(a) > 0:
self.set_url(a)
self.send_request()
else:
self.loop.exit()
def test(self):
self.wv.auth('https://www.facebook.com/freelanceuidesignerdeveloper')
self.wv.authentication.connect(self.webview_login)
def _urlencode_post_data(self, post_data):
post_params = []
for (key, value) in post_data.items():
print(key, value)
post_params.append(key+'='+value)
return '&'.join(post_params)
def webview_login(self):
text_page = self.wv.page().mainFrame().toHtml()
data = {
'ft_ent_identifier': '735272899920440',
'comment_text': 'amazing',
'source': '22',
'client_id': '1429632677205%3A3425397009',
'reply_fbid': '',
'parent_comment_id': '',
'rootid': 'u_ps_0_0_o',
'clp': '',
'attached_sticker_fbid': '0',
'attached_photo_fbid': '0',
'feed_context': '%7B%22fbfeed_context%22%3Atrue%2C%22location_type%22%3A36%2C%22is_starred%22%3Afalse%2C%22is_pinned_post%22%3Afalse%2C%22can_moderate_timeline_story%22%3Afalse%2C%22profile_id%22%3A308106089303792%2C%22outer_object_element_id%22%3A%22u_ps_0_0_0%22%2C%22object_element_id%22%3A%22u_ps_0_0_0%22%2C%22is_ad_preview%22%3Afalse%2C%22is_editable%22%3Afalse%7D',
'ft[tn]': '[]',
'ft[top_level_post_id]': '',
'ft[fbfeed_location]': '36',
'nctr[_mod]': 'pagelet_timeline_main_column',
'av': '100009110845526',
'__user': '******',
'__a': '1',
'__dyn': '', #пустой
'__req': 'c',
'fb_dtsg': 'AQEkxiOYhtrJ', # инпут в теле документа
'ttstamp': '26581716611911872109105876676',
'__rev': '1713404',
}
dtsg_index = text_page.find('"token":"AQ')
data['fb_dtsg'] = text_page[dtsg_index+9:dtsg_index+21]
data['ttstamp'] = self.ttstamp_gen(data['fb_dtsg'])
data['ft_ent_identifier'] = '849713745045784' # self.get_post_id(post_object)
data['comment_text'] = random_number.choice(config.comments_list)
pprint(data['comment_text'])
# data['av'] = data['__user'] = from_user
# self.applyMetaData()
self.url = QUrl('https://www.facebook.com/ajax/ufi/add_comment.php')
self.send_request(True, data)
sys.exit()
def applyMetaData(self):
print('applyMetaData')
raw_header = {
'Host': 'www.facebook.com',
'User-Agent': ' Mozilla/5.0 (X11; Linux x86_64; rv:37.0) Gecko/20100101 Firefox/37.0',
'Accept': ' text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language': ' en-US,en;q=0.5',
'Content-Type': ' application/x-www-form-urlencoded; charset=UTF-8',
'Referer': ' https://www.facebook.com/SoftProposal?fref=nf',
}
for (key, header) in raw_header.items():
self.r.setRawHeader(key, header)
@staticmethod
def ttstamp_gen(fb_dtsg):
u = ''
for v in fb_dtsg:
u += str(ord(v))
return '2'+u
@staticmethod
def get_post_id(post):
if post.object_id:
return post.object_id
else:
str = post.id.split('_')
if len(str) > 1:
return str[0]
else:
post.id
class FLNetwork(QtCore.QObject):
url = None
request = None
manager = None
reply = None
finished = QtCore.pyqtSignal()
start = QtCore.pyqtSignal()
data = QtCore.pyqtSignal(str)
dataTransferProgress = QtCore.pyqtSignal(int, int)
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)
# self.data.connect(self._slotNetWorkData)
# self.dataTransferProgress.connect(self._slotNetworkProgress)
@decorators.BetaImplementation
def get(self, location):
self.request.setUrl(QtCore.QUrl("%s%s" % (self.url, location)))
self.reply = self.manager.get(self.request)
try:
self.reply.uploadProgress.disconnect(self._slotNetworkProgress)
self.reply.downloadProgress.disconnect(self._slotNetworkProgress)
except:
pass
self.reply.downloadProgress.connect(self._slotNetworkProgress)
@decorators.BetaImplementation
def put(self, data, location):
self.request.setUrl(QtCore.QUrl("%s%s" % (self.url, localtion)))
self.reply = self.manager.put(data, self.request)
try:
self.reply.uploadProgress.disconnect(self._slotNetworkProgress)
self.reply.downloadProgress.disconnect(self._slotNetworkProgress)
except:
pass
self.uploadProgress.connect(self.slotNetworkProgress)
@decorators.BetaImplementation
def copy(self, fromLocation, toLocation):
self.request.setUrl("%s%s" % (self.url, fromLocaltion))
data = self.manager.get(self.request)
self.put(data.readAll(), toLocation)
@QtCore.pyqtSlot()
def _slotNetworkStart(self):
self.start.emit()
@QtCore.pyqtSlot()
def _slotNetworkFinished(self, reply=None):
self.finished.emit()
#@QtCore.pyqtSlot(QtCore.QByteArray)
# def _slotNetWorkData(self, b):
# buffer = b
# self.data.emit(b)
def _slotNetworkProgress(self, bDone, bTotal):
self.dataTransferProgress.emit(bDone, bTotal)
data_ = None
reply_ = self.reply.readAll().data()
try:
data_ = str(reply_, encoding="iso-8859-15")
except:
data_ = str(reply_, encoding="utf-8")
self.data.emit(data_)
def _setAuth(self, request: QNetworkRequest):
current_url = request.url().toString()
operator = "&" if current_url.find("?") > 0 else "?"
new_url = QUrl("{}{}key={}".format(current_url, operator, Settings.MYMINIFACTORY_API_TOKEN))
request.setUrl(new_url)
def get_arrive_time(self, station_id: int):
self.__url = QUrl(self.time_arrive_pattern.format(station_id))
request = QNetworkRequest()
request.setUrl(self.__url)
request.setAttribute(QNetworkRequest.User, (int, station_id))
self.__manager.get(request)
