def runProcess(self, args):
self.logDb( u"BEFEHL: '%s'" % ( u"' '".join(args) ) )
currout = ""
currerr = ""
p = QProcess()
p.start( args[0], args[1:] )
i=0
while not p.waitForFinished(500):
i += 1
self.alive.setText( self.alive.text()[:-1] + ("-\|/")[i%4] )
app.processEvents()
currout = self.processOutput( currout, p.readAllStandardOutput() )
currerr = self.processOutput( currerr, p.readAllStandardError() )
if p.state()<>QProcess.Running:
if self.canceled:
self.log( u"Prozeß abgebrochen." )
break
if self.canceled:
self.log( u"Prozeß wird abgebrochen." )
p.kill()
currout = self.processOutput( currout, p.readAllStandardOutput() )
if currout and currout!="":
self.log( "E %s" % currout )
currerr = self.processOutput( currerr, p.readAllStandardError() )
if currerr and currerr!="":
self.log( "E %s" % currerr )
ok = False
if p.exitStatus()==QProcess.NormalExit:
if p.exitCode()==0:
ok = True
else:
self.log( u"Fehler bei Prozeß: %d" % p.exitCode() )
else:
self.log( u"Prozeß abgebrochen: %d" % p.exitCode() )
self.logDb( "EXITCODE: %d" % p.exitCode() )
p.close()
return ok
def runProcess(self, args):
self.logDb(u"BEFEHL: '%s'" % (u"' '".join(args)))
currout = ""
currerr = ""
p = QProcess()
p.start(args[0], args[1:])
i = 0
while not p.waitForFinished(500):
i += 1
self.alive.setText(self.alive.text()[:-1] + ("-\|/")[i % 4])
app.processEvents()
currout = self.processOutput(currout, p.readAllStandardOutput())
currerr = self.processOutput(currerr, p.readAllStandardError())
if p.state() <> QProcess.Running:
if self.canceled:
self.log(u"Prozeß abgebrochen.")
break
if self.canceled:
self.log(u"Prozeß wird abgebrochen.")
p.kill()
currout = self.processOutput(currout, p.readAllStandardOutput())
if currout and currout != "":
self.log("E %s" % currout)
currerr = self.processOutput(currerr, p.readAllStandardError())
if currerr and currerr != "":
self.log("E %s" % currerr)
ok = False
if p.exitStatus() == QProcess.NormalExit:
if p.exitCode() == 0:
ok = True
else:
self.log(u"Fehler bei Prozeß: %d" % p.exitCode())
else:
self.log(u"Prozeß abgebrochen: %d" % p.exitCode())
self.logDb("EXITCODE: %d" % p.exitCode())
p.close()
return ok
class WallpaperChanger(object):
def __init__(self):
self.settings = Settings()
self.process = QProcess()
def apply_wallpaper(self, filepath):
system_platform = platform.system()
if system_platform == 'Windows':
return self._windows(filepath)
elif system_platform == 'Linux':
# Read desktop environment from settings.
env = self.settings.linux_desktop
print 'Setting wallpaper using environment "{0:s}"'.format(env)
if env == 'feh':
return self._feh(filepath)
elif env == 'unity':
return self._unity(filepath)
elif env == 'xfce4':
return self._xfce4(filepath)
elif env == 'mate':
return self._mate(filepath)
def _windows(self, filepath):
import ctypes
SPI_SETDESKWALLPAPER = 20 # According to http://support.microsoft.com/default.aspx?scid=97142
ctypes.windll.user32.SystemParametersInfoA(SPI_SETDESKWALLPAPER, 0, filepath, 1)
def _feh(self, filepath):
error = self.process.execute('feh --bg-scale {0:s}'.format(filepath))
return not bool(error)
def _unity(self, filepath):
error = self.process.execute('gsettings set org.gnome.desktop.background picture-uri {0:s}'.format(filepath))
return not bool(error)
def _mate(self, filepath):
error = self.process.execute('gsettings set org.mate.background picture-filename {0:s}'.format(filepath))
return not bool(error)
def _xfce4(self, filepath):
self.process.start('xfconf-query -c xfce4-desktop -l')
self.process.waitForFinished()
properties = re.findall(r'(/backdrop/screen.*(?:last-image|image-path))',
unicode(self.process.readAllStandardOutput()))
error = False
for item in properties:
self.process.start('xfconf-query --channel xfce4-desktop --property {0:s} --set {1:s}'.format(item, '/'))
self.process.waitForFinished()
self.process.start(
'xfconf-query --channel xfce4-desktop --property {0:s} --set {1:s}'.format(item, filepath))
self.process.waitForFinished()
if self.process.exitCode():
error = True
return not error
class InoProcess(QtCore.QThread):
def __init__(self,project,command):
QtCore.QThread.__init__(self,project.parent())
self.project=project
self.command=command
def run(self):
self.project.newMessage.emit()
self.project.addMessage.emit("# running: "+self.command+"\n")
start_time=time.time()
self.proc = QProcess(None)
self.proc.readyReadStandardError.connect(self.stdErrReady)
self.proc.readyReadStandardOutput.connect(self.stdOutReady)
self.proc.setWorkingDirectory(self.project.path)
commands = self.command.split(' ')
args=QStringList()
for cmd in commands[1:]:
args.append(cmd)
self.proc.start(QString(commands[0]), args, mode=QIODevice.ReadOnly)
self.proc.waitForFinished()
end_time=time.time()
if (self.proc.exitCode()==0):
self.project.statusChanged.emit("SUCCESS")
self.project.addMessage.emit("# \""+self.command+"\" finished in "+str(end_time-start_time)+"sec\n")
else:
self.project.statusChanged.emit("FAILED")
self.project.addErrorMessage.emit("# \""+self.command+"\" finished in "+str(end_time-start_time)+ "sec with status:"+str(self.proc.exitCode())+"\n")
def stop(self):
if self.proc!=None and self.proc.state()!=QProcess.NotRunning:
self.project.addErrorMessage.emit("# Received stop process command\n")
self.proc.kill()
def stdErrReady(self):
#Reading possible errors
errors=unicode(self.proc.readAllStandardError().data(),errors='ignore')
if (errors!=None and len(errors)>0):
self.project.addErrorMessage.emit(QString(errors))
def stdOutReady(self):
msg=unicode(self.proc.readAllStandardOutput().data(),errors='ignore')
if (msg!=None and len(msg)>0):
self.project.addMessage.emit(QString(msg))
class Main(plugin.Plugin):
" Main Class "
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.scriptPath, self.scriptArgs = "", []
self.profilerPath, self.tempPath = profilerPath, tempPath
self.output = " ERROR: FAIL: No output ! "
self.process = QProcess()
self.process.finished.connect(self.on_process_finished)
self.process.error.connect(self.on_process_error)
self.tabWidget, self.stat = QTabWidget(), QWidget()
self.tabWidget.tabCloseRequested.connect(
lambda: self.tabWidget.setTabPosition(1) if self.tabWidget.
tabPosition() == 0 else self.tabWidget.setTabPosition(0))
self.tabWidget.setStyleSheet('QTabBar{font-weight:bold;}')
self.tabWidget.setMovable(True)
self.tabWidget.setTabsClosable(True)
self.vboxlayout1 = QVBoxLayout(self.stat)
self.hboxlayout1 = QHBoxLayout()
self.filterTableLabel = QLabel("<b>Type to Search : </b>", self.stat)
self.hboxlayout1.addWidget(self.filterTableLabel)
self.filterTableLineEdit = QLineEdit(self.stat)
self.filterTableLineEdit.setPlaceholderText(' Type to Search . . . ')
self.hboxlayout1.addWidget(self.filterTableLineEdit)
self.filterHintTableLabel = QLabel(" ? ", self.stat)
self.hboxlayout1.addWidget(self.filterHintTableLabel)
self.vboxlayout1.addLayout(self.hboxlayout1)
self.tableWidget = QTableWidget(self.stat)
self.tableWidget.setAlternatingRowColors(True)
self.tableWidget.setColumnCount(8)
self.tableWidget.setRowCount(2)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(4, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(5, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(6, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(7, item)
self.tableWidget.itemDoubleClicked.connect(
self.on_tableWidget_itemDoubleClicked)
self.vboxlayout1.addWidget(self.tableWidget)
self.tabWidget.addTab(self.stat, " ? ")
self.source = QWidget()
self.gridlayout = QGridLayout(self.source)
self.scintillaWarningLabel = QLabel(
"QScintilla is not installed!. Falling back to basic text edit!.",
self.source)
self.gridlayout.addWidget(self.scintillaWarningLabel, 1, 0, 1, 2)
self.sourceTreeWidget = QTreeWidget(self.source)
self.sourceTreeWidget.setAlternatingRowColors(True)
self.sourceTreeWidget.itemActivated.connect(
self.on_sourceTreeWidget_itemActivated)
self.sourceTreeWidget.itemClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.sourceTreeWidget.itemDoubleClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.gridlayout.addWidget(self.sourceTreeWidget, 0, 0, 1, 1)
self.sourceTextEdit = QTextEdit(self.source)
self.sourceTextEdit.setReadOnly(True)
self.gridlayout.addWidget(self.sourceTextEdit, 0, 1, 1, 1)
self.tabWidget.addTab(self.source, " ? ")
self.result = QWidget()
self.vlayout = QVBoxLayout(self.result)
self.globalStatGroupBox = QGroupBox(self.result)
self.hboxlayout = QHBoxLayout(self.globalStatGroupBox)
self.totalTimeLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.totalTimeLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.totalTimeLcdNumber.setNumDigits(7)
self.totalTimeLcdNumber.display(1000000)
self.totalTimeLcdNumber.setFrameShape(QFrame.StyledPanel)
self.totalTimeLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.totalTimeLcdNumber)
self.tTimeLabel = QLabel("<b>Total Time (Sec)</b>",
self.globalStatGroupBox)
self.tTimeLabel.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.tTimeLabel)
self.numCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.numCallLcdNumber.setNumDigits(7)
self.numCallLcdNumber.display(1000000)
self.numCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.numCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.numCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.numCallLcdNumber)
self.numCallLabel = QLabel("<b>Number of calls</b>",
self.globalStatGroupBox)
self.numCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.numCallLabel)
self.primCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.primCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.primCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.primCallLcdNumber.setNumDigits(7)
self.primCallLcdNumber.display(1000000)
self.primCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.primCallLcdNumber)
self.primCallLabel = QLabel("<b>Primitive calls (%)</b>",
self.globalStatGroupBox)
self.primCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.primCallLabel)
self.vlayout.addWidget(self.globalStatGroupBox)
try:
from PyKDE4.kdeui import KRatingWidget
self.rating = KRatingWidget(self.globalStatGroupBox)
self.rating.setToolTip('Profiling Performance Rating')
except ImportError:
pass
self.tabWidget.addTab(self.result, " Get Results ! ")
self.resgraph = QWidget()
self.vlayout2 = QVBoxLayout(self.result)
self.graphz = QGroupBox(self.resgraph)
self.hboxlayout2 = QHBoxLayout(self.graphz)
try:
from PyKDE4.kdeui import KLed
KLed(self.graphz)
except ImportError:
pass
self.hboxlayout2.addWidget(
QLabel('''
Work in Progress :) Not Ready Yet'''))
self.vlayout2.addWidget(self.graphz)
self.tabWidget.addTab(self.resgraph, " Graphs and Charts ")
self.pathz = QWidget()
self.vlayout3 = QVBoxLayout(self.pathz)
self.patz = QGroupBox(self.pathz)
self.hboxlayout3 = QVBoxLayout(self.patz)
self.profilepath = QLineEdit(profilerPath)
self.getprofile = QPushButton(QIcon.fromTheme("document-open"), 'Open')
self.getprofile.setToolTip(
'Dont touch if you dont know what are doing')
self.getprofile.clicked.connect(lambda: self.profilepath.setText(
str(
QFileDialog.getOpenFileName(
self.patz, ' Open the profile.py file ',
path.expanduser("~"), ';;(profile.py)'))))
self.hboxlayout3.addWidget(
QLabel(
'<center><b>Profile.py Python Library Full Path:</b></center>')
)
self.hboxlayout3.addWidget(self.profilepath)
self.hboxlayout3.addWidget(self.getprofile)
self.argGroupBox = QGroupBox(self.pathz)
self.hbxlayout = QHBoxLayout(self.argGroupBox)
self.argLineEdit = QLineEdit(self.argGroupBox)
self.argLineEdit.setToolTip(
'Not touch if you dont know what are doing')
self.argLineEdit.setPlaceholderText(
'Dont touch if you dont know what are doing')
self.hbxlayout.addWidget(
QLabel('<b>Additional Profile Arguments:</b>'))
self.hbxlayout.addWidget(self.argLineEdit)
self.hboxlayout3.addWidget(self.argGroupBox)
self.vlayout3.addWidget(self.patz)
self.tabWidget.addTab(self.pathz, " Paths and Configs ")
self.outp = QWidget()
self.vlayout4 = QVBoxLayout(self.outp)
self.outgro = QGroupBox(self.outp)
self.outgro.setTitle(" MultiProcessing Output Logs ")
self.hboxlayout4 = QVBoxLayout(self.outgro)
self.outputlog = QTextEdit()
self.outputlog.setText('''
I do not fear computers, I fear the lack of them. -Isaac Asimov ''')
self.hboxlayout4.addWidget(self.outputlog)
self.vlayout4.addWidget(self.outgro)
self.tabWidget.addTab(self.outp, " Logs ")
self.actionNew_profiling = QAction(QIcon.fromTheme("document-new"),
'New Profiling', self)
self.actionLoad_profile = QAction(QIcon.fromTheme("document-open"),
'Open Profiling', self)
self.actionClean = QAction(QIcon.fromTheme("edit-clear"), 'Clean',
self)
self.actionClean.triggered.connect(lambda: self.clearContent)
self.actionAbout = QAction(QIcon.fromTheme("help-about"), 'About',
self)
self.actionAbout.triggered.connect(lambda: QMessageBox.about(
self.dock, __doc__, ', '.join(
(__doc__, __license__, __author__, __email__))))
self.actionSave_profile = QAction(QIcon.fromTheme("document-save"),
'Save Profiling', self)
self.actionManual = QAction(QIcon.fromTheme("help-contents"), 'Help',
self)
self.actionManual.triggered.connect(lambda: open_new_tab(
'http://docs.python.org/library/profile.html'))
self.tabWidget.setCurrentIndex(2)
self.globalStatGroupBox.setTitle("Global Statistics")
item = self.tableWidget.horizontalHeaderItem(0)
item.setText("Number of Calls")
item = self.tableWidget.horizontalHeaderItem(1)
item.setText("Total Time")
item = self.tableWidget.horizontalHeaderItem(2)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(3)
item.setText("Cumulative Time")
item = self.tableWidget.horizontalHeaderItem(4)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(5)
item.setText("Filename")
item = self.tableWidget.horizontalHeaderItem(6)
item.setText("Line")
item = self.tableWidget.horizontalHeaderItem(7)
item.setText("Function")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.stat),
"Statistics per Function")
self.sourceTreeWidget.headerItem().setText(0, "Source files")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.source),
"Sources Navigator")
#######################################################################
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(self.tabWidget)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
QToolBar(self.dock).addActions(
(self.actionNew_profiling, self.actionClean,
self.actionSave_profile, self.actionLoad_profile,
self.actionManual, self.actionAbout))
self.actionNew_profiling.triggered.connect(
self.on_actionNew_profiling_triggered)
self.actionLoad_profile.triggered.connect(
self.on_actionLoad_profile_triggered)
self.actionSave_profile.triggered.connect(
self.on_actionSave_profile_triggered)
self.locator.get_service('misc').add_widget(
self.dock, QIcon.fromTheme("document-open-recent"), __doc__)
if QSCI:
# Scintilla source editor management
self.scintillaWarningLabel.setText(' QScintilla is Ready ! ')
layout = self.source.layout()
layout.removeWidget(self.sourceTextEdit)
self.sourceTextEdit = Qsci.QsciScintilla(self.source)
layout.addWidget(self.sourceTextEdit, 0, 1)
doc = self.sourceTextEdit
doc.setLexer(Qsci.QsciLexerPython(self.sourceTextEdit))
doc.setReadOnly(True)
doc.setEdgeMode(Qsci.QsciScintilla.EdgeLine)
doc.setEdgeColumn(80)
doc.setEdgeColor(QColor("#FF0000"))
doc.setFolding(Qsci.QsciScintilla.BoxedTreeFoldStyle)
doc.setBraceMatching(Qsci.QsciScintilla.SloppyBraceMatch)
doc.setCaretLineVisible(True)
doc.setMarginLineNumbers(1, True)
doc.setMarginWidth(1, 25)
doc.setTabWidth(4)
doc.setEolMode(Qsci.QsciScintilla.EolUnix)
self.marker = {}
for color in COLORS:
mnr = doc.markerDefine(Qsci.QsciScintilla.Background)
doc.setMarkerBackgroundColor(color, mnr)
self.marker[color] = mnr
self.currentSourcePath = None
# Connect table and tree filter edit signal to unique slot
self.filterTableLineEdit.textEdited.connect(
self.on_filterLineEdit_textEdited)
# Timer to display filter hint message
self.filterHintTimer = QTimer(self)
self.filterHintTimer.setSingleShot(True)
self.filterHintTimer.timeout.connect(self.on_filterHintTimer_timeout)
# Timer to start search
self.filterSearchTimer = QTimer(self)
self.filterSearchTimer.setSingleShot(True)
self.filterSearchTimer.timeout.connect(
self.on_filterSearchTimer_timeout)
self.tabLoaded = {}
for i in range(10):
self.tabLoaded[i] = False
self.backgroundTreeMatchedItems = {}
self.resizeWidgetToContent(self.tableWidget)
def on_actionNew_profiling_triggered(self):
self.clearContent()
self.scriptPath = str(
QFileDialog.getOpenFileName(self.dock,
"Choose your script to profile",
path.expanduser("~"),
"Python (*.py *.pyw)"))
commandLine = [
self.profilerPath, "-o", self.tempPath, self.scriptPath
] + self.scriptArgs
commandLine = " ".join(commandLine)
##if self.termCheckBox.checkState() == Qt.Checked:
#termList = ["xterm", "aterm"]
#for term in termList:
#termPath = which(term)
#if termPath:
#break
#commandLine = """%s -e "%s ; echo 'Press ENTER Exit' ; read" """ \
#% (termPath, commandLine)
self.process.start(commandLine)
if not self.process.waitForStarted():
print((" ERROR: {} failed!".format(commandLine)))
return
def on_process_finished(self, exitStatus):
' whan the process end '
print((" INFO: OK: QProcess is %s" % self.process.exitCode()))
self.output = self.process.readAll().data()
if not self.output:
self.output = " ERROR: FAIL: No output ! "
self.outputlog.setText(self.output + str(self.process.exitCode()))
if path.exists(self.tempPath):
self.setStat(self.tempPath)
remove(self.tempPath)
else:
self.outputlog.setText(" ERROR: QProcess FAIL: Profiling failed.")
self.tabWidget.setCurrentIndex(2)
def on_process_error(self, error):
' when the process fail, I hope you never see this '
print(" ERROR: QProcess FAIL: Profiler Dead, wheres your God now ? ")
if error == QProcess.FailedToStart:
self.outputlog.setText(" ERROR: FAIL: Profiler execution failed ")
elif error == QProcess.Crashed:
self.outputlog.setText(" ERROR: FAIL: Profiler execution crashed ")
else:
self.outputlog.setText(" ERROR: FAIL: Profiler unknown error ")
def on_actionLoad_profile_triggered(self):
"""Load a previous profile sessions"""
statPath = str(
QFileDialog.getOpenFileName(self.dock, "Open profile dump",
path.expanduser("~"),
"Profile file (*)"))
if statPath:
self.clearContent()
print(' INFO: OK: Loading profiling from ' + statPath)
self.setStat(statPath)
def on_actionSave_profile_triggered(self):
"""Save a profile sessions"""
statPath = str(
QFileDialog.getSaveFileName(self.dock, "Save profile dump",
path.expanduser("~"),
"Profile file (*)"))
if statPath:
#TODO: handle error case and give feelback to user
print(' INFO: OK: Saving profiling to ' + statPath)
self.stat.save(statPath)
#=======================================================================#
# Common parts #
#=======================================================================#
def on_tabWidget_currentChanged(self, index):
"""slot for tab change"""
# Kill search and hint timer if running to avoid cross effect
for timer in (self.filterHintTimer, self.filterSearchTimer):
if timer.isActive():
timer.stop()
if not self.stat:
#No stat loaded, nothing to do
return
self.populateTable()
self.populateSource()
def on_filterLineEdit_textEdited(self, text):
"""slot for filter change (table or tree"""
if self.filterSearchTimer.isActive():
# Already runnning, stop it
self.filterSearchTimer.stop()
# Start timer
self.filterSearchTimer.start(300)
def on_filterHintTimer_timeout(self):
"""Timeout to warn user about text length"""
print("timeout")
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
label = self.filterHintTableLabel
label.setText("Type > 2 characters to search")
def on_filterSearchTimer_timeout(self):
"""timeout to start search"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
text = self.filterTableLineEdit.text()
label = self.filterHintTableLabel
edit = self.filterTableLineEdit
widget = self.tableWidget
else:
print("Unknow tab for filterSearch timeout !")
print(("do search for %s" % text))
if not len(text):
# Empty keyword, just clean all
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
self.warnUSer(True, edit)
self.clearSearch()
return
if len(text) < 2:
# Don't filter if text is too short and tell it to user
self.filterHintTimer.start(600)
return
else:
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
# Search
self.clearSearch()
matchedItems = []
if tab == TAB_FUNCTIONSTAT:
# Find items
matchedItems = widget.findItems(text, Qt.MatchContains)
widget.setSortingEnabled(False)
matchedRows = [item.row() for item in matchedItems]
# Hide matched items
header = widget.verticalHeader()
for row in range(widget.rowCount()):
if row not in matchedRows:
header.hideSection(row)
widget.setSortingEnabled(True)
else:
print(" Unknow tab for filterSearch timeout ! ")
print(("got %s members" % len(matchedItems)))
self.warnUSer(matchedItems, edit)
self.resizeWidgetToContent(widget)
def resizeWidgetToContent(self, widget):
"""Resize all columns according to content"""
for i in range(widget.columnCount()):
widget.resizeColumnToContents(i)
def clearSearch(self):
"""Clean search result
For table, show all items
For tree, remove colored items"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
header = self.tableWidget.verticalHeader()
if header.hiddenSectionCount():
for i in range(header.count()):
if header.isSectionHidden(i):
header.showSection(i)
def clearContent(self):
# Clear tabs
self.tableWidget.clearContents()
self.sourceTreeWidget.clear()
# Reset LCD numbers
for lcdNumber in (self.totalTimeLcdNumber, self.numCallLcdNumber,
self.primCallLcdNumber):
lcdNumber.display(1000000)
# Reset stat
self.pstat = None
# Disable save as menu
self.actionSave_profile.setEnabled(False)
# Mark all tabs as unloaded
for i in range(10):
self.tabLoaded[i] = False
def warnUSer(self, result, inputWidget):
palette = inputWidget.palette()
if result:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 255, 255))
else:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 136, 138))
inputWidget.setPalette(palette)
inputWidget.update()
def setStat(self, statPath):
self.stat = Stat(path=statPath)
# Global stat update
self.totalTimeLcdNumber.display(self.stat.getTotalTime())
self.numCallLcdNumber.display(self.stat.getCallNumber())
self.primCallLcdNumber.display(self.stat.getPrimitiveCallRatio())
# Refresh current tab
self.on_tabWidget_currentChanged(self.tabWidget.currentIndex())
# Activate save as menu
self.actionSave_profile.setEnabled(True)
try:
self.rating.setMaxRating(10)
self.rating.setRating(
int(self.stat.getPrimitiveCallRatio()) / 10 - 1)
except:
pass
#========================================================================#
# Statistics table #
#=======================================================================#
def populateTable(self):
row = 0
rowCount = self.stat.getStatNumber()
progress = QProgressDialog("Populating statistics table...", "Abort",
0, 2 * rowCount)
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setRowCount(rowCount)
progress.setWindowModality(Qt.WindowModal)
for (key, value) in self.stat.getStatItems():
#ncalls
item = StatTableWidgetItem(str(value[0]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_NCALLS, item)
colorTableItem(item, self.stat.getCallNumber(), value[0])
#total time
item = StatTableWidgetItem(str(value[2]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[2])
#per call (total time)
if value[0] != 0:
tPerCall = str(value[2] / value[0])
cPerCall = str(value[3] / value[0])
else:
tPerCall = ""
cPerCall = ""
item = StatTableWidgetItem(tPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TPERCALL, item)
colorTableItem(
item,
100.0 * self.stat.getTotalTime() / self.stat.getCallNumber(),
tPerCall)
#per call (cumulative time)
item = StatTableWidgetItem(cPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CPERCALL, item)
colorTableItem(
item,
100.0 * self.stat.getTotalTime() / self.stat.getCallNumber(),
cPerCall)
#cumulative time
item = StatTableWidgetItem(str(value[3]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[3])
#Filename
self.tableWidget.setItem(row, STAT_FILENAME,
StatTableWidgetItem(str(key[0])))
#Line
item = StatTableWidgetItem(str(key[1]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_LINE, item)
#Function name
self.tableWidget.setItem(row, STAT_FUNCTION,
StatTableWidgetItem(str(key[2])))
row += 1
# Store it in stat hash array
self.stat.setStatLink(item, key, TAB_FUNCTIONSTAT)
progress.setValue(row)
if progress.wasCanceled():
return
for i in range(self.tableWidget.rowCount()):
progress.setValue(row + i)
for j in range(self.tableWidget.columnCount()):
item = self.tableWidget.item(i, j)
if item:
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setSortingEnabled(True)
self.resizeWidgetToContent(self.tableWidget)
progress.setValue(2 * rowCount)
def on_tableWidget_itemDoubleClicked(self, item):
matchedItems = []
filename = str(self.tableWidget.item(item.row(), STAT_FILENAME).text())
if not filename or filename.startswith("<"):
# No source code associated, return immediatly
return
function = self.tableWidget.item(item.row(), STAT_FUNCTION).text()
line = self.tableWidget.item(item.row(), STAT_LINE).text()
self.on_tabWidget_currentChanged(TAB_SOURCE) # load source tab
function = "%s (%s)" % (function, line)
fathers = self.sourceTreeWidget.findItems(filename, Qt.MatchContains,
SOURCE_FILENAME)
print(("find %s father" % len(fathers)))
for father in fathers:
findItems(father, function, SOURCE_FILENAME, matchedItems)
print(("find %s items" % len(matchedItems)))
if matchedItems:
self.tabWidget.setCurrentIndex(TAB_SOURCE)
self.sourceTreeWidget.scrollToItem(matchedItems[0])
self.on_sourceTreeWidget_itemClicked(matchedItems[0],
SOURCE_FILENAME)
matchedItems[0].setSelected(True)
else:
print("oups, item found but cannot scroll to it !")
#=======================================================================#
# Source explorer #
#=====================================================================#
def populateSource(self):
items = {}
for stat in self.stat.getStatKeys():
source = stat[0]
function = "%s (%s)" % (stat[2], stat[1])
if source in ("", "profile") or source.startswith("<"):
continue
# Create the function child
child = QTreeWidgetItem([function])
# Store it in stat hash array
self.stat.setStatLink(child, stat, TAB_SOURCE)
if source in items:
father = items[source]
else:
# Create the father
father = QTreeWidgetItem([source])
items[source] = father
father.addChild(child)
self.sourceTreeWidget.setSortingEnabled(False)
for value in list(items.values()):
self.sourceTreeWidget.addTopLevelItem(value)
self.sourceTreeWidget.setSortingEnabled(True)
def on_sourceTreeWidget_itemActivated(self, item, column):
self.on_sourceTreeWidget_itemClicked(item, column)
def on_sourceTreeWidget_itemClicked(self, item, column):
line = 0
parent = item.parent()
if QSCI:
doc = self.sourceTextEdit
if parent:
pathz = parent.text(column)
result = match("(.*) \(([0-9]+)\)", item.text(column))
if result:
try:
function = str(result.group(1))
line = int(result.group(2))
except ValueError:
# We got garbage... falling back to line 0
pass
else:
pathz = item.text(column)
pathz = path.abspath(str(pathz))
if self.currentSourcePath != pathz:
# Need to load source
self.currentSourcePath == pathz
try:
if QSCI:
doc.clear()
doc.insert(file(pathz).read())
else:
self.sourceTextEdit.setPlainText(file(pathz).read())
except IOError:
QMessageBox.warning(self, "Error",
"Source file could not be found",
QMessageBox.Ok)
return
if QSCI:
for function, line in [(i[2], i[1])
for i in self.stat.getStatKeys()
if i[0] == pathz]:
# expr, regexp, case sensitive, whole word, wrap, forward
doc.findFirst("def", False, True, True, False, True, line,
0, True)
end, foo = doc.getCursorPosition()
time = self.stat.getStatTotalTime((pathz, line, function))
colorSource(doc, self.stat.getTotalTime(), time, line, end,
self.marker)
if QSCI:
doc.ensureLineVisible(line)
def _performMonitor(self):
"""
Protected method implementing the monitoring action.
This method populates the statusList member variable
with a list of strings giving the status in the first column and the
path relative to the project directory starting with the third column.
The allowed status flags are:
<ul>
<li>"A" path was added but not yet comitted</li>
<li>"M" path has local changes</li>
<li>"O" path was removed</li>
<li>"R" path was deleted and then re-added</li>
<li>"U" path needs an update</li>
<li>"Z" path contains a conflict</li>
<li>" " path is back at normal</li>
</ul>
@return tuple of flag indicating successful operation (boolean) and
a status message in case of non successful operation (QString)
"""
self.shouldUpdate = False
process = QProcess()
args = QStringList()
args.append('status')
if not Preferences.getVCS("MonitorLocalStatus"):
args.append('--show-updates')
args.append('--non-interactive')
args.append('.')
process.setWorkingDirectory(self.projectDir)
process.start('svn', args)
procStarted = process.waitForStarted()
if procStarted:
finished = process.waitForFinished(300000)
if finished and process.exitCode() == 0:
output = \
unicode(process.readAllStandardOutput(), self.__ioEncoding, 'replace')
states = {}
for line in output.splitlines():
if self.rx_status1.exactMatch(line):
flags = str(self.rx_status1.cap(1))
path = self.rx_status1.cap(3).trimmed()
elif self.rx_status2.exactMatch(line):
flags = str(self.rx_status2.cap(1))
path = self.rx_status2.cap(5).trimmed()
else:
continue
if flags[0] in "ACDMR" or \
(flags[0] == " " and flags[-1] == "*"):
if flags[-1] == "*":
status = "U"
else:
status = flags[0]
if status == "C":
status = "Z" # give it highest priority
elif status == "D":
status = "O"
if status == "U":
self.shouldUpdate = True
name = unicode(path)
states[name] = status
try:
if self.reportedStates[name] != status:
self.statusList.append("%s %s" % (status, name))
except KeyError:
self.statusList.append("%s %s" % (status, name))
for name in self.reportedStates.keys():
if name not in states:
self.statusList.append(" %s" % name)
self.reportedStates = states
return True, \
self.trUtf8("Subversion status checked successfully (using svn)")
else:
process.kill()
process.waitForFinished()
return False, QString(process.readAllStandardError())
else:
process.kill()
process.waitForFinished()
return False, self.trUtf8("Could not start the Subversion process.")
class Window(QWidget):
__pyqtSignals__ = ("burningProgress(int)")
__pyqtSignals__ = ("burningFinished()")
__pyqtSignals__ = ("burningStartingIn(int)")
__pyqtSignals__ = ("burningError(int)")
def __init__(self):
QWidget.__init__(self)
self.rawstr3 = r"""(?:^Current:\s)(.*)"""
self.rawstr2 = r"""(?:^.*?)(\d)(?:\sseconds\.$)"""
self.rawstr = r"""(?:^.*Track .*?\d*\D*)(\d{1,})(?:\D*of.*?)(\d{1,})(?:.*?MB written.*$)"""
self.compile_obj = re.compile(self.rawstr, re.MULTILINE)
self.compile_obj_2 = re.compile(self.rawstr2, re.MULTILINE)
self.compile_obj_3 = re.compile(self.rawstr3, re.MULTILINE)
self.process = QProcess()
self.connect(self.process, SIGNAL("readyReadStandardOutput()"), self.readOutput)
self.connect(self.process, SIGNAL("readyReadStandardError()"), self.readErrors)
self.connect(self.process, SIGNAL("finished(int)"), self.resetButtons)
self.connect(self, SIGNAL("burningProgress(int)"), self.readProgress)
self.noError=True
def blankCommand(self):
print "blankCDRW"
b=QString("cdrecord -v dev=1000,0,0 --blank=fast")
a=b.split(" ")
self.process.start(a.first(), a.mid(1))
if self.process.exitCode():
print "exitCode"
self.resetButtons()
return
def startCommand(self, isofile):
print "startCommand"
b=QString("cdrecord -v -pad speed=8 dev=/dev/cdrom "+isofile)
a=b.split(" ")
self.process.start(a.first(), a.mid(1))
if self.process.exitCode():
print "exitCode"
self.resetButtons()
return
def stopCommand(self, i):
self.resetButtons(i)
self.process.terminate()
QTimer.singleShot(5000, self.process, SLOT("kill()"))
def readOutput(self):
a= self.process.readAllStandardOutput().data()
match_obj = self.compile_obj.search(a)
match_obj_2 = self.compile_obj_2.search(a)
match_obj_3 = self.compile_obj_3.search(a)
print a
if match_obj:
all_groups = match_obj.groups()
group_1 = float(match_obj.group(1))
group_2 = float(match_obj.group(2))
g=int(group_1*100.0/group_2)
if group_1:
self.emit(SIGNAL("burningProgress(int)"), g)
if match_obj_2:
group_1 = int(match_obj_2.group(1))
print "group_1: "+str(group_1)
if group_1:
self.emit(SIGNAL("burningStartingIn(int)"), group_1)
if match_obj_3:
group_1 = match_obj_3.group(1)
if group_1 == "none":
print "NO MEDIA"
self.stopCommand(334)
if a=="Re-load disk and hit \<CR\>":
print "Non writable disc"
self.stopCommand()
def readProgress(self, g):
print g
def readErrors(self):
a= self.process.readAllStandardError().data()
print "ERORR: "+a
if a.startswith("cdrecord: Try to load media by hand"):
print "ERROR: Non writable disc"
self.stopCommand(333)
def resetButtons(self, i):
print "resetButtons"
print i
if i==0:
if self.noError:
self.emit(SIGNAL("burningFinished()"))
if i==333:
self.noError=False
self.emit(SIGNAL("burningError(int)"), i)
if i==334:
self.noError=False
self.emit(SIGNAL("burningError(int)"), i)
if i==335:
self.noError=False
self.emit(SIGNAL("burningCanceled(int)"), i)
class GDALLocationInfoMapTool(QgsMapTool):
def __init__(self, canvas):
QgsMapTool.__init__(self, canvas)
self.canvas = canvas
self.cursor = QCursor(QPixmap(":/plugins/AGSInfo/icons/cursor.png"), 1, 1)
def activate(self):
self.canvas.setCursor(self.cursor)
def parseJSON(self, jsonLocationInfo):
if jsonLocationInfo.has_key("error"):
err_msg = ""
err_msg += "Error code: " + str(jsonLocationInfo["error"]["code"]) + "\n"
err_msg += "Error message: \n" + jsonLocationInfo["error"]["message"] + "\n"
QMessageBox.warning(self.canvas,
self.tr("Error"),
str(err_msg)
)
else:
results = jsonLocationInfo["results"]
if (len(results) == 0):
QMessageBox.warning(self.canvas,
self.tr("Warning"),
self.tr("Not found any objects")
)
return
#locationInfoPure = ""
locationInfoPure = {}
#i = 1
for result in results:
attrs = {}
#locationInfoPure += str(i) + ".\n"
#locationInfoPure += "\tlayerName: " + result["layerName"] + "\n"
#locationInfoPure += "\tvalue: " + result["value"] + "\n"
#locationInfoPure += "\tattributes: " + str(result["attributes"]) + "\n"
#i += 1
attrs.update({"layerName": result["layerName"]})
attrs.update({"Shape": result["attributes"]["Shape"]})
attrs.update({"DESCRIPTION": result["attributes"]["DESCRIPTION"]})
locationInfoPure.update({result["attributes"]["OBJECTID"]: attrs})
#QMessageBox.information(self.canvas,
# self.tr("Info"),
# locationInfoPure
# )
self.a = GDALLocationInfoForm(locationInfoPure)
self.a.show()
def parseXML(self, xmlLocationInfo):
#locationInfoPure = u""
locationInfoPure = {}
#i = 1
for child in xmlLocationInfo:
attrs = {}
#locationInfoPure += u"" + str(i) + u".\n"
#locationInfoPure += u"\t" + string.join([string.join( (k, str(child.attrib[k])), ":") for k in child.attrib.keys() ],",") + u".\n"
#locationInfoPure += string.join([ string.join( (k, child.attrib[k]), ":") for k in child.attrib.keys() ],"\n") + u".\n"
#i += 1
for k in child.attrib.keys():
attrs.update({k: child.attrib[k]})
locationInfoPure.update({child.attrib["OBJECTID"]: attrs})
#QMessageBox.information(self.canvas,
# self.tr("Info"),
# locationInfoPure
# )
self.a = GDALLocationInfoForm(locationInfoPure)
self.a.show()
def canvasReleaseEvent(self, event):
#self.a = GDALLocationInfoForm({"a":{"asd1":"xcvsdfvss", "asd2":"xcvsdfvss", "asd3":"xcvsdfvss"}, "b":{"asd1":"xcvsdfvss", "asd2":"xcvsdfvss", "asd3":"xcvsdfvss"}})
#self.a.show()
currentlayer = self.canvas.currentLayer()
if currentlayer is None:
QMessageBox.warning(self.canvas,
self.tr("No active layer"),
self.tr("To identify features, you must choose an active layer by clicking on its name in the legend")
)
return
if currentlayer.type() != QgsMapLayer.RasterLayer:
QMessageBox.warning(self.canvas,
self.tr("Wrong layer type"),
self.tr("This tool works only for vector layers. Please select another layer in legend and try again")
)
return
self.canvas.setCursor(Qt.WaitCursor)
point = self.canvas.getCoordinateTransform().toMapCoordinates(event.x(), event.y())
self.process = QProcess(self)
GdalTools_utils.setProcessEnvironment(self.process)
self.process.start("gdallocationinfo", ["-xml","-b", "1" ,"-geoloc", currentlayer.source(), str(point[0]), str(point[1])], QIODevice.ReadOnly)
self.process.waitForFinished()
self.canvas.setCursor(self.cursor)
if(self.process.exitCode() != 0):
err_msg = str(self.process.readAllStandardError())
if err_msg != '':
QMessageBox.warning(self.canvas,
self.tr("Error"),
err_msg
)
else:
QMessageBox.warning(self.canvas,
self.tr("Error"),
str(self.process.readAllStandardOutput())
)
else:
data = str(self.process.readAllStandardOutput());
root = ET.fromstring(data)
alert_node = root.find('Alert')
if (alert_node != None):
QMessageBox.warning(self.canvas,
self.tr("Warning"),
alert_node.text
)
return
location_info_node = root.find('BandReport').find('LocationInfo')
try:
jsonLocationInfo = json.JSONDecoder().decode(location_info_node.text.encode("utf-8"))
self.parseJSON(jsonLocationInfo)
return
except ValueError as err:
print "json parse error"
pass
try:
data = location_info_node.text.encode("utf-8")
#data.decode("cp1251").encode("utf-8")
xmlLocationInfo = ET.fromstring(data)
self.parseXML(xmlLocationInfo)
return
except ValueError as err:
print "xml parse error: ", err
pass
def run_process(fused_command, read_output=False):
# print "run process", fused_command
# qprocess = QProcess()
# set_process_env(qprocess)
# code_de_retour = qprocess.execute(fused_command)
# print "code de retour", code_de_retour
# logger.info("command: ")
# logger.info(fused_command)
# logger.info("code de retour" + str(code_de_retour))
#
# # if not qprocess.waitForStarted():
# # # handle a failed command here
# # print "qprocess.waitForStarted()"
# # return
# #
# # if not qprocess.waitForReadyRead():
# # # handle a timeout or error here
# # print "qprocess.waitForReadyRead()"
# # return
# # #if not qprocess.waitForFinished(1):
# # # qprocess.kill()
# # # qprocess.waitForFinished(1)
#
# # if read_output:
#
# # logger.info("Erreur")
# code_d_erreur = qprocess.error()
# dic_err = { 0:"QProcess::FailedToStart", 1:"QProcess::Crashed", 2:"QProcess::TimedOut", 3:"QProcess::WriteError", 4:"QProcess::ReadError", 5:"QProcess::UnknownError" }
# logger.info("Code de retour: " + str(code_d_erreur))
# logger.info(dic_err[code_d_erreur])
#
# print "get output"
# output = str(qprocess.readAllStandardOutput())
# # print "output", output
# print 'end output'
process = QProcess()
process.start(fused_command)
if process.waitForStarted():
process.waitForFinished(-1)
exit_code = process.exitCode()
logger.info("Code de sortie : " + str(exit_code))
if exit_code < 0:
code_d_erreur = process.error().data
dic_err = {
0: "QProcess::FailedToStart",
1: "QProcess::Crashed",
2: "QProcess::TimedOut",
3: "QProcess::WriteError",
4: "QProcess::ReadError",
5: "QProcess::UnknownError"
}
logger.info("Code erreur : " + str(code_d_erreur))
logger.info(dic_err[code_d_erreur])
result = process.readAllStandardOutput()
# print type(result), result
error = process.readAllStandardError().data()
# print repr(error)
if not error == "\n":
logger.info("error : " + "\'" + str(error) + "\'")
logger.info("output : " + result.data() + "fin output")
return result
else:
code_d_erreur = process.error()
dic_err = {
0: "QProcess::FailedToStart",
1: "QProcess::Crashed",
2: "QProcess::TimedOut",
3: "QProcess::WriteError",
4: "QProcess::ReadError",
5: "QProcess::UnknownError"
}
logger.info("Code erreur : " + str(code_d_erreur))
logger.info(dic_err[code_d_erreur])
return None
def run_process(fused_command, read_output = False):
# print "run process", fused_command
# qprocess = QProcess()
# set_process_env(qprocess)
# code_de_retour = qprocess.execute(fused_command)
# print "code de retour", code_de_retour
# logger.info("command: ")
# logger.info(fused_command)
# logger.info("code de retour" + str(code_de_retour))
#
# # if not qprocess.waitForStarted():
# # # handle a failed command here
# # print "qprocess.waitForStarted()"
# # return
# #
# # if not qprocess.waitForReadyRead():
# # # handle a timeout or error here
# # print "qprocess.waitForReadyRead()"
# # return
# # #if not qprocess.waitForFinished(1):
# # # qprocess.kill()
# # # qprocess.waitForFinished(1)
#
# # if read_output:
#
# # logger.info("Erreur")
# code_d_erreur = qprocess.error()
# dic_err = { 0:"QProcess::FailedToStart", 1:"QProcess::Crashed", 2:"QProcess::TimedOut", 3:"QProcess::WriteError", 4:"QProcess::ReadError", 5:"QProcess::UnknownError" }
# logger.info("Code de retour: " + str(code_d_erreur))
# logger.info(dic_err[code_d_erreur])
#
# print "get output"
# output = str(qprocess.readAllStandardOutput())
# # print "output", output
# print 'end output'
process = QProcess()
process.start(fused_command)
if process.waitForStarted():
process.waitForFinished(-1)
exit_code = process.exitCode()
logger.info("Code de sortie : " + str(exit_code))
if exit_code < 0:
code_d_erreur = process.error().data
dic_err = { 0:"QProcess::FailedToStart", 1:"QProcess::Crashed", 2:"QProcess::TimedOut", 3:"QProcess::WriteError", 4:"QProcess::ReadError", 5:"QProcess::UnknownError" }
logger.info("Code erreur : " + str(code_d_erreur))
logger.info(dic_err[code_d_erreur])
result = process.readAllStandardOutput()
# print type(result), result
error = process.readAllStandardError().data()
# print repr(error)
if not error == "\n":
logger.info("error : " + "\'" + str(error) + "\'")
logger.info("output : " + result.data() + "fin output")
return result
else:
code_d_erreur = process.error()
dic_err = { 0:"QProcess::FailedToStart", 1:"QProcess::Crashed", 2:"QProcess::TimedOut", 3:"QProcess::WriteError", 4:"QProcess::ReadError", 5:"QProcess::UnknownError" }
logger.info("Code erreur : " + str(code_d_erreur))
logger.info(dic_err[code_d_erreur])
return None
class Window(mainwindow, ui_mainwindow):
def __init__(self):
QMainWindow.__init__(self)
self.setWindowIcon(QIcon(":/scanner.png"))
QIcon.setThemeName("Adwaita")
self.setupUi(self)
close_icon = QApplication.style().standardIcon(QStyle.SP_DialogCloseButton)
self.closeBtn.setIcon(close_icon)
# connect signals
self.comboDevice.currentIndexChanged.connect(self.onDeviceChange)
self.comboColor.currentIndexChanged.connect(self.onColorModeChange)
self.scanBtn.clicked.connect(self.startScanning)
self.closeBtn.clicked.connect(self.close)
self.process = QProcess(self)
QTimer.singleShot(100, self.updateDeviceList)
def updateDeviceList(self):
self.devices_info = get_devices()
if len(self.devices_info)>0:
self.comboDevice.clear()
models = [ dev['model'] for dev in self.devices_info]
self.comboDevice.addItems(models)
self.selectDevice(0)
def selectDevice(self, index):
self.scanner = get_backend_from_scanner_device(self.devices_info[index])
self.comboColor.clear()
self.comboResolution.clear()
self.comboArea.clear()
self.comboColor.addItems(self.scanner.supportedColorModes())
self.comboResolution.addItems(self.scanner.supportedResolutions())
self.comboArea.addItems(self.scanner.supportedScanAreas())
# Init values
self.comboColor.setCurrentIndex(self.scanner.default_color_index)
self.comboResolution.setCurrentIndex(self.scanner.default_resolution_index)
self.comboArea.setCurrentIndex(self.scanner.default_scan_area_index)
self.labelExt.setText(self.scanner.extension)
self.filenameEdit.setText(self.newFileName())
def onDeviceChange(self, index):
self.selectDevice(index)
def onColorModeChange(self, index):
""" Change file format on colormode change """
self.scanner.setSelectedColor(index)
self.labelExt.setText(self.scanner.extension)
self.filenameEdit.setText(self.newFileName())
def startScanning(self):
if self.comboDevice.count()==0:
return
self.scanner.setSelectedColor(self.comboColor.currentIndex())
self.scanner.setSelectedResolution(self.comboResolution.currentIndex())
self.scanner.setSelectedScanArea(self.comboArea.currentIndex())
ext = self.scanner.extension
args = self.scanner.getArgs()
self.statusbar.showMessage("Scan Started")
wait(20)
self.process.start('scanimage', args)
if not self.process.waitForFinished(-1) or self.process.exitCode():
self.statusbar.showMessage("Scanning Failed !")
return
data = self.process.readAllStandardOutput()
filename = self.filenameEdit.text() + ext
# to get more accurate scanned area when A4 at 300 dpi
if (self.scanner.crop_needed):
image = QImage.fromData(data)
image = image.copy(self.scanner.crop_rect)
image.save(filename)
else:
img_file = QFile(filename, self)
img_file.open(QIODevice.WriteOnly)
img_file.write(data)
img_file.close()
data.clear()
self.statusbar.showMessage("Scan Completed Successfully")
self.filenameEdit.setText(self.newFileName())
def newFileName(self):
ext = self.scanner.extension
index = 1
while True:
filename = "Scan%3i" % index
filename = filename.replace(" ", "0")
if os.path.exists(filename + ext):
index +=1
else:
break
return filename
class TerreImageProcess():
def __init__(self):
self.process = QProcess()
self.process.error[QProcess.ProcessError].connect(self.error_management)
self.env = QProcessEnvironment().systemEnvironment()
self.set_otb_process_env_default()
self.command = ""
def run_process(self, command):
logger.info(u"Running {}".format(command))
self.process.setProcessEnvironment(self.env)
# logger.debug("..............{}".format(self.process.processEnvironment().value("OTB_APPLICATION_PATH")))
# logger.debug("..............{}".format(self.process.processEnvironment().value("PATH")))
# logger.debug("Environ : PATH {}".format(os.environ["PATH"]))
# logger.debug("Environ : OTB_APPLICATION_PATH {}".format(os.environ.get("OTB_APPLICATION_PATH", "Empty")))
self.command = command
self.process.start(command)
if self.process.waitForStarted():
self.process.waitForFinished(-1)
exit_code = self.process.exitCode()
if exit_code != 0:
self.error_management(exit_code)
result = self.process.readAllStandardOutput()
# logger.debug(" {} {}".format(type(result), result))
error = self.process.readAllStandardError().data()
# logger.debug(repr(error))
if not error in ["\n", ""]:
logger.error("error : %s"%(error))
output = result.data()
logger.info(output)
return result
else:
code_d_erreur = self.process.error()
self.error_management(code_d_erreur)
return None
def error_management(self, errorCode):
dic_err = { 0:"QProcess::FailedToStart", 1:"QProcess::Crashed",
2:"QProcess::TimedOut", 3:"QProcess::WriteError",
4:"QProcess::ReadError", 5:"QProcess::UnknownError",
127:"Other, The application may not have been found"}
try:
type_qt_error = dic_err[errorCode]
logger.error(u"Error {} {}".format(errorCode, type_qt_error))
except KeyError:
type_qt_error = ""
error = self.process.readAllStandardError().data()
logger.error(error)
logger.error( self.process.readAllStandardOutput())
try:
raise terre_image_exceptions.TerreImageRunProcessError(u"Error running : {}\n {}{}".format(self.command,
type_qt_error, error
))
except UnicodeError:
raise terre_image_exceptions.TerreImageRunProcessError(u"Error running : {}\n {}".format(self.command,
type_qt_error))
def set_env_var(self, varname, varval, append = False, pre = False):
if append == True:
if pre == False:
# insert value at the end of the variable
self.env.insert(varname, self.env.value(varname) + os.pathsep + varval)
else:
# insert value in head
self.env.insert(varname, varval + os.pathsep + self.env.value(varname))
else:
# replace value if existing
self.env.insert(varname, varval)
# logger.debug("env {} {}".format(varname, self.env.value(varname)))
def set_otb_process_env(self):
dirname = os.path.dirname(os.path.abspath(__file__))
self.set_env_var("OTB_APPLICATION_PATH", os.path.join(dirname, "win32", "plugin"), pre=True)
self.set_env_var("PATH", os.path.join(dirname, "win32", "bin"), append = False, pre=True)
def set_otb_process_env_custom(self, otb_app_path="", path=""):
"""
Add the given values to OTB_APPLICATION_PATH and PATH environement variables
Args:
otb_app_path:
path:
Returns:
"""
self.set_env_var("OTB_APPLICATION_PATH", otb_app_path, pre=True)
self.set_env_var("PATH", path, append = False, pre=True)
def set_otb_process_env_default(self):
"""
Add the values from the config file to OTB_APPLICATION_PATH and PATH environement variables
Args:
otb_app_path:
path:
Returns:
"""
self.set_env_var("OTB_APPLICATION_PATH",
terre_image_configuration.OTB_APPLICATION_PATH, pre=True)
self.set_env_var("PATH", terre_image_configuration.PATH, append = True, pre=True)
if terre_image_configuration.LD_LIBRARY_PATH:
self.set_env_var("LD_LIBRARY_PATH", terre_image_configuration.LD_LIBRARY_PATH, append = True, pre=True)
class TerreImageProcess():
def __init__(self):
self.process = QProcess()
self.process.error[QProcess.ProcessError].connect(
self.error_management)
self.env = QProcessEnvironment().systemEnvironment()
self.set_otb_process_env_default()
self.command = ""
def run_process(self, command):
logger.info(u"Running {}".format(command))
self.process.setProcessEnvironment(self.env)
# logger.debug("..............{}".format(self.process.processEnvironment().value("OTB_APPLICATION_PATH")))
# logger.debug("..............{}".format(self.process.processEnvironment().value("PATH")))
# logger.debug("Environ : PATH {}".format(os.environ["PATH"]))
# logger.debug("Environ : OTB_APPLICATION_PATH {}".format(os.environ.get("OTB_APPLICATION_PATH", "Empty")))
self.command = command
self.process.start(command)
if self.process.waitForStarted():
self.process.waitForFinished(-1)
exit_code = self.process.exitCode()
if exit_code != 0:
self.error_management(exit_code)
result = self.process.readAllStandardOutput()
# logger.debug(" {} {}".format(type(result), result))
error = self.process.readAllStandardError().data()
# logger.debug(repr(error))
if not error in ["\n", ""]:
logger.error("error : %s" % (error))
output = result.data()
logger.info(output)
return result
else:
code_d_erreur = self.process.error()
self.error_management(code_d_erreur)
return None
def error_management(self, errorCode):
dic_err = {
0: "QProcess::FailedToStart",
1: "QProcess::Crashed",
2: "QProcess::TimedOut",
3: "QProcess::WriteError",
4: "QProcess::ReadError",
5: "QProcess::UnknownError",
127: "Other, The application may not have been found"
}
try:
type_qt_error = dic_err[errorCode]
logger.error(u"Error {} {}".format(errorCode, type_qt_error))
except KeyError:
type_qt_error = ""
error = self.process.readAllStandardError().data()
logger.error(error)
logger.error(self.process.readAllStandardOutput())
try:
raise terre_image_exceptions.TerreImageRunProcessError(
u"Error running : {}\n {}{}".format(self.command,
type_qt_error, error))
except UnicodeError:
raise terre_image_exceptions.TerreImageRunProcessError(
u"Error running : {}\n {}".format(self.command, type_qt_error))
def set_env_var(self, varname, varval, append=False, pre=False):
if append == True:
if pre == False:
# insert value at the end of the variable
self.env.insert(varname,
self.env.value(varname) + os.pathsep + varval)
else:
# insert value in head
self.env.insert(varname,
varval + os.pathsep + self.env.value(varname))
else:
# replace value if existing
self.env.insert(varname, varval)
# logger.debug("env {} {}".format(varname, self.env.value(varname)))
def set_otb_process_env(self):
dirname = os.path.dirname(os.path.abspath(__file__))
self.set_env_var("OTB_APPLICATION_PATH",
os.path.join(dirname, "win32", "plugin"),
pre=True)
self.set_env_var("PATH",
os.path.join(dirname, "win32", "bin"),
append=False,
pre=True)
def set_otb_process_env_custom(self, otb_app_path="", path=""):
"""
Add the given values to OTB_APPLICATION_PATH and PATH environement variables
Args:
otb_app_path:
path:
Returns:
"""
self.set_env_var("OTB_APPLICATION_PATH", otb_app_path, pre=True)
self.set_env_var("PATH", path, append=False, pre=True)
def set_otb_process_env_default(self):
"""
Add the values from the config file to OTB_APPLICATION_PATH and PATH environement variables
Args:
otb_app_path:
path:
Returns:
"""
self.set_env_var("OTB_APPLICATION_PATH",
terre_image_configuration.OTB_APPLICATION_PATH,
pre=True)
self.set_env_var("PATH",
terre_image_configuration.PATH,
append=True,
pre=True)
if terre_image_configuration.LD_LIBRARY_PATH:
self.set_env_var("LD_LIBRARY_PATH",
terre_image_configuration.LD_LIBRARY_PATH,
append=True,
pre=True)
class Window(QWidget):
def __init__(self):
QWidget.__init__(self)
self.rawstr = r"""(?:^.*Track .*?\d*\D*)(\d{1,})(?:\D*of.*?)(\d{1,})(?:.*?MB written.*$)"""
self.compile_obj = re.compile(self.rawstr, re.MULTILINE)
self.textBrowser = QTextBrowser(self)
self.lineEdit = QLineEdit(self)
self.startButton = QPushButton(self.tr("Start"), self)
self.stopButton = QPushButton(self.tr("Stop"), self)
self.stopButton.setEnabled(False)
self.list1 = QStringList()
self.connect(self.lineEdit, SIGNAL("returnPressed()"), self.startCommand)
self.connect(self.startButton, SIGNAL("clicked()"), self.startCommand)
self.connect(self.stopButton, SIGNAL("clicked()"), self.stopCommand)
layout = QGridLayout(self)
layout.setSpacing(8)
layout.addWidget(self.textBrowser, 0, 0)
layout.addWidget(self.lineEdit, 1, 0)
layout.addWidget(self.startButton, 1, 1)
layout.addWidget(self.stopButton, 1, 2)
self.process = QProcess()
self.connect(self.process, SIGNAL("readyReadStandardOutput()"), self.readOutput)
self.connect(self.process, SIGNAL("readyReadStandardError()"), self.readErrors)
self.connect(self.process, SIGNAL("finished(int)"), self.resetButtons)
def startCommand(self):
a=self.lineEdit.text().split(" ")
self.process.start(a.first(), a.mid(1))
self.startButton.setEnabled(False)
self.stopButton.setEnabled(True)
self.textBrowser.clear()
if self.process.exitCode():
self.textBrowser.setText(
QString("*** Failed to run %1 ***").arg(self.lineEdit.text())
)
self.resetButtons()
return
def stopCommand(self):
self.resetButtons()
self.process.terminate()
QTimer.singleShot(5000, self.process, SLOT("kill()"))
def readOutput(self):
a= self.process.readAllStandardOutput().data()
match_obj = self.compile_obj.search(a)
if match_obj:
all_groups = match_obj.groups()
group_1 = float(match_obj.group(1))
group_2 = float(match_obj.group(2))
g=int(group_1*100.0/group_2)
if group_1:
self.textBrowser.append(QString(str(g)))
def readErrors(self):
a= self.process.readAllStandardError().data()
self.textBrowser.append("error: " + QString(a))
def resetButtons(self, i):
self.startButton.setEnabled(True)
self.stopButton.setEnabled(False)
def interpret(self, command):
"""Interprets command
Returns turple (output, exitCode)
"""
print '~~~~~~~~~ interpret'
ec = pConsoleCommand.NotFound
output, ec = pConsoleCommand.interpret( command)
parts = self.parseCommands( command )
if parts:
cmd = parts.takeFirst()
else:
cmd = ''
if ec != pConsoleCommand.NotFound : # nothing to do
pass
elif cmd == "ls" :
if sys.platform.startswith('win'):
cmd = "dir %s" % \
" ".join(pConsoleCommand.quotedStringList(parts)).trim()
else:
cmd = "dir %s" % " ".join( \
pConsoleCommand.quotedStringList(parts)).trimmed()
process = QProcess()
process.setProcessChannelMode( QProcess.MergedChannels )
process.start( cmd )
process.waitForStarted()
process.waitForFinished()
output = process.readAll().trimmed()
ec = process.exitCode()
elif cmd == "echo" :
if parts:
output = "\n".join(parts)
ec = pConsoleCommand.Error
else:
output = pConsole.tr(console, "No argument given" )
ec = pConsoleCommand.Success
elif cmd == "quit":
output = pConsole.tr(console, "Quitting the application..." )
ec = pConsoleCommand.Success
QTimer.singleShot(1000, qApp.quit() )
elif cmd == "style" :
if parts.count() != 1 :
output = pConsole.tr(console, "%s take only 1 parameter, %d given" %
(cmd, len(parts)) )
ec = pConsoleCommand.Error
elif parts[-1] == "list" :
output = pConsole.tr(console, "Available styles:\n%s" %
'\n'.join(QStyleFactory.keys()) )
ec = pConsoleCommand.Success
else:
styleExists = parts[-1].lower() in \
[key.lower() for key in QStyleFactory.keys()]
if styleExists:
output = pConsole.tr(console, "Setting style to %s..." % parts[-1])
self.mMainWindow.setCurrentStyle( parts[-1] )
ec = pConsoleCommand.Success
else:
output = pConsole.tr(console, "This style does not exists" )
ec = pConsoleCommand.Error
return (output, ec)
def newProject(path):
initProcess=QProcess(None)
initProcess.setWorkingDirectory(path)
initProcess.start("ino",['init'])
initProcess.waitForFinished()
return initProcess.exitCode()==0
class Main(plugin.Plugin):
" Main Class "
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.scriptPath, self.scriptArgs = "", []
self.profilerPath, self.tempPath = profilerPath, tempPath
self.output = " ERROR: FAIL: No output ! "
self.process = QProcess()
self.process.finished.connect(self.on_process_finished)
self.process.error.connect(self.on_process_error)
self.tabWidget, self.stat = QTabWidget(), QWidget()
self.tabWidget.tabCloseRequested.connect(lambda:
self.tabWidget.setTabPosition(1)
if self.tabWidget.tabPosition() == 0
else self.tabWidget.setTabPosition(0))
self.tabWidget.setStyleSheet('QTabBar{font-weight:bold;}')
self.tabWidget.setMovable(True)
self.tabWidget.setTabsClosable(True)
self.vboxlayout1 = QVBoxLayout(self.stat)
self.hboxlayout1 = QHBoxLayout()
self.filterTableLabel = QLabel("<b>Type to Search : </b>", self.stat)
self.hboxlayout1.addWidget(self.filterTableLabel)
self.filterTableLineEdit = QLineEdit(self.stat)
self.filterTableLineEdit.setPlaceholderText(' Type to Search . . . ')
self.hboxlayout1.addWidget(self.filterTableLineEdit)
self.filterHintTableLabel = QLabel(" ? ", self.stat)
self.hboxlayout1.addWidget(self.filterHintTableLabel)
self.vboxlayout1.addLayout(self.hboxlayout1)
self.tableWidget = QTableWidget(self.stat)
self.tableWidget.setAlternatingRowColors(True)
self.tableWidget.setColumnCount(8)
self.tableWidget.setRowCount(2)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(4, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(5, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(6, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(7, item)
self.tableWidget.itemDoubleClicked.connect(
self.on_tableWidget_itemDoubleClicked)
self.vboxlayout1.addWidget(self.tableWidget)
self.tabWidget.addTab(self.stat, " ? ")
self.source = QWidget()
self.gridlayout = QGridLayout(self.source)
self.scintillaWarningLabel = QLabel(
"QScintilla is not installed!. Falling back to basic text edit!.",
self.source)
self.gridlayout.addWidget(self.scintillaWarningLabel, 1, 0, 1, 2)
self.sourceTreeWidget = QTreeWidget(self.source)
self.sourceTreeWidget.setAlternatingRowColors(True)
self.sourceTreeWidget.itemActivated.connect(
self.on_sourceTreeWidget_itemActivated)
self.sourceTreeWidget.itemClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.sourceTreeWidget.itemDoubleClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.gridlayout.addWidget(self.sourceTreeWidget, 0, 0, 1, 1)
self.sourceTextEdit = QTextEdit(self.source)
self.sourceTextEdit.setReadOnly(True)
self.gridlayout.addWidget(self.sourceTextEdit, 0, 1, 1, 1)
self.tabWidget.addTab(self.source, " ? ")
self.result = QWidget()
self.vlayout = QVBoxLayout(self.result)
self.globalStatGroupBox = QGroupBox(self.result)
self.hboxlayout = QHBoxLayout(self.globalStatGroupBox)
self.totalTimeLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.totalTimeLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.totalTimeLcdNumber.setNumDigits(7)
self.totalTimeLcdNumber.display(1000000)
self.totalTimeLcdNumber.setFrameShape(QFrame.StyledPanel)
self.totalTimeLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.totalTimeLcdNumber)
self.tTimeLabel = QLabel("<b>Total Time (Sec)</b>",
self.globalStatGroupBox)
self.tTimeLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.tTimeLabel)
self.numCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.numCallLcdNumber.setNumDigits(7)
self.numCallLcdNumber.display(1000000)
self.numCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.numCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.numCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.numCallLcdNumber)
self.numCallLabel = QLabel("<b>Number of calls</b>",
self.globalStatGroupBox)
self.numCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.numCallLabel)
self.primCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.primCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.primCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.primCallLcdNumber.setNumDigits(7)
self.primCallLcdNumber.display(1000000)
self.primCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.primCallLcdNumber)
self.primCallLabel = QLabel("<b>Primitive calls (%)</b>",
self.globalStatGroupBox)
self.primCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.primCallLabel)
self.vlayout.addWidget(self.globalStatGroupBox)
try:
from PyKDE4.kdeui import KRatingWidget
self.rating = KRatingWidget(self.globalStatGroupBox)
self.rating.setToolTip('Profiling Performance Rating')
except ImportError:
pass
self.tabWidget.addTab(self.result, " Get Results ! ")
self.resgraph = QWidget()
self.vlayout2 = QVBoxLayout(self.result)
self.graphz = QGroupBox(self.resgraph)
self.hboxlayout2 = QHBoxLayout(self.graphz)
try:
from PyKDE4.kdeui import KLed
KLed(self.graphz)
except ImportError:
pass
self.hboxlayout2.addWidget(QLabel('''
Work in Progress :) Not Ready Yet'''))
self.vlayout2.addWidget(self.graphz)
self.tabWidget.addTab(self.resgraph, " Graphs and Charts ")
self.pathz = QWidget()
self.vlayout3 = QVBoxLayout(self.pathz)
self.patz = QGroupBox(self.pathz)
self.hboxlayout3 = QVBoxLayout(self.patz)
self.profilepath = QLineEdit(profilerPath)
self.getprofile = QPushButton(QIcon.fromTheme("document-open"), 'Open')
self.getprofile.setToolTip('Dont touch if you dont know what are doing')
self.getprofile.clicked.connect(lambda: self.profilepath.setText(str(
QFileDialog.getOpenFileName(self.patz, ' Open the profile.py file ',
path.expanduser("~"), ';;(profile.py)'))))
self.hboxlayout3.addWidget(QLabel(
'<center><b>Profile.py Python Library Full Path:</b></center>'))
self.hboxlayout3.addWidget(self.profilepath)
self.hboxlayout3.addWidget(self.getprofile)
self.argGroupBox = QGroupBox(self.pathz)
self.hbxlayout = QHBoxLayout(self.argGroupBox)
self.argLineEdit = QLineEdit(self.argGroupBox)
self.argLineEdit.setToolTip('Not touch if you dont know what are doing')
self.argLineEdit.setPlaceholderText(
'Dont touch if you dont know what are doing')
self.hbxlayout.addWidget(QLabel('<b>Additional Profile Arguments:</b>'))
self.hbxlayout.addWidget(self.argLineEdit)
self.hboxlayout3.addWidget(self.argGroupBox)
self.vlayout3.addWidget(self.patz)
self.tabWidget.addTab(self.pathz, " Paths and Configs ")
self.outp = QWidget()
self.vlayout4 = QVBoxLayout(self.outp)
self.outgro = QGroupBox(self.outp)
self.outgro.setTitle(" MultiProcessing Output Logs ")
self.hboxlayout4 = QVBoxLayout(self.outgro)
self.outputlog = QTextEdit()
self.outputlog.setText('''
I do not fear computers, I fear the lack of them. -Isaac Asimov ''')
self.hboxlayout4.addWidget(self.outputlog)
self.vlayout4.addWidget(self.outgro)
self.tabWidget.addTab(self.outp, " Logs ")
self.actionNew_profiling = QAction(QIcon.fromTheme("document-new"),
'New Profiling', self)
self.actionLoad_profile = QAction(QIcon.fromTheme("document-open"),
'Open Profiling', self)
self.actionClean = QAction(QIcon.fromTheme("edit-clear"), 'Clean', self)
self.actionClean.triggered.connect(lambda: self.clearContent)
self.actionAbout = QAction(QIcon.fromTheme("help-about"), 'About', self)
self.actionAbout.triggered.connect(lambda: QMessageBox.about(self.dock,
__doc__, ', '.join((__doc__, __license__, __author__, __email__))))
self.actionSave_profile = QAction(QIcon.fromTheme("document-save"),
'Save Profiling', self)
self.actionManual = QAction(QIcon.fromTheme("help-contents"),
'Help', self)
self.actionManual.triggered.connect(lambda:
open_new_tab('http://docs.python.org/library/profile.html'))
self.tabWidget.setCurrentIndex(2)
self.globalStatGroupBox.setTitle("Global Statistics")
item = self.tableWidget.horizontalHeaderItem(0)
item.setText("Number of Calls")
item = self.tableWidget.horizontalHeaderItem(1)
item.setText("Total Time")
item = self.tableWidget.horizontalHeaderItem(2)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(3)
item.setText("Cumulative Time")
item = self.tableWidget.horizontalHeaderItem(4)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(5)
item.setText("Filename")
item = self.tableWidget.horizontalHeaderItem(6)
item.setText("Line")
item = self.tableWidget.horizontalHeaderItem(7)
item.setText("Function")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.stat),
"Statistics per Function")
self.sourceTreeWidget.headerItem().setText(0, "Source files")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.source),
"Sources Navigator")
#######################################################################
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(self.tabWidget)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
QToolBar(self.dock).addActions((self.actionNew_profiling,
self.actionClean, self.actionSave_profile, self.actionLoad_profile,
self.actionManual, self.actionAbout))
self.actionNew_profiling.triggered.connect(
self.on_actionNew_profiling_triggered)
self.actionLoad_profile.triggered.connect(
self.on_actionLoad_profile_triggered)
self.actionSave_profile.triggered.connect(
self.on_actionSave_profile_triggered)
self.locator.get_service('misc').add_widget(self.dock,
QIcon.fromTheme("document-open-recent"), __doc__)
if QSCI:
# Scintilla source editor management
self.scintillaWarningLabel.setText(' QScintilla is Ready ! ')
layout = self.source.layout()
layout.removeWidget(self.sourceTextEdit)
self.sourceTextEdit = Qsci.QsciScintilla(self.source)
layout.addWidget(self.sourceTextEdit, 0, 1)
doc = self.sourceTextEdit
doc.setLexer(Qsci.QsciLexerPython(self.sourceTextEdit))
doc.setReadOnly(True)
doc.setEdgeMode(Qsci.QsciScintilla.EdgeLine)
doc.setEdgeColumn(80)
doc.setEdgeColor(QColor("#FF0000"))
doc.setFolding(Qsci.QsciScintilla.BoxedTreeFoldStyle)
doc.setBraceMatching(Qsci.QsciScintilla.SloppyBraceMatch)
doc.setCaretLineVisible(True)
doc.setMarginLineNumbers(1, True)
doc.setMarginWidth(1, 25)
doc.setTabWidth(4)
doc.setEolMode(Qsci.QsciScintilla.EolUnix)
self.marker = {}
for color in COLORS:
mnr = doc.markerDefine(Qsci.QsciScintilla.Background)
doc.setMarkerBackgroundColor(color, mnr)
self.marker[color] = mnr
self.currentSourcePath = None
# Connect table and tree filter edit signal to unique slot
self.filterTableLineEdit.textEdited.connect(
self.on_filterLineEdit_textEdited)
# Timer to display filter hint message
self.filterHintTimer = QTimer(self)
self.filterHintTimer.setSingleShot(True)
self.filterHintTimer.timeout.connect(self.on_filterHintTimer_timeout)
# Timer to start search
self.filterSearchTimer = QTimer(self)
self.filterSearchTimer.setSingleShot(True)
self.filterSearchTimer.timeout.connect(
self.on_filterSearchTimer_timeout)
self.tabLoaded = {}
for i in range(10):
self.tabLoaded[i] = False
self.backgroundTreeMatchedItems = {}
self.resizeWidgetToContent(self.tableWidget)
def on_actionNew_profiling_triggered(self):
self.clearContent()
self.scriptPath = str(QFileDialog.getOpenFileName(self.dock,
"Choose your script to profile", path.expanduser("~"),
"Python (*.py *.pyw)"))
commandLine = [self.profilerPath, "-o", self.tempPath,
self.scriptPath] + self.scriptArgs
commandLine = " ".join(commandLine)
##if self.termCheckBox.checkState() == Qt.Checked:
#termList = ["xterm", "aterm"]
#for term in termList:
#termPath = which(term)
#if termPath:
#break
#commandLine = """%s -e "%s ; echo 'Press ENTER Exit' ; read" """ \
#% (termPath, commandLine)
self.process.start(commandLine)
if not self.process.waitForStarted():
print((" ERROR: {} failed!".format(commandLine)))
return
def on_process_finished(self, exitStatus):
' whan the process end '
print((" INFO: OK: QProcess is %s" % self.process.exitCode()))
self.output = self.process.readAll().data()
if not self.output:
self.output = " ERROR: FAIL: No output ! "
self.outputlog.setText(self.output + str(self.process.exitCode()))
if path.exists(self.tempPath):
self.setStat(self.tempPath)
remove(self.tempPath)
else:
self.outputlog.setText(" ERROR: QProcess FAIL: Profiling failed.")
self.tabWidget.setCurrentIndex(2)
def on_process_error(self, error):
' when the process fail, I hope you never see this '
print(" ERROR: QProcess FAIL: Profiler Dead, wheres your God now ? ")
if error == QProcess.FailedToStart:
self.outputlog.setText(" ERROR: FAIL: Profiler execution failed ")
elif error == QProcess.Crashed:
self.outputlog.setText(" ERROR: FAIL: Profiler execution crashed ")
else:
self.outputlog.setText(" ERROR: FAIL: Profiler unknown error ")
def on_actionLoad_profile_triggered(self):
"""Load a previous profile sessions"""
statPath = str(QFileDialog.getOpenFileName(self.dock,
"Open profile dump", path.expanduser("~"), "Profile file (*)"))
if statPath:
self.clearContent()
print(' INFO: OK: Loading profiling from ' + statPath)
self.setStat(statPath)
def on_actionSave_profile_triggered(self):
"""Save a profile sessions"""
statPath = str(QFileDialog.getSaveFileName(self.dock,
"Save profile dump", path.expanduser("~"), "Profile file (*)"))
if statPath:
#TODO: handle error case and give feelback to user
print(' INFO: OK: Saving profiling to ' + statPath)
self.stat.save(statPath)
#=======================================================================#
# Common parts #
#=======================================================================#
def on_tabWidget_currentChanged(self, index):
"""slot for tab change"""
# Kill search and hint timer if running to avoid cross effect
for timer in (self.filterHintTimer, self.filterSearchTimer):
if timer.isActive():
timer.stop()
if not self.stat:
#No stat loaded, nothing to do
return
self.populateTable()
self.populateSource()
def on_filterLineEdit_textEdited(self, text):
"""slot for filter change (table or tree"""
if self.filterSearchTimer.isActive():
# Already runnning, stop it
self.filterSearchTimer.stop()
# Start timer
self.filterSearchTimer.start(300)
def on_filterHintTimer_timeout(self):
"""Timeout to warn user about text length"""
print("timeout")
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
label = self.filterHintTableLabel
label.setText("Type > 2 characters to search")
def on_filterSearchTimer_timeout(self):
"""timeout to start search"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
text = self.filterTableLineEdit.text()
label = self.filterHintTableLabel
edit = self.filterTableLineEdit
widget = self.tableWidget
else:
print("Unknow tab for filterSearch timeout !")
print(("do search for %s" % text))
if not len(text):
# Empty keyword, just clean all
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
self.warnUSer(True, edit)
self.clearSearch()
return
if len(text) < 2:
# Don't filter if text is too short and tell it to user
self.filterHintTimer.start(600)
return
else:
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
# Search
self.clearSearch()
matchedItems = []
if tab == TAB_FUNCTIONSTAT:
# Find items
matchedItems = widget.findItems(text, Qt.MatchContains)
widget.setSortingEnabled(False)
matchedRows = [item.row() for item in matchedItems]
# Hide matched items
header = widget.verticalHeader()
for row in range(widget.rowCount()):
if row not in matchedRows:
header.hideSection(row)
widget.setSortingEnabled(True)
else:
print(" Unknow tab for filterSearch timeout ! ")
print(("got %s members" % len(matchedItems)))
self.warnUSer(matchedItems, edit)
self.resizeWidgetToContent(widget)
def resizeWidgetToContent(self, widget):
"""Resize all columns according to content"""
for i in range(widget.columnCount()):
widget.resizeColumnToContents(i)
def clearSearch(self):
"""Clean search result
For table, show all items
For tree, remove colored items"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
header = self.tableWidget.verticalHeader()
if header.hiddenSectionCount():
for i in range(header.count()):
if header.isSectionHidden(i):
header.showSection(i)
def clearContent(self):
# Clear tabs
self.tableWidget.clearContents()
self.sourceTreeWidget.clear()
# Reset LCD numbers
for lcdNumber in (self.totalTimeLcdNumber, self.numCallLcdNumber,
self.primCallLcdNumber):
lcdNumber.display(1000000)
# Reset stat
self.pstat = None
# Disable save as menu
self.actionSave_profile.setEnabled(False)
# Mark all tabs as unloaded
for i in range(10):
self.tabLoaded[i] = False
def warnUSer(self, result, inputWidget):
palette = inputWidget.palette()
if result:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 255, 255))
else:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 136, 138))
inputWidget.setPalette(palette)
inputWidget.update()
def setStat(self, statPath):
self.stat = Stat(path=statPath)
# Global stat update
self.totalTimeLcdNumber.display(self.stat.getTotalTime())
self.numCallLcdNumber.display(self.stat.getCallNumber())
self.primCallLcdNumber.display(self.stat.getPrimitiveCallRatio())
# Refresh current tab
self.on_tabWidget_currentChanged(self.tabWidget.currentIndex())
# Activate save as menu
self.actionSave_profile.setEnabled(True)
try:
self.rating.setMaxRating(10)
self.rating.setRating(
int(self.stat.getPrimitiveCallRatio()) / 10 - 1)
except:
pass
#========================================================================#
# Statistics table #
#=======================================================================#
def populateTable(self):
row = 0
rowCount = self.stat.getStatNumber()
progress = QProgressDialog("Populating statistics table...",
"Abort", 0, 2 * rowCount)
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setRowCount(rowCount)
progress.setWindowModality(Qt.WindowModal)
for (key, value) in self.stat.getStatItems():
#ncalls
item = StatTableWidgetItem(str(value[0]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_NCALLS, item)
colorTableItem(item, self.stat.getCallNumber(), value[0])
#total time
item = StatTableWidgetItem(str(value[2]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[2])
#per call (total time)
if value[0] != 0:
tPerCall = str(value[2] / value[0])
cPerCall = str(value[3] / value[0])
else:
tPerCall = ""
cPerCall = ""
item = StatTableWidgetItem(tPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TPERCALL, item)
colorTableItem(item, 100.0 * self.stat.getTotalTime() /
self.stat.getCallNumber(), tPerCall)
#per call (cumulative time)
item = StatTableWidgetItem(cPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CPERCALL, item)
colorTableItem(item, 100.0 * self.stat.getTotalTime() /
self.stat.getCallNumber(), cPerCall)
#cumulative time
item = StatTableWidgetItem(str(value[3]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[3])
#Filename
self.tableWidget.setItem(row, STAT_FILENAME,
StatTableWidgetItem(str(key[0])))
#Line
item = StatTableWidgetItem(str(key[1]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_LINE, item)
#Function name
self.tableWidget.setItem(row, STAT_FUNCTION,
StatTableWidgetItem(str(key[2])))
row += 1
# Store it in stat hash array
self.stat.setStatLink(item, key, TAB_FUNCTIONSTAT)
progress.setValue(row)
if progress.wasCanceled():
return
for i in range(self.tableWidget.rowCount()):
progress.setValue(row + i)
for j in range(self.tableWidget.columnCount()):
item = self.tableWidget.item(i, j)
if item:
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setSortingEnabled(True)
self.resizeWidgetToContent(self.tableWidget)
progress.setValue(2 * rowCount)
def on_tableWidget_itemDoubleClicked(self, item):
matchedItems = []
filename = str(self.tableWidget.item(item.row(), STAT_FILENAME).text())
if not filename or filename.startswith("<"):
# No source code associated, return immediatly
return
function = self.tableWidget.item(item.row(), STAT_FUNCTION).text()
line = self.tableWidget.item(item.row(), STAT_LINE).text()
self.on_tabWidget_currentChanged(TAB_SOURCE) # load source tab
function = "%s (%s)" % (function, line)
fathers = self.sourceTreeWidget.findItems(filename, Qt.MatchContains,
SOURCE_FILENAME)
print(("find %s father" % len(fathers)))
for father in fathers:
findItems(father, function, SOURCE_FILENAME, matchedItems)
print(("find %s items" % len(matchedItems)))
if matchedItems:
self.tabWidget.setCurrentIndex(TAB_SOURCE)
self.sourceTreeWidget.scrollToItem(matchedItems[0])
self.on_sourceTreeWidget_itemClicked(matchedItems[0],
SOURCE_FILENAME)
matchedItems[0].setSelected(True)
else:
print("oups, item found but cannot scroll to it !")
#=======================================================================#
# Source explorer #
#=====================================================================#
def populateSource(self):
items = {}
for stat in self.stat.getStatKeys():
source = stat[0]
function = "%s (%s)" % (stat[2], stat[1])
if source in ("", "profile") or source.startswith("<"):
continue
# Create the function child
child = QTreeWidgetItem([function])
# Store it in stat hash array
self.stat.setStatLink(child, stat, TAB_SOURCE)
if source in items:
father = items[source]
else:
# Create the father
father = QTreeWidgetItem([source])
items[source] = father
father.addChild(child)
self.sourceTreeWidget.setSortingEnabled(False)
for value in list(items.values()):
self.sourceTreeWidget.addTopLevelItem(value)
self.sourceTreeWidget.setSortingEnabled(True)
def on_sourceTreeWidget_itemActivated(self, item, column):
self.on_sourceTreeWidget_itemClicked(item, column)
def on_sourceTreeWidget_itemClicked(self, item, column):
line = 0
parent = item.parent()
if QSCI:
doc = self.sourceTextEdit
if parent:
pathz = parent.text(column)
result = match("(.*) \(([0-9]+)\)", item.text(column))
if result:
try:
function = str(result.group(1))
line = int(result.group(2))
except ValueError:
# We got garbage... falling back to line 0
pass
else:
pathz = item.text(column)
pathz = path.abspath(str(pathz))
if self.currentSourcePath != pathz:
# Need to load source
self.currentSourcePath == pathz
try:
if QSCI:
doc.clear()
doc.insert(file(pathz).read())
else:
self.sourceTextEdit.setPlainText(file(pathz).read())
except IOError:
QMessageBox.warning(self,
"Error", "Source file could not be found",
QMessageBox.Ok)
return
if QSCI:
for function, line in [(i[2], i[1]
) for i in self.stat.getStatKeys() if i[0] == pathz]:
# expr, regexp, case sensitive, whole word, wrap, forward
doc.findFirst("def", False, True, True, False, True, line,
0, True)
end, foo = doc.getCursorPosition()
time = self.stat.getStatTotalTime((pathz, line, function))
colorSource(doc, self.stat.getTotalTime(), time, line, end,
self.marker)
if QSCI:
doc.ensureLineVisible(line)
