def to_png(image): """ Get as PNG """ imgbuf = QBuffer() imgbuf.open(QIODevice.ReadWrite) image.save(imgbuf, "PNG") # Return a QByteArray return imgbuf.data()
def writeTile(self, tile, image, fileFormat, quality): data = QByteArray() buff = QBuffer(data) image.save(buff, fileFormat, quality) self.cursor.execute('''INSERT INTO tiles(zoom_level, tile_column, tile_row, tile_data) VALUES (?, ?, ?, ?);''', (tile.z, tile.x, tile.y, sqlite3.Binary(buff.data()))) buff.close()
class Response(QgsServerResponse): """ Adaptor to handler response The data is written at 'flush()' call. """ def __init__(self, handler: RequestHandler) -> None: super().__init__() self._handler = handler self._buffer = QBuffer() self._buffer.open(QIODevice.ReadWrite) self._numbytes = 0 self._finish = False def setStatusCode(self, code: int) -> None: if not self._handler.header_written: self._handler.status_code = code else: LOGGER.error("Cannot set status code after header written") def statusCode(self) -> int: return self._handler.status_code def finish(self) -> None: """ Terminate the request """ self._finish = True self.flush() def flush(self) -> None: """ Write the data to the handler buffer and flush the socket Headers will be written at the first call to flush() """ try: self._buffer.seek(0) bytesAvail = self._buffer.bytesAvailable() LOGGER.debug("%s: Flushing response data: (%d bytes)", self._handler.identity, bytesAvail) if self._finish: self._handler.headers['Content-Length'] = bytesAvail # Take care of the logic: if finish and not handler.header_written then there is no # chunk following send_more = not self._finish or self._handler.header_written if bytesAvail: self._handler.send(bytes(self._buffer.data()), send_more) self._buffer.buffer().clear() # push the sentinel if send_more and self._finish: self._handler.send(b'', False) except: LOGGER.error("Caught Exception (worker: %s, msg: %s):\n%s", self._handler.identity, self._handler.msgid, traceback.format_exc()) del self._handler.headers['Content-Type'] self.sendError(500, "Internal server error") def header(self, key: str) -> str: return self._handler.headers.get(key) def headers(self) -> Dict[str, str]: """ Return headers as dict """ return self._handler.headers def io(self) -> QIODevice: return self._buffer def data(self) -> QByteArray: """ Return buffer data """ return self._buffer.data() def setHeader(self, key: str, value: str) -> None: if not self._handler.header_written: self._handler.headers[key] = value else: LOGGER.error("Cannot set header after header written") def removeHeader(self, key: str) -> None: self._handler.headers.pop(key, None) def sendError(self, code: int, message: str = None) -> None: try: if not self._handler.header_written: LOGGER.error("%s (%s)", message, code) self._handler.status_code = code self._handler.send(bytes(str(message).encode('ascii'))) self._finish = True else: LOGGER.error("Cannot set error after header written") except: LOGGER.critical("Unrecoverable exception:\n%s", traceback.format_exc()) def _clearHeaders(self) -> None: """ Clear headers set so far """ self._handler.headers = {} def clear(self) -> None: self._clearHeaders() self.truncate() def headersSent(self) -> bool: return self._handler.header_written def truncate(self) -> None: """ Truncate buffer """ self._buffer.seek(0) self._buffer.buffer().clear()