def __init__(self,
framework,
url,
operation,
request,
requestContent,
cookieJar,
reply,
parent=None):
QNetworkReply.__init__(self, parent)
self.framework = framework
self.Data = self.framework.getDB()
self.__url = url
self.__request = request
self.__reply = reply
self.reqUrl = request.url()
self.requestContent = requestContent
self.requestTime = time.time()
self.data_io = BytesIO()
self.response_data = b''
self.datalen = 0
self.offset = 0
self.response_status = ''
self.responseHeaders = b''
self.is_finished = False
self.requestId = ''
self.xrefId = ''
self.pendingData = b''
self.__populate_request_info(operation, cookieJar)
QObject.connect(self.__reply,
SIGNAL('sslErrors(const QList<QSslError> &)'),
self.handle_sslErrors)
QObject.connect(self.__reply,
SIGNAL('error(QNetworkReply::NetworkError)'),
self.handle_errors)
QObject.connect(self.__reply, SIGNAL('uploadProgress(qint64, qint64)'),
self.handle_uploadProgress)
QObject.connect(self.__reply,
SIGNAL('downloadProgress(qint64, qint64)'),
self.handle_downloadProgress)
QObject.connect(self.__reply, SIGNAL('readyRead()'),
self.handle_readyRead)
QObject.connect(self.__reply, SIGNAL('metaDataChanged()'),
self.handle_metaDataChanged)
QObject.connect(self.__reply, SIGNAL('finished()'),
self.handle_finished)
self.debug_print('__init__')
self.setOperation(self.__reply.operation())
self.setReadBufferSize(self.__reply.readBufferSize())
self.setRequest(self.__reply.request())
self.setUrl(self.__reply.url())
self.open(self.ReadOnly | self.Unbuffered)
def __init__(self, parent, request, reply, operation): #self.sniffed_data = "" #self.sniffed_data = QByteArray() QNetworkReply.__init__(self, parent) self.open(self.ReadOnly | self.Unbuffered) self.setUrl(QUrl(request.url())) self.setRequest(request) self.offset = 0 reply.finished.connect(self.onReplyFinished)
def __init__(self, url, operation, html):
QNetworkReply.__init__(self)
self.content = html
self.offset = 0
self.setHeader(QNetworkRequest.ContentTypeHeader, QVariant("text/html; charset=utf-8"))
self.setHeader(QNetworkRequest.ContentLengthHeader, QVariant(len(self.content)))
QTimer.singleShot(0, self, SIGNAL("readyRead()"))
QTimer.singleShot(0, self, SIGNAL("finished()"))
self.open(self.ReadOnly | self.Unbuffered)
self.setUrl(url)
def __init__(self, protocol, parent = None):
"""
Constructor
@param protocol protocol name (string or QString)
@param parent reference to the parent object (QObject)
"""
QNetworkReply.__init__(self, parent)
self.setError(QNetworkReply.ProtocolUnknownError,
self.trUtf8("Protocol '%1' not supported.").arg(protocol))
QTimer.singleShot(0, self.__fireSignals)
def __init__(self, parent, request):
QNetworkReply.__init__(self, parent)
res = ":" + str(request.url().path().toUtf8())
self.file = None
self.filepath = res
self.connect(self, SIGNAL('aboutToClose()'), self.__close)
self.setRequest(request)
self.setOperation(QNetworkAccessManager.GetOperation)
self.open()
self.setUrl(request.url())
self.connect(parent, SIGNAL("ready"), self.ready)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent object (QObject)
"""
QNetworkReply.__init__(self, parent)
self.setOperation(QNetworkAccessManager.GetOperation)
self.setError(QNetworkReply.OperationCanceledError, "eric4:No Error")
QTimer.singleShot(0, self, SIGNAL("finished()"))
def __init__(self, parent, reply):
QNetworkReply.__init__(self, parent)
self.reply = reply # reply to proxy
self.data = '' # contains downloaded data
self.buffer = '' # contains buffer of data to read
self.setOpenMode(QNetworkReply.ReadOnly | QNetworkReply.Unbuffered)
#print dir(reply)
# connect signal from proxy reply
reply.metaDataChanged.connect(self.applyMetaData)
reply.readyRead.connect(self.readInternal)
reply.finished.connect(self.finished)
reply.uploadProgress.connect(self.uploadProgress)
reply.downloadProgress.connect(self.downloadProgress)
def __init__(self, parent, url, content, operation, urllib_request, urllib_response):
QNetworkReply.__init__(self, parent)
self.content = content
self.offset = 0
self.urllib_request = urllib_request
self.urllib_response = urllib_response
self.setHeader(QNetworkRequest.ContentTypeHeader, "text/html")
self.setHeader(QNetworkRequest.ContentLengthHeader, len(self.content))
QTimer.singleShot(0, self, SIGNAL("readyRead()"))
QTimer.singleShot(0, self, SIGNAL("finished()"))
self.open(self.ReadOnly | self.Unbuffered)
self.setUrl(QUrl(url))
def __init__(self, request, rule, parent = None):
"""
Constructor
@param request reference to the request object (QNetworkRequest)
@param fileData reference to the data buffer (QByteArray)
@param mimeType for the reply (string)
"""
QNetworkReply.__init__(self, parent)
self.setOperation(QNetworkAccessManager.GetOperation)
self.setRequest(request)
self.setUrl(request.url())
self.setError(QNetworkReply.ContentAccessDenied,
self.trUtf8("Blocked by AdBlock rule: %1.").arg(rule.filter()))
QTimer.singleShot(0, self.__fireSignals)
def __init__(self,request,url,parent=None,qwebview=None):
QNetworkReply.__init__(self,parent)
self.qwebview=qwebview
self.setRequest(request)
self.setOpenMode(QIODevice.ReadOnly)
self.m_data=self.loadResource(url)
if self.m_data!=None:
self.m_length=len(self.m_data)
self.m_data=StringIO.StringIO(self.m_data)
else:
self.m_length=0
self.m_data=StringIO.StringIO('')
self.left=self.m_length
self.setHeader(QNetworkRequest.ContentLengthHeader,QVariant(QtCore.QByteArray.number(self.m_length)))
# QTimer.singleShot(0,self,QtCore.SIGNAL('metaDataChanged()'))
QTimer.singleShot(0,self,QtCore.SIGNAL('readyRead()'))
def __init__(self, url):
QNetworkReply.__init__(self)
self.gopher = QTcpSocket()
self.gopher.bytesWritten.connect(self.writeGopherData)
self.gopher.readyRead.connect(self.readGopherData)
self.gopher.connected.connect(self.getResource)
self.gopher.disconnected.connect(self.setContent)
self.input = ""
self.output = ""
self.content = ""
self.offset = 0
self.setUrl(url)
self.gopher.connectToHost(url.host(), 70)
def bytesAvailable(self): # NOTE: # This works for Win: # return len(self.content) - self.offset # but it does not work under OS X. # Solution which works for OS X and Win: # return len(self.content) - self.offset + QNetworkReply.bytesAvailable(self) return len(self.content) - self.offset + QNetworkReply.bytesAvailable(self)
def __init__(self, parent, operation, request, searcher_hp, searcher_de):
QNetworkReply.__init__(self, parent)
url = request.url()
self.setRequest(request)
self.setUrl(url)
self.setOperation(operation)
self.open(QIODevice.ReadOnly)
self._finished = False
self._data = None
self._offset = 0
self._url = url
self._searcher_hp = searcher_hp
self._searcher_de = searcher_de
QTimer.singleShot(0, self._load) # don't disturb the UI thread
def __init__(self, parent=None):
# -------------------------------------------------------------------
# http://pyqt.sourceforge.net/Docs/PyQt4/qnetworkreply.html
QNetworkReply.__init__( self, parent );
# -------------------------------------------------------------------
self.PARENT = parent;
self.DEBUG = False;
self.LOG_TAG = str(self.__class__.__name__).upper();
# -------------------------------------------------------------------
self.HEADERS_FRAME = QFrame( self.PARENT );
self.HEADERS_FRAME.setGeometry( 10, 50, 980, 520 );
self.HEADERS_FRAME.setStyleSheet( "QFrame{ font: 12px 'monospace'; color: #000; background-color: rbga(0,0,0, 170); border-style: solid; border-width: 5px; border-color: #FFF; }" );
self.HEADERS_FRAME.hide();
# -------------------------------------------------------------------
self.HEADERS_RAW = QTextEdit("TEST: TEST", self.HEADERS_FRAME);
self.HEADERS_RAW.setGeometry(5, 5, 970, 510);
self.HEADERS_RAW.setStyleSheet("QTextEdit{ color: #fff; margin: 5px; padding: 5px; border-style: dashed; border-width: 1px; border-color: #FFF; }")
self.HEADERS_RAW.setReadOnly(True);
#self.HEADERS_RAW.setOpenExternalLinks(True);
#self.HEADERS_RAW.show();
# -------------------------------------------------------------------
self.downloadProgress.connect( self._DOWN );
self.uploadProgress.connect( self._UP );
self.error.connect( self._ERROR);
self.finished.connect( self._FINISH );
self.metaDataChanged.connect( self._META_DATA_CHANGED );
self.sslErrors.connect( self._SSL_ERROR );
# -------------------------------------------------------------------
self.SHOW_NOT_REQUESTED_HEADERS = False;
self.LAST_PAGE_REQUEST_HEADERS = {};
self.LAST_PAGE_REQUEST_FILES = [];
# -------------------------------------------------------------------
self.IS_OPEN = False;
self.KEEP_OPEN = False;
# -------------------------------------------------------------------
self.PARENT.SPLASH.STATUS( self.LOG_TAG+": [INIT]" );
def bytesAvailable(self):
"""
Public method to determined the bytes available for being read.
@return bytes available (integer)
"""
if self.__data.length() == 0:
QTimer.singleShot(0, self, SIGNAL("finished()"))
return self.__data.length() + QNetworkReply.bytesAvailable(self)
def __init__(self, parent, request):
QNetworkReply.__init__(self, parent)
self.qbuffer = None
self.connect(self, SIGNAL('abouteToClose()'), self.__close)
self.byteArray = QByteArray()
self.qbuffer = QBuffer(self.byteArray)
self.node = vfs().getnode(str(request.url().path().toUtf8()))
self.thumbnailer = Thumbnailer()
self.connect(self.thumbnailer, SIGNAL("ThumbnailUpdate"),
self.updateThumbnail)
self.setRequest(request)
self.setOperation(QNetworkAccessManager.GetOperation)
mime = "image/jpg"
self.setHeader(QNetworkRequest.ContentTypeHeader, QVariant(mime))
self.open()
self.setUrl(request.url())
self.connect(parent, SIGNAL("ready"), self.ready)
self.ready()
def __init__(self, parent, operation, request,
searcher_hp, searcher_de):
QNetworkReply.__init__(self, parent)
url = request.url()
self.setRequest(request)
self.setUrl(url)
self.setOperation(operation)
self.open(QIODevice.ReadOnly)
self._finished = False
self._data = None
self._offset = 0
self._url = url
self._searcher_hp = searcher_hp
self._searcher_de = searcher_de
QTimer.singleShot(0, self._load) # don't disturb the UI thread
def __getattribute__(self, attr):
"""Send undefined methods straight through to proxied reply
"""
# send these attributes through to proxy reply
if attr in ('operation', 'request', 'url', 'abort', 'close'):#, 'isSequential'):
value = self.reply.__getattribute__(attr)
else:
value = QNetworkReply.__getattribute__(self, attr)
#print attr, value
return value
def __getattribute__(self, attr):
"""Send undefined methods straight through to proxied reply
"""
# send these attributes through to proxy reply
if attr in ('operation', 'request', 'url', 'abort', 'close'):#, 'isSequential'):
value = self.original_reply.__getattribute__(attr)
else:
value = QNetworkReply.__getattribute__(self, attr)
#print attr, value
return value
def __getattribute__(self, attr):
"""Send undefined methods straight through to proxied reply
"""
# send these attributes through to proxy reply
if attr in ("operation", "request", "url", "abort", "close"): # , 'isSequential'):
value = self.reply.__getattribute__(attr)
else:
value = QNetworkReply.__getattribute__(self, attr)
# print attr, value
return value
def __init__(self, request, fileData, mimeType, parent = None):
"""
Constructor
@param request reference to the request object (QNetworkRequest)
@param fileData reference to the data buffer (QByteArray)
@param mimeType for the reply (string)
@param parent reference to the parent object (QObject)
"""
QNetworkReply.__init__(self, parent)
self.__data = fileData
self.setRequest(request)
self.setOpenMode(QIODevice.ReadOnly)
self.setHeader(QNetworkRequest.ContentTypeHeader, QVariant(mimeType))
self.setHeader(QNetworkRequest.ContentLengthHeader,
QVariant(QByteArray.number(fileData.length())))
QTimer.singleShot(0, self, SIGNAL("metaDataChanged()"))
QTimer.singleShot(0, self, SIGNAL("readyRead()"))
def __init__(self, parent, request):
QNetworkReply.__init__(self, parent)
self.__parent = parent
self.qbuffer = None
self.connect(self, SIGNAL('abouteToClose()'), self.__close)
self.byteArray = QByteArray()
self.qbuffer = QBuffer(self.byteArray)
self.setRequest(request)
self.setOperation(QNetworkAccessManager.GetOperation)
self.setHeader(
QNetworkRequest.ContentTypeHeader,
QVariant(
'"text/javascript" charset="utf-8" language="javascript"'))
self.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
QVariant(QNetworkRequest.AlwaysNetwork))
self.open()
self.setUrl(request.url())
self.writeJS()
QTimer.singleShot(0, self, SIGNAL("readyRead()"))
QTimer.singleShot(0, self, SIGNAL("finished()"))
def __init__(self, framework, url, operation, request, requestContent, cookieJar, reply, parent = None):
QNetworkReply.__init__(self, parent)
self.framework = framework
self.Data = self.framework.getDB()
self.__url = url
self.__request = request
self.__reply = reply
self.reqUrl = request.url()
self.requestContent = requestContent
self.requestTime = time.time()
self.data_io = BytesIO()
self.response_data = b''
self.datalen = 0
self.offset = 0
self.response_status = ''
self.responseHeaders = b''
self.is_finished = False
self.requestId = ''
self.xrefId = ''
self.pendingData = b''
self.__populate_request_info(operation, cookieJar)
QObject.connect(self.__reply, SIGNAL('sslErrors(const QList<QSslError> &)'), self.handle_sslErrors)
QObject.connect(self.__reply, SIGNAL('error(QNetworkReply::NetworkError)'), self.handle_errors)
QObject.connect(self.__reply, SIGNAL('uploadProgress(qint64, qint64)'), self.handle_uploadProgress)
QObject.connect(self.__reply, SIGNAL('downloadProgress(qint64, qint64)'), self.handle_downloadProgress)
QObject.connect(self.__reply, SIGNAL('readyRead()'), self.handle_readyRead)
QObject.connect(self.__reply, SIGNAL('metaDataChanged()'), self.handle_metaDataChanged)
QObject.connect(self.__reply, SIGNAL('finished()'), self.handle_finished)
self.debug_print('__init__')
self.setOperation(self.__reply.operation())
self.setReadBufferSize(self.__reply.readBufferSize())
self.setRequest(self.__reply.request())
self.setUrl(self.__reply.url())
self.open(self.ReadOnly | self.Unbuffered)
def __init__(self, parent, reply):
QNetworkReply.__init__(self, parent)
self.m_reply = reply
self.m_buffer = self.m_data = ''
# apply attributes
self.setOperation(self.m_reply.operation())
self.setRequest(self.m_reply.request())
self.setUrl(self.m_reply.url())
# handle these to forward
self.m_reply.metaDataChanged.connect(self.applyMetaData)
self.m_reply.readyRead.connect(self.readInternal)
self.m_reply.error.connect(self.errorInternal)
# forward signals
self.m_reply.finished.connect(self.finished)
self.m_reply.uploadProgress.connect(self.uploadProgress)
self.m_reply.downloadProgress.connect(self.downloadProgress)
# for the data proxy...
self.setOpenMode(QNetworkReply.ReadOnly)
def __init__(self, access_manager, request, url, operation, book_manager):
QNetworkReply.__init__(self, access_manager)
self.book_manager = book_manager
uri = unicode(url.toEncoded()).split(self.url_scheme + '://')[1]
self.resource = route_dictionary_uri(uri, self.book_manager.books.values())
self.offset = 0
self.content = ''
self.aborted = False
self.setHeader(QNetworkRequest.ContentTypeHeader, QVariant('text/html; charset=UTF-8'))
self.setRequest(request)
self.setUrl(url)
self.open(self.ReadOnly | self.Unbuffered)
self.renderer = EpwingRenderer(self.resource, parent=self)
self.renderer.finished.connect(self._finished)
self.renderer.terminated.connect(self._finished)
self.renderer.readyRead.connect(self.get_rendered_data)
self.renderer.render()
def setReadBufferSize(self, size):
QNetworkReply.setReadBufferSize(size)
self.m_reply.setReadBufferSize(size)
def bytesAvailable(self):
return self.left+QNetworkReply.bytesAvailable(self)
def bytesAvailable(self): c_bytes = len(self.sniffed_data) - self.offset + QNetworkReply.bytesAvailable(self) return c_bytes
def __init__(self, manager, url, handler, encoding="UTF-8"):
QNetworkReply.__init__(self, manager)
self.setUrl(url)
self._handler = handler
self._encoding = encoding
def bytesAvailable(self):
"""
How many bytes in the buffer are available to be read
"""
return len(self.buffer) + QNetworkReply.bytesAvailable(self)
def __init__(self, manager, url, handler, encoding="UTF-8"):
QNetworkReply.__init__(self, manager)
self.setUrl(url)
self._handler = handler
self._encoding = encoding
def bytesAvailable(self):
"""
How many bytes in the buffer are available to be read
"""
return len(self.buffer) + QNetworkReply.bytesAvailable(self)
