def createRequest(self, op, req, outgoingData = 0):
url = req.url().toString()
host = req.url().host()
if (req.url().isRelative() or req.url().scheme() == "file" or host in self.allowedHosts or url in self.allowedUrls):
print "Requesting file: " + url
return QNetworkAccessManager.createRequest(self, op, req, outgoingData)
else:
print "Dropping non-local URI request: " + url
return QNetworkAccessManager.createRequest(self, QNetworkAccessManager.GetOperation, QNetworkRequest(QUrl()))
def __init__(self):
self.last_reply = None
self.replys_cache = []
self.replys_cache_index = 0
self.last_method = None
self.initialized = False
Logger.getLoggerFor(self.__class__)
QNetworkAccessManager.__init__(self)
self.finished.connect(self.processFinishedRequest)
self.sslErrors.connect(self.processSslErrors)
def __init__(self, logger):
QNetworkAccessManager.__init__(self)
self.logger = logger
self.errors = []
# connect signals
self.sslErrors.connect(self._ssl_errors)
self.finished.connect(self._finished)
# bind a custom virtual function to createRequest
self.createRequest = self._create_request
def get(self, url, local_path):
print "url", url
print "local_path", local_path
self.url = url
self.local_path = local_path
self.mb = DownloadMessageBox(self.parent())
self.mb.buttonClicked.connect(self.handleCancel)
self.mb.rejected.connect(self.handleReject)
mgr = QNetworkAccessManager(self)
mgr.finished.connect(self.handleFinished)
self.reply = mgr.get(QNetworkRequest(QUrl(url)))
self.reply.downloadProgress.connect(self.mb.updateProgress)
self.mb.exec_()
def get(self, url, local_path):
print "url", url
print "local_path", local_path
self.url = url
self.local_path = local_path
self.mb = DownloadMessageBox(self.parent())
self.mb.buttonClicked.connect(self.handleCancel)
self.mb.rejected.connect(self.handleReject)
mgr = QNetworkAccessManager(self)
mgr.finished.connect(self.handleFinished)
self.reply = mgr.get(QNetworkRequest(QUrl(url)))
self.reply.downloadProgress.connect(self.mb.updateProgress)
self.mb.exec_()
def _create_request(self, operation, request, data):
self.log_post_data(data)
reply = QNetworkAccessManager.createRequest(self,
operation,
request,
data)
return reply
def __init__(self, parent = None):
QAbstractListModel.__init__(self, parent)
self.manager = QNetworkAccessManager(self)
self.manager.finished[QNetworkReply].connect(self.replyFinished)
self._timeStamp = ""
self._statistics = {
'P1' : 0,
'P2' : 0,
'P3' : 0,
'P4' : 0,
'P5' : 0,
'FIXED' : 0,
'UNCONFIRMED' : 0,
'---' : 0
}
self._bugs = []
self._maxValue = 0
self.setRoleNames({self.ID : 'BUG_ID',
self.STATUS : 'BUG_STATUS',
self.PRIORITY : 'BUG_PRIORITY',
self.ASSIGNEE : 'BUG_ASSIGNEE',
self.SUMARY : 'BUG_SUMMARY',
self.COMPONENT: 'BUG_COMPONENT',
self.COMMENTS : 'BUG_COMMENTS'})
self.update()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.invoice_form = InvoiceForm(self)
self.action_Account.triggered.connect(self.show_account_editor)
self.action_Update.triggered.connect(self.update_usage)
self.action_About.triggered.connect(self.about)
self.actionInvoice.triggered.connect(self.invoice_form.show)
self.network_access_manager = QNetworkAccessManager()
self.network_access_manager.finished.connect(self.fetched_usages)
self.network_access_manager.sslErrors.connect(self.allow_connection)
self.settings = QSettings('Nasim', 'BLUsage')
self.file_name = os.path.expanduser('~/.BLUsage.dat')
self.usage_model = BLUsage()
self.read_usage()
self.tree_model = TreeModel(self.usage_model.usage)
self.treeView.setModel(self.tree_model)
self.treeView.resizeColumnToContents(0)
if not self.usage_model.username:
self.show_account_editor()
self.treeView.header().setResizeMode(QHeaderView.Stretch)
self.treeView.header().setResizeMode(0, QHeaderView.ResizeToContents)
self.treeView.setAlternatingRowColors(True)
self.accountName.setText(self.usage_model.name)
self.progressBar.setHidden(True)
self.show_lastupdate()
def test():
global session
#s = u"オープニングやエンディングのアニメーションは単純に主人公を入れ替えた程度の物ではなく、タイトルロゴはもちろん金時や定春の行動や表情、登場する道具（万事屋の面々が乗る車のデザインなど）やクレジット文字など、細部に渡って変更がなされた。更に、坂田金時が『銀魂'』を最終回に追い込み新しいアニメ『まんたま』を始めようとした時にはエンディングや提供表示の煽りコメントが最終回を思わせる演出となり、『まんたま』でも専用のタイトルロゴとオープニングアニメーション（スタッフクレジット付き）が新造され、偽物の提供クレジットまで表示されるなど随所に至るまで徹底的な演出が行われた。また、テレビ欄では金魂篇終了回は『金魂'』最終回として、その翌週は新番組「銀魂'」として案内された。"
s = "test"
fr = "ja"
to = "zhs"
#s = u"What are you doing?"
#fr = "en"
from sakurakit.skprof import SkProfiler
from qtrequests import qtrequests
from PySide.QtNetwork import QNetworkAccessManager
session = qtrequests.Session(QNetworkAccessManager())
with SkProfiler():
for i in range(1):
t = translate(s, to=to, fr=fr)
print t
session = requests.Session()
with SkProfiler():
for i in range(1):
t = translate(s, to=to, fr=fr)
print t
print type(t)
#session = requests
#with SkProfiler():
# for i in range(10):
# t = translate(s, to=to, fr=fr)
#print t
app.quit()
def _create_request(self, operation, request, data):
self.log_post_data(data)
# store the request object with the upload data
try:
raw_data = data.readAll()
except AttributeError:
original_data = backup_data = None
else:
original_data = self._new_buffer(raw_data)
backup_data = self._new_buffer(raw_data)
reply = QNetworkAccessManager.createRequest(self,
operation,
request,
original_data)
self.logger.info('Request {0} started.'.format(id(reply)))
if original_data is not None:
original_data.setParent(reply)
backup_data.setParent(reply)
self._requests[id(reply)] = {'reply': reply,
'outgoing_data': backup_data,
'finished': False,
'retry_count': 0}
# in case the request object is destroyed, remove it from the dict
# of request objects
reply.destroyed.connect(partial(self._reply_destroyed, id(reply)))
return reply
def _create_request(self, operation, request, data):
reply = QNetworkAccessManager.createRequest(self.network_manager,
operation, request, data)
url = request.url().toString()
print(url)
# self.resultList.append(url)
return reply
def createRequest(self, operation, request, device=None):
if self.headers:
request = QNetworkRequest(request)
if operation != QNetworkAccessManager.PostOperation and operation != QNetworkAccessManager.PutOperation :
request.setHeader(QNetworkRequest.ContentTypeHeader, None)
for item in self.headers.iteritems():
request.setRawHeader(*item)
return QNetworkAccessManager.createRequest(self,operation, request, device)
def __init__(self, q, nam):
self.nam = nam or QNetworkAccessManager(q)
self.request = None # QNetworkRequest or None
self.reply = None # QNetworkReply or None
self.path = '' # unicode
self.file = None # python file object
self._progressTime = 0 # long
self._progressBytes = 0 # long
def __init__(self, abortSignal):
self.abortSignal = abortSignal # signal
self.online = False
self.language = 'en' # str, user language
self.convertsAlphabet = False
self.yueEnabled = False # translate zh to yue
self.allTranslators = [] # all created translators
self.marked = False
self.rubyEnabled = False
self.romajiEnabled = \
self.infoseekEnabled = \
self.exciteEnabled = \
self.niftyEnabled = \
self.systranEnabled = \
self.babylonEnabled = \
self.bingEnabled = \
self.googleEnabled = \
self.naverEnabled = \
self.vtransEnabled = \
self.baiduEnabled = \
self.youdaoEnabled = \
self.lecOnlineEnabled = \
self.transruEnabled = \
self.hanVietEnabled = \
self.jbeijingEnabled = \
self.fastaitEnabled = \
self.dreyeEnabled = \
self.ezTransEnabled = \
self.transcatEnabled = \
self.atlasEnabled = \
self.lecEnabled = \
False # bool
self.ehndEnabled = True
self.romajiType = 'romaji'
self.alignEnabled = {} # {str key:bool t}
self.scriptEnabled = {} # {str key:bool t}
self.retrans = {} # {str key:_trman.Retranslator}
# {str key:{'yes':bool,'key':str,'lang':str}}
self.retransSettings = settings.global_().retranslatorSettings() or {}
# Example:
#self.retransSettings = {
# 'jbeijing': {'yes':True, 'key': 'hanviet', 'lang':'zhs'},
#}
from PySide.QtNetwork import QNetworkAccessManager
nam = QNetworkAccessManager() # parent is not assigned
from qtrequests import qtrequests
self.session = qtrequests.Session(nam, abortSignal=self.abortSignal, requestTimeout=config.APP_ONLINE_TRANSLATION_TIMEOUT)
def __init__(self, app):
self.network_manager = QNetworkAccessManager()
self.network_manager.createRequest = self._create_request
self.web_page = QWebPage()
self.web_page.setNetworkAccessManager(self.network_manager)
self.web_view = QWebView()
self.web_view.setPage(self.web_page)
self.html_data = None
self.app = app
self.finished = threading.Event()
def __init__(self):
self.network_manager = QNetworkAccessManager()
self.network_manager.createRequest = self._create_request
self.network_manager.finished.connect(self._request_finished)
self.web_page = QWebPage()
self.web_page.setNetworkAccessManager(self.network_manager)
self.web_view = QWebView()
self.web_view.setPage(self.web_page)
def createRequest(self, operation, request, data):
# data contains all the post data that is being added to the request
# so you can look into it here
#print "replay:====>",request.url().toString(),operation
#url = request.url().toString()
reply = QNetworkAccessManager.createRequest(self, operation,request,data)
#if "js" in url or "gif" in url:
#reply = QNetworkAccessManager.createRequest(self,QNetworkAccessManager.GetOperation,QNetworkRequest(QtCore.QUrl("")))
#reply = QNetworkAccessManager.createRequest(self, operation,request,data)
#else:
return reply
def run(self, q):
from pywmp import WindowsMediaPlayer
self.wmp = WindowsMediaPlayer()
from qtrequests import qtrequests
from PySide.QtNetwork import QNetworkAccessManager
nam = QNetworkAccessManager()
self.session = qtrequests.Session(nam, abortSignal=q.abortSignal)
q.abortSignalRequested.connect(q.abortSignal, Qt.QueuedConnection)
q.playRequested.connect(self.play, Qt.QueuedConnection)
q.stopRequested.connect(self.stop, Qt.QueuedConnection)
def __init__(self, logger, max_request_retries):
QNetworkAccessManager.__init__(self)
self._http_methods = {
QNetworkAccessManager.HeadOperation: lambda r, d: self.head(r),
QNetworkAccessManager.GetOperation: lambda r, d: self.get(r),
QNetworkAccessManager.PutOperation: lambda r, d: self.put(r, d),
QNetworkAccessManager.PostOperation: lambda r, d: self.post(r, d),
QNetworkAccessManager.DeleteOperation:
lambda r, d: self.deleteResource(r)
}
self.logger = logger
self._max_request_retries = max_request_retries
self._requests = dict()
self.errors = []
self.sslErrors.connect(self._ssl_errors)
self.finished.connect(self._finished)
# bind a custom virtual function to createRequest
self.createRequest = self._create_request
def _create_request(self, operation, request, data):
try:
raw_data = smart_str(data.peek(8192))
except AttributeError:
# data is None, nothing will be sent in this request
pass
else:
parsed_data = '\n'.join(raw_data.split('&'))
print parsed_data
reply = QNetworkAccessManager.createRequest(self._network_manager,
operation,
request,
data)
return reply
def __init__(self):
super(MainWindow, self).__init__()
self.nam = QNetworkAccessManager()
self.setWindowIcon(QIcon(os.path.join('icons', 'Logo_rendered_edited.png')))
layout = QBoxLayout(QBoxLayout.TopToBottom)
layout.setContentsMargins(0, 0, 0, 0)
self.preference_manager = PreferenceManager()
self.kgk_manager = KgkManager()
self.kgk_manager.set_preference_manager(self.preference_manager)
self.settings_manager = PasswordSettingsManager(self.preference_manager)
self.setting_dirty = True
# Header bar
header_bar = QFrame()
header_bar.setStyleSheet(
"QWidget { background: rgb(40, 40, 40); } " +
"QToolButton { background: rgb(40, 40, 40); }" +
"QToolTip { color: rgb(255, 255, 255); background-color: rgb(20, 20, 20); " +
"border: 1px solid white; }")
header_bar.setAutoFillBackground(True)
header_bar.setFixedHeight(45)
header_bar_layout = QBoxLayout(QBoxLayout.LeftToRight)
header_bar_layout.addStretch()
header_bar.setLayout(header_bar_layout)
layout.addWidget(header_bar)
self.create_header_bar(header_bar_layout)
# Widget area
main_area = QFrame()
main_layout = QBoxLayout(QBoxLayout.TopToBottom)
main_area.setLayout(main_layout)
layout.addWidget(main_area)
self.create_main_area(main_layout)
# Window layout
layout.addStretch()
main_layout.addStretch()
self.setLayout(layout)
settings = QSettings()
size = settings.value("MainWindow/size")
if not size:
size = QSize(350, 450)
self.resize(size)
position = settings.value("MainWindow/pos")
if not position:
position = QPoint(0, 24)
self.move(position)
self.setWindowTitle("c't SESAM")
self.master_password_edit.setFocus()
self.show()
def __init__(self):
self.user_agent = 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2) Gecko/20100124 Firefox/3.6 (Swiftfox)'
self.application = QApplication([])
self.webpage = QWebPage()
self.network_manager = QNetworkAccessManager()
self.network_manager.createRequest = self._create_request
self.webpage.setNetworkAccessManager(self.network_manager)
self.webpage.userAgentForUrl = lambda url: self.user_agent
self.webframe = self.webpage.currentFrame()
self.webpage.javaScriptAlert = self._alert
self.webpage.javaScriptConfirm = self._alert
self.url = ''
self._load_status = 'init'
self.web_view = QWebView()
self.web_view.setPage(self.webpage)
self.web_view.loadFinished.connect(self.onLoadFinished)
def __init__(self, callback):
self._network_manager = QNetworkAccessManager()
# connect signals
self._network_manager.sslErrors.connect(self._ssl_errors)
self._network_manager.finished.connect(self._finished)
# bind a custom virtual function to createRequest
self._network_manager.createRequest = self._create_request
# a dict of available request methods
self._request_methods = {
'delete': lambda r, d: self._network_manager.deleteResource(r),
'get': lambda r, d: self._network_manager.get(r),
'head': lambda r, d: self._network_manager.head(r),
'post': lambda r, d: self._network_manager.post(r, d),
'put': lambda r, d: self._network_manager.put(r, d),
}
# store the callback function which will be called when a request is
# finished
self._result_callback = callback
def __init__(self, parent=None):
super(InvoiceForm, self).__init__(parent)
self.setupUi(self)
self.progressBar.setHidden(True)
self.invoice = Invoice(self)
self.tableView.setModel(self.invoice)
self.tableView.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.tableView.setAlternatingRowColors(True)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.updateButton.clicked.connect(self.update_invoices)
self.tableView.selectionModel().selectionChanged.connect(self.invoice_selected)
self.webpage = QWebPage()
self.webpage.loadFinished.connect(self.save_invoice)
self.webpage.networkAccessManager().sslErrors.connect(self.allow_connection)
self.network_access_manager = QNetworkAccessManager()
self.network_access_manager.finished.connect(self.fetched_invoices)
self.network_access_manager.sslErrors.connect(self.allow_connection)
def createRequest(self, operation, request, outgoingData):
url = request.url().toString()
for h in request.rawHeaderList():
pass
#self._debug(DEBUG, " %s: %s" % (h, request.rawHeader(h)))
if self._url_filter:
if url in self._url_filter:
#self._debug(INFO, "URL filtered: %s" % url)
request.setUrl(QUrl("about:blank"))
else:
pass
#self._debug(DEBUG, "URL not filtered: %s" % url)
#print url
#if url == "http://v5.ele.me/":
#request.setRawHeader("Accept-Encoding","")
reply = QNetworkAccessManager.createRequest(self, operation, request, outgoingData)
#self.emit(SIGNAL('networkRequestCreated(QNetworkReply*)'), reply)
#if html[:6]=='\x1f\x8b\x08\x00\x00\x00':
# html=gzip.GzipFile(fileobj=StringIO(html)).read()
return reply
def __init__(self, parent=None):
QNetworkAccessManager.__init__(self, parent=parent)
self._ignore_ssl_errors = False
self.sslErrors.connect(self.handleSslErrors)
def __init__(self, parent):
QNetworkAccessManager.__init__(self, parent)
self.finished.connect(self._request_ended)
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.invoice_form = InvoiceForm(self)
self.action_Account.triggered.connect(self.show_account_editor)
self.action_Update.triggered.connect(self.update_usage)
self.action_About.triggered.connect(self.about)
self.actionInvoice.triggered.connect(self.invoice_form.show)
self.network_access_manager = QNetworkAccessManager()
self.network_access_manager.finished.connect(self.fetched_usages)
self.network_access_manager.sslErrors.connect(self.allow_connection)
self.settings = QSettings('Nasim', 'BLUsage')
self.file_name = os.path.expanduser('~/.BLUsage.dat')
self.usage_model = BLUsage()
self.read_usage()
self.tree_model = TreeModel(self.usage_model.usage)
self.treeView.setModel(self.tree_model)
self.treeView.resizeColumnToContents(0)
if not self.usage_model.username:
self.show_account_editor()
self.treeView.header().setResizeMode(QHeaderView.Stretch)
self.treeView.header().setResizeMode(0, QHeaderView.ResizeToContents)
self.treeView.setAlternatingRowColors(True)
self.accountName.setText(self.usage_model.name)
self.progressBar.setHidden(True)
self.show_lastupdate()
def show_account_editor(self):
AccountDialog(self.usage_model, self).exec_()
self.accountName.setText(self.usage_model.name)
self.show_lastupdate()
self.write_usage()
def about(self):
QMessageBox.about(self, "BLUsage",
"""Bangla Lion bandwidth usage viewer.
Version 2.0
Author: M. Nasimul Haque
email: [email protected]
Web: http://www.nasim.me.uk""")
def update_usage(self):
if not all([self.usage_model.username, self.usage_model.password]):
QMessageBox.critical(self, 'No account',
'Please enter your account details first.')
return
request = QNetworkRequest(QUrl(self.usage_model.user_endpoint))
self.network_access_manager.post(request, self.usage_model.post_data)
self.updateButton.setEnabled(False)
self.progressBar.setHidden(False)
self.progressBar.setValue(0)
self.statusBar.showMessage("Please wait...")
def fetched_usages(self, reply):
self.updateButton.setEnabled(True)
self.progressBar.setHidden(True)
if reply.error() == QNetworkReply.NoError:
if not self.usage_model.parse(str(reply.readAll())):
title = "Parsing error"
message = self.usage_model.error
else:
title = None
self.tree_model.deleteLater()
self.tree_model = TreeModel(self.usage_model.usage)
self.treeView.setModel(self.tree_model)
self.show_lastupdate()
self.write_usage()
elif reply.error() in [QNetworkReply.AuthenticationRequiredError,
QNetworkReply.ContentAccessDenied]:
title = "Authentication error"
message = "Please check your account credentials."
else:
title = "An error occured"
message = reply.errorString() \
+ ".\nPlease check your internet connection."
if title:
QMessageBox.critical(self, title, message)
reply.deleteLater()
def allow_connection(self, reply):
reply.ignoreSslErrors()
def read_usage(self):
self.usage_model.name = self.settings.value('name')
self.usage_model.username = self.settings.value('username')
self.usage_model.password = self.settings.value('password')
self.usage_model.last_update = self.settings.value('last_update')
self.usage_model.capKB = int(self.settings.value('cap') or 0)
self.usage_model.totalKB = int(self.settings.value('total') or 0)
start = self.settings.value('start')
if not start:
today = QDate.currentDate()
start = QDate(today.year(), today.month(), 1)
self.usage_model.start = start
end = self.settings.value('end')
if not end:
end = start.addDays(29)
self.usage_model.end = end
def write_usage(self):
self.settings.setValue('name', self.usage_model.name)
self.settings.setValue('username', self.usage_model.username)
self.settings.setValue('password', self.usage_model.password)
self.settings.setValue('start', self.usage_model.start)
self.settings.setValue('end', self.usage_model.end)
self.settings.setValue('last_update', self.usage_model.last_update)
self.settings.setValue('cap', self.usage_model.capKB)
self.settings.setValue('total', self.usage_model.totalKB)
def show_lastupdate(self):
self.totalLabel.setText("Totals usage: <b>%s</b>" %
(self.usage_model.smart_bytes(self.usage_model.totalKB),))
remaining = self.usage_model.remaining()
if isinstance(remaining, int):
self.remainingLabel.setText("Remaining: <b>%s</b>" %
(self.usage_model.smart_bytes(remaining),))
else:
self.remainingLabel.setText("Remaining: <b>Unlimited</b>")
try:
if not self.usage_model.last_update:
self.statusBar.showMessage("Ready")
else:
self.statusBar.showMessage("Last updated on: " +
self.usage_model.last_update.toString())
except:
pass
def __init__(self, *args, **kwargs):
QNetworkAccessManager.__init__(self, *args, **kwargs)
self.headers = {}
class Bugzilla (QAbstractListModel):
# Role names
ID = 0
STATUS = 1
PRIORITY = 2
ASSIGNEE = 3
SUMARY = 4
COMPONENT = 5
COMMENTS = 6
def __init__(self, parent = None):
QAbstractListModel.__init__(self, parent)
self.manager = QNetworkAccessManager(self)
self.manager.finished[QNetworkReply].connect(self.replyFinished)
self._timeStamp = ""
self._statistics = {
'P1' : 0,
'P2' : 0,
'P3' : 0,
'P4' : 0,
'P5' : 0,
'FIXED' : 0,
'UNCONFIRMED' : 0,
'---' : 0
}
self._bugs = []
self._maxValue = 0
self.setRoleNames({self.ID : 'BUG_ID',
self.STATUS : 'BUG_STATUS',
self.PRIORITY : 'BUG_PRIORITY',
self.ASSIGNEE : 'BUG_ASSIGNEE',
self.SUMARY : 'BUG_SUMMARY',
self.COMPONENT: 'BUG_COMPONENT',
self.COMMENTS : 'BUG_COMMENTS'})
self.update()
# WORKAROUND
@Slot(str, result=str)
def parseISODate(self, isoDate):
return QDateTime.fromString(isoDate, Qt.ISODate).toString('dd/MM/yyyy hh:mm')
@Slot()
def update(self):
url = "http://bugs.pyside.org/buglist.cgi?bug_status=UNCONFIRMED&bug_status=NEW&bug_status=WAITING&bug_status=ASSIGNED&bug_status=REOPENED&bug_status=RESOLVED&bug_status=VERIFIED&product=PySide&query_format=advanced&resolution=---&resolution=FIXED&ctype=csv"
self._timeStamp = QDateTime.currentDateTime().toString("h:mm ap")
self.manager.get(QNetworkRequest(QUrl(url)))
@Slot(QNetworkReply)
def replyFinished(self, reply):
for k in self._statistics:
self._statistics[k] = 0
self._bugs = []
while not reply.atEnd():
line = str(reply.readLine())
if line.startswith('bug_id'):
continue
fields = line.split(',', 7)
fields = map(lambda (x) : x.strip()[1:-1] if x.startswith('"') else x, fields)
fields = map(lambda (x) : x.replace('""', '"'), fields)
self._bugs.append(fields)
statisticsFields = (2, 5, 6)
if fields[6] != '---': # just open bugs
statisticsFields = (5, 6)
for i in statisticsFields:
key = fields[i]
if key in self._statistics:
self._statistics[key] += 1
self._maxValue = max(self._statistics['P1'], self._statistics['P2'], self._statistics['P3'], self._statistics['P4'], self._statistics['P5'])
reply.deleteLater()
#self.dataChanged.emit(self.index(0, 0), self.index(4, 0))
self.reset()
self.modelUpdated.emit()
def getMaxValue(self):
return self._maxValue
def getTimeStamp(self):
return self._timeStamp
modelUpdated = Signal()
maxValue = Property(int, getMaxValue, notify = modelUpdated)
lastUpdate = Property(str, getTimeStamp, notify = modelUpdated)
unconfirmedBugs = Property(int, lambda(self) : self._statistics['UNCONFIRMED'], notify = modelUpdated)
fixedBugs = Property(int, lambda(self) : self._statistics['FIXED'], notify = modelUpdated)
openedBugs = Property(int, lambda(self) : self._statistics['---'], notify = modelUpdated)
p1 = Property(int, lambda(self) : self._statistics['P1'], notify = modelUpdated)
p2 = Property(int, lambda(self) : self._statistics['P2'], notify = modelUpdated)
p3 = Property(int, lambda(self) : self._statistics['P3'], notify = modelUpdated)
p4 = Property(int, lambda(self) : self._statistics['P4'], notify = modelUpdated)
p5 = Property(int, lambda(self) : self._statistics['P5'], notify = modelUpdated)
def rowCount(self, index):
return len(self._bugs)
def data(self, index, role):
row = index.row()
if role == self.ID:
return self._bugs[row][0]
elif role == self.STATUS:
return self._bugs[row][5]
elif role == self.PRIORITY:
return self._bugs[row][2]
elif role == self.ASSIGNEE:
if self._bugs[row][5] == 'ASSIGNED':
return self._bugs[row][4]
return 'nobody'
elif role == self.SUMARY or Qt.DisplayRole:
return self._bugs[row][7]
elif role == self.COMPONENT:
return 'PySide'
elif role == self.COMMENTS:
return "Comments ..."
return None
def __init__(self):
QObject.__init__(self)
self.manager = QNetworkAccessManager()
self.current_downloads = {}
self.manager.finished.connect(self.download_finished)
class DownloadManager(QObject):
dl_finished = Signal(str, str)
def __init__(self):
QObject.__init__(self)
self.manager = QNetworkAccessManager()
self.current_downloads = {}
self.manager.finished.connect(self.download_finished)
def do_download(self, dl_url):
url = QUrl(dl_url)
req = QNetworkRequest(url)
reply = self.manager.get(req)
self.current_downloads[reply] = dl_url
def get_file_name(self, url):
path = url.path()
basename = QFileInfo(path).fileName()
if not basename:
basename = "download"
if QFile.exists(basename):
print "aaaaaaaaaaaaaaaah"
return
return basename
def save_to_disk(self, filename, data):
f = QFile(filename)
if not f.open(QIODevice.WriteOnly):
print "could not open %s for writing" % filename
return False
f.write(data.readAll())
f.close()
return True
def execute(self):
print "downloader on the run"
dls = ["http://www.pyside.org/docs/pyside/_static/pysidelogo.png",
"https://www.google.com/intl/en_com/images/srpr/logo3w.png"]
for dl in dls:
self.do_download(dl)
def download_finished(self, reply):
url = reply.url()
if reply.error():
print "Dowload of %s failed" % url.toEncoded()
return
else:
#filename = self.save_file_name(url)
f = QTemporaryFile()
if f.open():
filename = f.fileName()
else:
print "Creation of tempfile for %s failed" % url.toEncoded()
return
if self.save_to_disk(filename, reply):
print "Download of %s succeded (saved to %s)\n" % (
url.toEncoded(), filename)
url = self.current_downloads.pop(reply)
reply.deleteLater()
self.dl_finished.emit(url, filename)
def lastlog(self, url, filename):
print url, "to", filename, "ok"
if len(self.current_downloads) == 0:
print "bye"
QCoreApplication.instance().quit()
def createRequest(self, op, request, outgoingData=None):
conf = QSslConfiguration()
conf.setProtocol(QSsl.TlsV1)
request.setSslConfiguration(conf)
return QNetworkAccessManager.createRequest(self, op, request, outgoingData)
class InvoiceForm(QDialog, Ui_InvoiceDialog):
def __init__(self, parent=None):
super(InvoiceForm, self).__init__(parent)
self.setupUi(self)
self.progressBar.setHidden(True)
self.invoice = Invoice(self)
self.tableView.setModel(self.invoice)
self.tableView.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.tableView.setAlternatingRowColors(True)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.updateButton.clicked.connect(self.update_invoices)
self.tableView.selectionModel().selectionChanged.connect(self.invoice_selected)
self.webpage = QWebPage()
self.webpage.loadFinished.connect(self.save_invoice)
self.webpage.networkAccessManager().sslErrors.connect(self.allow_connection)
self.network_access_manager = QNetworkAccessManager()
self.network_access_manager.finished.connect(self.fetched_invoices)
self.network_access_manager.sslErrors.connect(self.allow_connection)
def invoice_selected(self, new, old):
try:
row = self.invoice.invoices[new.indexes()[0].row()]
except IndexError:
return
if row[1].startswith('Invoice'):
self.invoice_filename = os.path.expanduser('~/.blusage/%s.png' % row[1].lower())
if os.path.exists(self.invoice_filename):
self.load_invoice()
else:
usage = self.parentWidget().usage_model
url = '%s%s' % (usage.user_endpoint[:-5], self.invoice.invoices[new.indexes()[0].row()][0])
self.webpage.mainFrame().load(QUrl(url))
self.webpage.mainFrame().setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self.webpage.mainFrame().setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.webpage.setViewportSize(QSize(800, 600))
self.enable_ui(False)
else:
self.invoiceLabel.setText("""
<center>
<table>
<tr>
<th>Payment #</th>
<td>{number}</td>
</tr>
<tr>
<th>Date</th>
<td>{date}</td>
</tr>
<tr>
<th>Credit</th>
<td>{credit}</td>
</tr>
<tr>
<th>Balance</th>
<td>{balance}</td>
</tr>
</table>
</center>
""".format(number=row[1][8:], date=row[2], credit=row[3], balance=row[5]))
def load_invoice(self):
pixmap = QPixmap(self.invoice_filename)
self.invoiceLabel.setPixmap(pixmap)
def update_invoices(self):
usage = self.parentWidget().usage_model
url = '%s?%s' % (usage.user_endpoint, self.invoice.post_data)
request = QNetworkRequest(QUrl(url))
self.network_access_manager.get(request)
self.enable_ui(False)
def enable_ui(self, value=True):
self.updateButton.setEnabled(value)
self.progressBar.setHidden(value)
self.tableView.setEnabled(value)
def save_invoice(self, ok):
self.enable_ui()
if ok:
frame = self.webpage.mainFrame()
image = QImage(frame.contentsSize(), QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent);
painter = QPainter(image)
painter.setRenderHint(QPainter.Antialiasing, True);
painter.setRenderHint(QPainter.TextAntialiasing, True);
painter.setRenderHint(QPainter.SmoothPixmapTransform, True);
frame.documentElement().render(painter);
painter.end();
image.save(self.invoice_filename)
self.load_invoice()
else:
title = "An error occured"
message = "Could not load invoice." \
+ "\nPlease check your internet connection."
QMessageBox.critical(self, title, message)
def fetched_invoices(self, reply):
self.enable_ui()
if reply.error() == QNetworkReply.NoError:
html = unicode(reply.readAll())
self.invoice.parse(html)
self.invoice.reset()
else:
title = "An error occured"
message = reply.errorString() \
+ ".\nPlease check your internet connection."
QMessageBox.critical(self, title, message)
reply.deleteLater()
def allow_connection(self, reply):
reply.ignoreSslErrors()
def _create_request(self, operation, request, data):
print(data.readAll())
reply = QNetworkAccessManager.createRequest(self.network_manager,
operation, request, data)
return reply
"""Processes replies and dispatches results to requesters.
This method will be invoked on each finished request, submitted by
:py:meth:`.fetch_banner`. It then converts the loaded data into a
banner and passes the result on to the model of the request's origin.
:param reply: The network reply from a banner load request.
:type reply: :class:`.QNetworkReply`
"""
pixmap = QPixmap()
if reply.error() == QNetworkReply.NoError:
image_bytes = reply.readAll()
pixmap.loadFromData(image_bytes)
else:
pixmap.load(":/icons/image-missing.png")
index = self._ready_signal.pop(reply.request().url().toString())
index.model().setData(index, pixmap, Qt.DecorationRole)
banner_loader = BannerLoader()
disk_cache = QNetworkDiskCache()
disk_cache.setCacheDirectory(dirs.user_cache_dir)
disk_cache.setMaximumCacheSize(100 * 1024 * 1024) # 100MB Cache
access_manager = QNetworkAccessManager()
access_manager.setCache(disk_cache)
access_manager.finished.connect(banner_loader.finished_request)
def testSetNetworkAccessManager(self):
page = QWebPage()
manager = QNetworkAccessManager()
page.setNetworkAccessManager(manager)
def createRequest(self,op,request,outgoing=None):
self.configureSsl(request)
reply = QNetworkAccessManager.createRequest(self,op,request,outgoing)
self.attachCallbacks(reply)
self.cacheReply(reply)
return reply
class NetManager(object):
def __init__(self, callback):
self._network_manager = QNetworkAccessManager()
# connect signals
self._network_manager.sslErrors.connect(self._ssl_errors)
self._network_manager.finished.connect(self._finished)
# bind a custom virtual function to createRequest
self._network_manager.createRequest = self._create_request
# a dict of available request methods
self._request_methods = {
'delete': lambda r, d: self._network_manager.deleteResource(r),
'get': lambda r, d: self._network_manager.get(r),
'head': lambda r, d: self._network_manager.head(r),
'post': lambda r, d: self._network_manager.post(r, d),
'put': lambda r, d: self._network_manager.put(r, d),
}
# store the callback function which will be called when a request is
# finished
self._result_callback = callback
def _ssl_errors(self, reply, errors):
# currently we ignore all ssl related errors
reply.ignoreSslErrors()
def _finished(self, reply):
# Called when a request is finished, whether it was successful or not.
# Obtain some basic information about the request
reply_url = reply.url().toString()
# Request headers
request_headers = dict((str(hdr), str(reply.request().rawHeader(hdr)))
for hdr in reply.request().rawHeaderList())
# Reply headers
reply_headers = dict((str(hdr), str(reply.rawHeader(hdr)))
for hdr in reply.rawHeaderList())
status_code = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
reason = reply.attribute(QNetworkRequest.HttpReasonPhraseAttribute)
redirect = reply.attribute(QNetworkRequest.RedirectionTargetAttribute)
result = {'reply_url': smart_str(reply_url),
'status_code': status_code,
'reason': reason,
'redirect_to': smart_str(redirect.toString()),
'request_headers': request_headers,
'reply_headers': reply_headers}
if reply.error() == QNetworkReply.NoError:
# request was successful
result['successful'] = True
result['reply_data'] = reply.readAll()
else:
# request was not successful
result['successful'] = False
result['error'] = reply.error()
result['error_msg'] = reply.errorString()
# schedule the reply object for deletion
reply.deleteLater()
# calling the callback function which we passed upon instantiation to
# report the results there
self._result_callback(result)
def _create_request(self, operation, request, data):
try:
raw_data = smart_str(data.peek(8192))
except AttributeError:
# data is None, nothing will be sent in this request
pass
else:
parsed_data = '\n'.join(raw_data.split('&'))
print parsed_data
reply = QNetworkAccessManager.createRequest(self._network_manager,
operation,
request,
data)
return reply
def _prepare_request(self, url, headers):
# create an empty request
request = QNetworkRequest()
# assign a url to it
request.setUrl(QUrl(url))
# add some custom headers to the request
for (header_name, header_value) in headers.items():
request.setRawHeader(header_name, QByteArray(header_value))
return request
def _urlencode_request_data(self, raw_data):
# the data which we want to send to the server must be urlencoded
request_data = QUrl()
for (name, value) in raw_data.items():
request_data.addQueryItem(name, unicode(value))
return request_data.encodedQuery()
def perform(self, method, url, headers, raw_data=None):
# create the request object
request = self._prepare_request(url, headers)
# urlencode the request data
request_data = self._urlencode_request_data(raw_data or dict())
# locate the request function for the choosen request method
request_func = self._request_methods[method.lower()]
# initiate request
request_func(request, request_data)
class DownloadManager(QObject):
dl_finished = Signal(str, str)
def __init__(self):
QObject.__init__(self)
self.manager = QNetworkAccessManager()
self.current_downloads = {}
self.manager.finished.connect(self.download_finished)
def do_download(self, dl_url):
url = QUrl(dl_url)
req = QNetworkRequest(url)
reply = self.manager.get(req)
self.current_downloads[reply] = dl_url
def get_file_name(self, url):
path = url.path()
basename = QFileInfo(path).fileName()
if not basename:
basename = "download"
if QFile.exists(basename):
print "aaaaaaaaaaaaaaaah"
return
return basename
def save_to_disk(self, filename, data):
f = QFile(filename)
if not f.open(QIODevice.WriteOnly):
print "could not open %s for writing" % filename
return False
f.write(data.readAll())
f.close()
return True
def execute(self):
print "downloader on the run"
dls = [
"http://www.pyside.org/docs/pyside/_static/pysidelogo.png",
"https://www.google.com/intl/en_com/images/srpr/logo3w.png"
]
for dl in dls:
self.do_download(dl)
def download_finished(self, reply):
url = reply.url()
if reply.error():
print "Dowload of %s failed" % url.toEncoded()
return
else:
#filename = self.save_file_name(url)
f = QTemporaryFile()
if f.open():
filename = f.fileName()
else:
print "Creation of tempfile for %s failed" % url.toEncoded()
return
if self.save_to_disk(filename, reply):
print "Download of %s succeded (saved to %s)\n" % (url.toEncoded(),
filename)
url = self.current_downloads.pop(reply)
reply.deleteLater()
self.dl_finished.emit(url, filename)
def lastlog(self, url, filename):
print url, "to", filename, "ok"
if len(self.current_downloads) == 0:
print "bye"
QCoreApplication.instance().quit()
def __init__(self):
QObject.__init__(self)
self.manager = QNetworkAccessManager()
self.current_downloads = {}
self.manager.finished.connect(self.download_finished)
