def on_received_response(self, reply: QNetworkReply):
if reply.error() != QNetworkReply.NoError:
error_msg = "Unable to create new print share: {}".format(reply.errorString())
logging.error(error_msg)
app_settings.app_data_writer.signals.exchange_share_failed.emit(error_msg)
return
share_location = reply.rawHeader(QByteArray(bytes("Location", encoding="utf-8")))
app_settings.app_data_writer.signals.exchange_share_created.emit(share_location.data().decode())
reply.deleteLater()
self.buffer.close()
def done(self, reply: QNetworkReply) -> None:
if reply.error() != QNetworkReply.NoError:
self.logger.error(reply.errorString())
sys.stderr.write(reply.errorString())
return
if os.getenv('DEBUG', False):
self.log_request(reply)
# noinspection PyTypeChecker
jsonobj = json.loads(str(reply.readAll(), 'utf-8'))
reply.deleteLater()
latest = parse_version(jsonobj.get('tag_name'))
current = parse_version(qApp.applicationVersion())
self.mbox.show_result(latest, current)
def done(self, reply: QNetworkReply):
if reply.error() != QNetworkReply.NoError:
sys.stderr.write(reply.errorString())
return
try:
json_data = json.loads(str(reply.readAll(), 'utf-8'))
reply.deleteLater()
latest = json_data.get('tag_name')
current = qApp.applicationVersion()
self.parent.update_available(latest, current)
except json.JSONDecodeError:
self.logger.exception('Error retrieving data', exc_info=True)
raise
def handleNetworkData(self, networkReply: QNetworkReply):
if networkReply.error() == QNetworkReply.NoError:
choices = []
response = networkReply.readAll()
xml = QXmlStreamReader(response)
while not xml.atEnd():
xml.readNext()
if xml.tokenType() == QXmlStreamReader.StartElement:
if xml.name() == 'suggestion':
string = xml.attributes().value('data')
choices.append(string)
self.showCompletion(choices)
networkReply.deleteLater()
def done(self, reply: QNetworkReply) -> None:
if reply.error() != QNetworkReply.NoError:
self.logger.error(reply.errorString())
sys.stderr.write(reply.errorString())
return
if os.getenv('DEBUG', False):
self.log_request(reply)
try:
jsonobj = loads(str(reply.readAll(), 'utf-8'))
reply.deleteLater()
latest = jsonobj.get('tag_name')
current = qApp.applicationVersion()
self.mbox.show_result(latest, current)
except JSONDecodeError:
self.logger.exception('Updater JSON decoding error', exc_info=True)
raise
def handle_finished(self, reply: QNetworkReply) -> None:
reply.deleteLater()
if reply is not self._current_reply:
return
if reply.error() == QNetworkReply.OperationCanceledError:
return
results, error_string = self.process_reply(reply)
if isinstance(results, Iterable):
for result in results:
item = QStandardItem(result)
self.appendRow(item)
if isinstance(error_string, str) and error_string:
self._error_string = error_string
else:
self._error_string = ""
self._current_reply = None
self.finished.emit()
def __request_finished(self, reply: QNetworkReply):
"""
Slot attached to finished signal of network access manager
Retrieves HTTP data and sets image appropriately
"""
pix = QPixmap()
if reply.error() != QNetworkReply.NoError:
qDebug(f"Unable to fetch image at {reply.url()}")
else:
img_data = reply.readAll()
pix.loadFromData(img_data)
reply.deleteLater()
if pix.isNull():
pix.load(R"img/default_photo.png")
# Emit signal
self.image_request_finished.emit(reply.url().toString(), pix)
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 from_reply(cls, reply: QtNetwork.QNetworkReply) -> 'Response':
"""Slowly populates a new Response object with data from the request."""
r = cls()
# Signal mapping
reply.metaDataChanged.connect(functools.partial(r._insert_headers, reply.rawHeaderPairs()))
reply.redirected.connect(r._insert_url)
reply.error.connect(r._update_code)
reply.error.connect(functools.partial(r._update_error_string, reply.errorString()))
# Wait until the request is finished before continuing
signals.wait_for_signal(reply.finished)
# Strip the remaining data from the reply, then mark it for deletion
r._from_reply(reply)
reply.close()
reply.deleteLater()
# Return the object
return r
def handleNetworkData(self, reply: QNetworkReply) -> None:
img = QImage()
tp = reply.request().attribute(QNetworkRequest.User)
if not reply.error():
if not img.load(reply, ""):
img = QImage()
reply.deleteLater()
self.m_tilePixmaps[QPointH(tp)] = (
self.m_emptyTile if img.isNull() else QPixmap.fromImage(img)
)
self.updated.emit(self.tileRect(tp))
# purge unused spaces
bound = self.m_tilesRect.adjusted(-2, -2, 2, 2)
self.m_tilePixmaps = {
tp: pixmap
for tp, pixmap in self.m_tilePixmaps.items()
if bound.contains(tp)
}
self.download()
