def build(path):
for name in os.listdir(path):
source = os.path.join(path, name)
target = None
if source.endswith(".ui"):
target = os.path.join(path,
"ui_" + name.replace(".ui", ".py"))
command = PYUIC4
elif source.endswith(".qrc"):
target = os.path.join(path,
name.replace(".qrc", "") + "_rc.py")
command = PYRCC4
process = QProcess()
if target is not None:
if not os.access(target, os.F_OK) or (
os.stat(source)[stat.ST_MTIME] > \
os.stat(target)[stat.ST_MTIME]):
if command == PYUIC4 and Execute:
args = ["-x", "-o", target, source]
else:
args = ["-o", target, source]
if Debug:
print "# %s -o %s %s" % (command, target, source)
else:
process.start(command, args)
if not process.waitForFinished(2 * 60 * 1000):
report_failure(command, args, process)
else:
print source, "->", target
elif Verbose:
print source, "is up-to-date"
def __init__(self, ID=None):
self.Test = QProcess()
self.ID = ID
#a and b to test if i get a output or command error
self.a = True
self.Settings = QtCore.QSettings('Tyrant.cfg',
QtCore.QSettings.IniFormat)
def main():
app = QApplication(sys.argv)
window = QSimpleShellWidget()
proc = QProcess()
window.setProcess(proc)
proc.start('sh -c "while true; do echo foo; sleep 1; done"')
window.show()
app.exec_()
def testNoArgs(self):
'''Connecting a lambda to a signal without arguments'''
proc = QProcess()
dummy = Dummy()
QObject.connect(proc, SIGNAL('started()'),
lambda: setattr(dummy, 'called', True))
proc.start(sys.executable, ['-c', '""'])
proc.waitForFinished()
self.assert_(dummy.called)
def __init__(self):
super(TasksPool, self).__init__()
self.tasks_pool = []
self.process = QProcess()
self.startNextTaskSignal.connect(self.execute_task)
self.allTasksCompleteSignal.connect(self.tasks_complete)
self.source = ''
def __init__(self, finishedHook=None, stdoutHook=None, stderrHook=None):
self.process = QProcess()
self.finishedHook = finishedHook
self.stdoutHook = stdoutHook
self.stderrHook = stderrHook
self.process.finished.connect(self.finished)
self.process.readyReadStandardOutput.connect(self.readStdout)
self.process.readyReadStandardError.connect(self.readStderr)
self.print_next_error_lines = 0
self.print_next_error_file = False
def run(self):
self.logger.debug("patcher started")
for patch in self.patches:
mod = patch["mod"]
fromFile = patch["patchfile"]
toFile = patch["tofilename"]
frommd5 = patch["md5"]
tomd5 = patch["tomd5"]
curPatchGen = "%s-%s.xdelta" % (fromFile, toFile)
self.logger.debug(curPatchGen)
self.logger.debug("opening database")
self.db = QtSql.QSqlDatabase.cloneDatabase(self.parentDb,
curPatchGen)
source = os.path.join(
config['global']['content_path'] + r"updaterNew/", mod,
fromFile)
target = os.path.join(
config['global']['content_path'] + r"updaterNew/", mod, toFile)
self.logger.debug(source)
self.logger.debug(target)
patchdest = os.path.join(
config['global']['content_path'] + r"xdelta/", curPatchGen)
self.logger.debug(patchdest)
if os.path.exists(source) and os.path.exists(target):
executable = "python"
arguments = [
config['global']['install_path'] + "patcher.py", source,
target, patchdest
]
self.logger.debug(arguments)
process = QProcess()
process.start(executable, arguments)
if not process.waitForFinished(28800000):
return
self.db.open()
query = QSqlQuery(self.db)
queryStr = (
"INSERT INTO patchs_table (fromMd5, toMd5, patchFile) VALUES ('%s','%s','%s')"
) % (frommd5, tomd5, curPatchGen)
query.exec_(queryStr)
#
self.db.close()
def detach(args, path=''):
"""
@param args [unicode]
@param* path unicode working directory
@return bool
"""
from PySide.QtCore import QProcess
dprint("path: %s" % (path or '(empty)'))
dprint(args)
if path:
return QProcess.startDetached(args[0], args[1:], path)
else:
return QProcess.startDetached(args[0], args[1:])
def start(self, messageElement):
Stream.clear_streams()
process = QProcess()
self.process = process
self.messageElement = messageElement
process.setProcessChannelMode(QProcess.MergedChannels)
process.start("livestreamer", self.arguments)
process.readyReadStandardOutput.connect(self.show_messages)
Stream.ALL_STREAMS.append(self)
def process(self, command):
# print "process"
content = "content"
process = QProcess()
process.start(command)
process.closeWriteChannel()
process.waitForFinished()
# process.closeWriteChannel()
content = process.readAllStandardOutput()
print "Content: " + content
return unicode(content)
def run(self):
if self.ui.cb_batch.isChecked():
self.last_log_file = None
else:
f_next, _ = os.path.splitext(str(self.ui.edit_file.text()))
f_params = f_next + '.params'
if not os.path.exists(f_params):
self.create_params_file(f_params)
self.ui.btn_param.setEnabled(True)
return
self.last_log_file = f_next + '.log'
if self.ui.tabWidget.currentIndex() == 0:
args = self.command_line_args()
elif self.ui.tabWidget.currentIndex() == 1:
args = self.gui_command_line_args()
self.update_result_tab()
# # Start process
self.ui.edit_stdout.clear()
format = self.ui.edit_stdout.currentCharFormat()
format.setFontWeight(QFont.Normal)
format.setForeground(QtCore.Qt.blue)
self.ui.edit_stdout.setCurrentCharFormat(format)
time_str = datetime.datetime.now().ctime()
start_msg = '''\
Starting spyking circus at {time_str}.
Command line call:
{call}
'''.format(time_str=time_str, call=' '.join(args))
self.ui.edit_stdout.appendPlainText(textwrap.dedent(start_msg))
format.setForeground(QtCore.Qt.black)
self.ui.edit_stdout.setCurrentCharFormat(format)
self.ui.edit_stdout.appendPlainText('\n')
self.process = QProcess(self)
self.connect(self.process, SIGNAL('readyReadStandardOutput()'), self.append_output)
self.connect(self.process, SIGNAL('readyReadStandardError()'),
self.append_error)
self.connect(self.process, SIGNAL('started()'),
self.process_started)
self.connect(self.process, SIGNAL('finished(int)'),
self.process_finished)
self.connect(self.process, SIGNAL('error()'),
self.process_errored)
self._interrupted = False
self.process.start(args[0], args[1:])
def __execute_task(self, task):
"""
:param task: Is a string used to start a process
"""
self.process = QProcess(self)
self.process.finished.connect(
lambda *x: logger.debug(task + ' reports complete'))
self.process.finished.connect(lambda *x: self.return_signal.emit(
'â–º' + task + 'â—„reports complete'))
self.process.finished.connect(self.task_done)
# self.process.readyRead.connect(lambda *x: print(str(self.process.readAll())))
self.process.readyRead.connect(
lambda *x: self.return_signal.emit(str(self.process.readAll())))
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.start(task)
def execute_task(self):
print('Start next?')
if self.process.isOpen():
self.process.waitForFinished()
if not self.tasks_pool:
self.allTasksCompleteSignal.emit()
return
self.process = QProcess()
self.process.finished.connect(
lambda *x: QTimer.singleShot(1000, self.startNextTaskSignal.emit))
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.readyRead.connect(self.process_output)
next_task = self.tasks_pool.pop(0)
print('NEXT TASK', next_task)
self.process.start(next_task)
class TasksPool(QObject):
"""
This class allows you to add_task() for execution queue. Launch_list() starts the queue.
"""
task_done = Signal()
return_signal = Signal(str)
def __init__(self):
super(TasksPool, self).__init__()
self.tasks_pool = []
self.process = None
if not QApplication.instance():
self.qapp = QApplication([])
def add_task(self, command):
"""
:type command: str
:param command: A console command with arguments
Adds a task to the pool for later execution
"""
self.tasks_pool.append(command)
def __execute_task(self, task):
"""
:param task: Is a string used to start a process
"""
self.process = QProcess(self)
self.process.finished.connect(
lambda *x: logger.debug(task + ' reports complete'))
self.process.finished.connect(lambda *x: self.return_signal.emit(
'â–º' + task + 'â—„reports complete'))
self.process.finished.connect(self.task_done)
# self.process.readyRead.connect(lambda *x: print(str(self.process.readAll())))
self.process.readyRead.connect(
lambda *x: self.return_signal.emit(str(self.process.readAll())))
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.start(task)
def launch_list(self):
"""
Starts the execution of the queue in consecutive order, waiting for previous process to finish
"""
for task in self.tasks_pool:
loop = QEventLoop()
self.task_done.connect(loop.quit)
self.__execute_task(task)
loop.exec_()
def init_broker(self):
print "[*] init_broker"
modname = self.input.text().encode('ascii', 'replace')
cmdline = u"\"%s\" -u \"%s\" --idb \"%s\"" % (
os.path.join(PYTHON_PATH, PYTHON_BIN),
BROKER_PATH, modname)
print "[*] init broker,", cmdline
self.broker = Broker(self.parser)
env = QProcess.systemEnvironment()
env.append("IDB_PATH=%s" % IDB_PATH)
env.append("PYTHON_PATH=%s" % os.path.realpath(PYTHON_PATH))
env.append("PYTHON_BIN=%s" % PYTHON_BIN)
try:
self.broker.connect(self.broker, QtCore.SIGNAL("started()"), self.cb_broker_started)
self.broker.connect(self.broker, QtCore.SIGNAL("finished(int)"), self.cb_broker_finished)
self.broker.setEnvironment(env)
self.broker.start(cmdline)
except Exception as e:
print "[-] failed to start broker: %s\n%s" % (str(e), traceback.format_exc())
return
self.init_hotkeys()
self.broker.worker.name = modname
def __init__(self, ID=None):
self.Test = QProcess()
self.ID = ID
#a and b to test if i get a output or command error
self.a = True
self.Settings = QtCore.QSettings('Tyrant.cfg',
QtCore.QSettings.IniFormat)
def init_broker(self):
print "[*] init_broker"
modname = self.input.text().encode('ascii', 'replace')
cmdline = u"\"%s\" -u \"%s\" --idb \"%s\"" % (
os.path.join(PYTHON_PATH, PYTHON_BIN),
BROKER_PATH, modname)
print "[*] init broker,", cmdline
self.broker = Broker(self.parser)
env = QProcess.systemEnvironment()
env.append("IDB_PATH=%s" % IDB_PATH)
env.append("PYTHON_PATH=%s" % os.path.realpath(PYTHON_PATH))
env.append("PYTHON_BIN=%s" % PYTHON_BIN)
try:
self.broker.connect(self.broker, QtCore.SIGNAL("started()"), self.cb_broker_started)
self.broker.connect(self.broker, QtCore.SIGNAL("finished(int)"), self.cb_broker_finished)
self.broker.setEnvironment(env)
self.broker.start(cmdline)
except Exception as e:
print "[-] failed to start broker: %s\n%s" % (str(e), traceback.format_exc())
return
self.init_hotkeys()
self.broker.worker.name = modname
def get_output(cmd):
if isinstance(cmd, list):
cmd = ' '.join(cmd)
process = QProcess()
process.start(cmd)
process.waitForFinished()
return str(process.readAll())
def translate(path):
files = []
tsfiles = []
for name in os.listdir(path):
if name.endswith((".py", ".pyw")):
files.append(os.path.join(path, name))
elif name.endswith(".ts"):
tsfiles.append(os.path.join(path, name))
if not tsfiles:
return
verbose = "-verbose" if Verbose else ""
silent = "-silent" if not Verbose else ""
process = QProcess()
for ts in tsfiles:
qm = ts[:-3] + ".qm"
command1 = PYLUPDATE4
args1 = [verbose] + files + ["-ts", ts]
command2 = LRELEASE
args2 = [silent, ts, "-qm", qm]
if Debug:
print "updated", ts
print "generated", qm
else:
process.start(command1, args1)
if not process.waitForFinished(2 * 60 * 1000):
report_failure(command1, args1, process)
process.start(command2, args2)
if not process.waitForFinished(2 * 60 * 1000):
report_failure(command2, args2, process)
def run(self) :
self.logger.debug("patcher started")
for patch in self.patches:
mod = patch["mod"]
fromFile = patch["patchfile"]
toFile = patch["tofilename"]
frommd5 = patch["md5"]
tomd5 = patch["tomd5"]
curPatchGen = "%s-%s.xdelta" % (fromFile, toFile)
self.logger.debug(curPatchGen)
self.logger.debug("opening database")
self.db = QtSql.QSqlDatabase.cloneDatabase(self.parentDb, curPatchGen)
source = os.path.join(config['global']['content_path'] + r"updaterNew/", mod, fromFile)
target = os.path.join(config['global']['content_path'] + r"updaterNew/", mod, toFile)
self.logger.debug(source)
self.logger.debug(target)
patchdest = os.path.join(config['global']['content_path'] + r"xdelta/", curPatchGen)
self.logger.debug(patchdest)
if os.path.exists(source) and os.path.exists(target) :
executable = "python"
arguments = [config['global']['install_path'] + "patcher.py", source, target, patchdest]
self.logger.debug(arguments)
process = QProcess()
process.start(executable, arguments)
if not process.waitForFinished(28800000) :
return
self.db.open()
query = QSqlQuery(self.db)
queryStr = ("INSERT INTO patchs_table (fromMd5, toMd5, patchFile) VALUES ('%s','%s','%s')") % (frommd5, tomd5, curPatchGen)
query.exec_(queryStr)
#
self.db.close()
def testWithoutArgs(self):
"""Connect QProcess.started() to QTimeLine.togglePaused()"""
process = QProcess()
timeline = QTimeLine()
QObject.connect(process, SIGNAL("finished(int, QProcess::ExitStatus)"), timeline, SLOT("toggleDirection()"))
orig_dir = timeline.direction()
process.start(sys.executable, ["-c", '"print 42"'])
process.waitForFinished()
new_dir = timeline.direction()
if orig_dir == QTimeLine.Forward:
self.assertEqual(new_dir, QTimeLine.Backward)
else:
self.assertEqual(new_dir, QTimeLine.Forward)
def is_online( self, tableWidgetItem ): Stream.clear_streams() process = QProcess() self.process = process self.table_widget_item = tableWidgetItem arguments = [ '--json' ] + self.arguments process.setProcessChannelMode( QProcess.MergedChannels ) process.start( 'livestreamer', arguments ) process.readyReadStandardOutput.connect( self.is_online_callback ) itemWidget = self.table_widget_item tableWidget = itemWidget.tableWidget() tableWidget.setCellWidget( itemWidget.row(), 0, MovieWidget( fullpath( 'icons/loading_16.gif' ), tableWidget) ) Stream.ALL_STREAMS.append( self )
def process(self,command):
# print "process"
content = "content"
process = QProcess()
process.start(command)
process.closeWriteChannel()
process.waitForFinished()
# process.closeWriteChannel()
content = process.readAllStandardOutput()
print "Content: " + content
return unicode(content);
def testQProcessFinished(self):
'''Multiple connections to QProcess.finished(int)'''
sender = QProcess()
receivers = [BasicPySlotCase() for x in range(10)]
def start_proc(*args):
sender.start(sys.executable, ['-c', '""'])
sender.waitForFinished()
self.run_many(sender, 'finished(int)', start_proc, receivers, (0, ))
def __init__(self, media, parent):
super(WebMediaView, self).__init__(media, parent)
self.widget = QWidget(parent)
self.process = QProcess(self.widget)
self.process.setObjectName('%s-process' % self.objectName())
self.std_out = []
self.errors = []
self.stopping = False
self.mute = False
self.widget.setGeometry(media['geometry'])
self.connect(self.process, SIGNAL('error()'), self.process_error)
self.connect(self.process, SIGNAL('finished()'), self.process_finished)
self.connect(self.process, SIGNAL('started()'), self.process_started)
self.set_default_widget_prop()
self.stop_timer = QTimer(self)
self.stop_timer.setSingleShot(True)
self.stop_timer.setInterval(1000)
self.stop_timer.timeout.connect(self.process_timeout)
self.rect = self.widget.geometry()
def start( self, messageElement, tableWidgetItem ): Stream.clear_streams() process = QProcess() self.process = process self.messageElement = messageElement row = tableWidgetItem.row() tableWidget = tableWidgetItem.tableWidget() tableWidget.setCellWidget( tableWidgetItem.row(), 0, ImageWidget( fullpath( 'icons/play_16.png' ), tableWidget) ) tableWidgetItem = tableWidget.item( row, 0 ) process.setProcessChannelMode( QProcess.MergedChannels ) process.start( 'livestreamer', self.arguments ) process.readyReadStandardOutput.connect( self.show_messages ) process.finished.connect( lambda: self.is_online( tableWidgetItem ) ) Stream.ALL_STREAMS.append( self )
def testWithArgs(self):
'''Connecting a lambda to a signal with arguments'''
proc = QProcess()
dummy = Dummy()
QObject.connect(proc, SIGNAL('finished(int)'),
lambda x: setattr(dummy, 'called', x))
proc.start(sys.executable, ['-c', '""'])
proc.waitForFinished()
self.assertEqual(dummy.called, proc.exitCode())
def get_output(cmd):
if isinstance(cmd, list):
cmd = ' '.join(cmd)
process = QProcess()
process.start(cmd)
process.waitForFinished()
return str(process.readAll())
def is_online(self, tableWidgetItem):
Stream.clear_streams()
process = QProcess()
self.process = process
self.table_widget_item = tableWidgetItem
arguments = ["--json"] + self.arguments
process.setProcessChannelMode(QProcess.MergedChannels)
process.start("livestreamer", arguments)
process.readyReadStandardOutput.connect(self.is_online_callback)
brush = QBrush(Qt.SolidPattern)
color = QColor(255, 255, 255) # white
brush.setColor(color)
tableWidgetItem.setBackground(brush)
tableWidgetItem.setText("Checking..")
Stream.ALL_STREAMS.append(self)
def neko(neko_id='neko:v2Yr'):
_, id = neko_id.split(":")
url = BASE_URL.format(id)
if not DEBUG:
res = requests.get(url).json()
else:
res = _response
mega_url = res.get("url","")
version = res.get("version", -1)
if VER != version:
print cat
print "Hay una version nueva!!! descargala"
raw_input("adios ...")
return
print cat
if _platform == "linux" or _platform == "linux2":
mega_path = "megadl"
mpv_path = "mpv"
elif _platform == "darwin": # MAC OS X
pass
elif _platform == "win32": # Windows
mega_path = os.path.join(BASE_DIR, 'mega', 'megadl.exe')
mpv_path = os.path.join(BASE_DIR, "mpv","mpv.com")
p1 = QProcess()
p2 = QProcess()
p1.setStandardOutputProcess(p2)
p1.start('{}'.format(mega_path), ['{}'.format(mega_url),"--path","-"])
p2.start('{}'.format(mpv_path), ["-" , '--no-terminal'])
p2.waitForFinished(-1)
#print p2.readAll()
# "--path","-",)
#cmd = ['"{}"'.format(mega_path), '"{}"'.format(mega_url),
# "--path","-","|",
# '"{}"'.format(mpv_path), "-" , '--no-terminal']
#'--fullscreen']
print "Cargando...."
def __init__(self, media, parent):
super(VideoMediaView, self).__init__(media, parent)
self._widget = QWidget(parent)
self._process = QProcess(self._widget)
self._process.setObjectName('%s-process' % self.objectName())
self._std_out = []
self._errors = []
self._stopping = False
self._mute = False
if 'mute' in self._options:
self._mute = bool(int(self._options['mute']))
self._widget.setGeometry(media['_geometry'])
self.connect(self._process, SIGNAL("error()"), self._process_error)
self.connect(self._process, SIGNAL("finished()"), self.stop)
self.connect(self._process, SIGNAL("readyReadStandardOutput()"),
self.__grep_std_out)
self.set_default_widget_prop()
self._stop_timer = QTimer(self)
self._stop_timer.setSingleShot(True)
self._stop_timer.setInterval(1000)
self._stop_timer.timeout.connect(self._force_stop)
def testNoArgs(self):
'''Connecting a lambda to a signal without arguments'''
proc = QProcess()
dummy = Dummy()
QObject.connect(proc, SIGNAL('started()'),
lambda: setattr(dummy, 'called', True))
proc.start(sys.executable, ['-c', '""'])
proc.waitForFinished()
self.assert_(dummy.called)
def testWithArgs(self):
'''Connecting a lambda to a signal with arguments'''
proc = QProcess()
dummy = Dummy()
QObject.connect(proc, SIGNAL('finished(int)'),
lambda x: setattr(dummy, 'called', x))
proc.start(sys.executable, ['-c', '""'])
proc.waitForFinished()
self.assertEqual(dummy.called, proc.exitCode())
def start_autostarts():
global autostart_processlist, logger
autostarts = {}
sl = clixxIOProjectAutostarts()
for sp in sl.keys():
p = QProcess()
p.setWorkingDirectory(sl[sp]["directory"])
program = sl[sp]["command"]
arguments = sl[sp]["arguments"].split(' ')
logger.debug("Starting %s in %s with arguments %s" % (program,sl[sp]["directory"],arguments))
# Start the process running
autostart_processlist.append(p)
autostart_processlist[len(autostart_processlist)-1].start(program, arguments)
for p in range(0,len(autostart_processlist)-1):
logger.debug("PID=%d" % autostart_processlist[p].pid())
class TasksPool(QObject):
startNextTaskSignal = Signal()
allTasksCompleteSignal = Signal()
def __init__(self):
super(TasksPool, self).__init__()
self.tasks_pool = []
self.process = QProcess()
self.startNextTaskSignal.connect(self.execute_task)
self.allTasksCompleteSignal.connect(self.tasks_complete)
self.source = ''
def add_task(self, command):
self.tasks_pool.append(command)
self.startNextTaskSignal.emit()
def execute_task(self):
print('Start next?')
if self.process.isOpen():
self.process.waitForFinished()
if not self.tasks_pool:
self.allTasksCompleteSignal.emit()
return
self.process = QProcess()
self.process.finished.connect(
lambda *x: QTimer.singleShot(1000, self.startNextTaskSignal.emit))
self.process.setProcessChannelMode(QProcess.MergedChannels)
self.process.readyRead.connect(self.process_output)
next_task = self.tasks_pool.pop(0)
print('NEXT TASK', next_task)
self.process.start(next_task)
def process_output(self):
output = self.process.readAll()
output = str(output).strip()
if output:
print(output)
def tasks_complete(self):
print('ALL TASKS COMPLETE')
def start(self, messageElement):
Stream.clear_streams()
process = QProcess()
self.process = process
self.messageElement = messageElement
process.setProcessChannelMode(QProcess.MergedChannels)
process.start('livestreamer', self.arguments)
process.readyReadStandardOutput.connect(self.show_messages)
Stream.ALL_STREAMS.append(self)
def __init__(self, media, parent):
super(VideoMediaView, self).__init__(media, parent)
self._widget = QWidget(parent)
self._process = QProcess(self._widget)
self._process.setObjectName('%s-process' % self.objectName())
self._std_out = []
self._errors = []
self._stopping = False
self._mute = False
if 'mute' in self._options:
self._mute = bool(int(self._options['mute']))
self._widget.setGeometry(media['_geometry'])
self.connect(self._process, SIGNAL("error()"), self._process_error)
self.connect(self._process, SIGNAL("finished()"), self.stop)
self.connect(self._process, SIGNAL("readyReadStandardOutput()"), self.__grep_std_out)
self.set_default_widget_prop()
self._stop_timer = QTimer(self)
self._stop_timer.setSingleShot(True)
self._stop_timer.setInterval(1000)
self._stop_timer.timeout.connect(self._force_stop)
def is_online(self, tableWidgetItem):
Stream.clear_streams()
process = QProcess()
self.process = process
self.table_widget_item = tableWidgetItem
arguments = ['--json'] + self.arguments
process.setProcessChannelMode(QProcess.MergedChannels)
process.start('livestreamer', arguments)
process.readyReadStandardOutput.connect(self.is_online_callback)
tableWidgetItem.setText('Checking..')
Stream.ALL_STREAMS.append(self)
def testWithoutArgs(self):
'''Connect QProcess.started() to QTimeLine.togglePaused()'''
process = QProcess()
timeline = QTimeLine()
QObject.connect(process, SIGNAL('finished(int, QProcess::ExitStatus)'),
timeline, SLOT('toggleDirection()'))
orig_dir = timeline.direction()
process.start(sys.executable, ['-c', '"print 42"'])
process.waitForFinished()
new_dir = timeline.direction()
if orig_dir == QTimeLine.Forward:
self.assertEqual(new_dir, QTimeLine.Backward)
else:
self.assertEqual(new_dir, QTimeLine.Forward)
def runtapinstall(args, errorok=False):
EXE = '%s/%s' % (TAPDIR, TAPINSTALL)
# args.insert(0, EXE)
# cmd = ' '.join(args)
process = QProcess()
process.start(EXE, args)
if not process.waitForFinished():
print "tapinstall failed. waitForFinished()"
sys.exit(1)
output = process.readAll();
rv = process.exitStatus()
output=str(output).strip()
if rv != 0 and not errorok:
print """tapinstall failed.
command was: %s
output was: %s
returnvalue was: %d""" % (cmd, output, rv)
sys.exit(1)
else:
return (rv, output)
def is_online(self, tableWidgetItem):
Stream.clear_streams()
process = QProcess()
self.process = process
self.table_widget_item = tableWidgetItem
arguments = ['--json'] + self.arguments
process.setProcessChannelMode(QProcess.MergedChannels)
process.start('livestreamer', arguments)
process.readyReadStandardOutput.connect(self.is_online_callback)
brush = QBrush(Qt.SolidPattern)
color = QColor(255, 255, 255) #white
brush.setColor(color)
tableWidgetItem.setBackground(brush)
tableWidgetItem.setText('Checking..')
Stream.ALL_STREAMS.append(self)
def parse_asn1(*files, **options):
''' Call the ASN.1 parser on a number of files, and return the module
containing the AST
This function uses QProcess to launch the ASN.1 compiler because
the subprocess module from Python has issues on the Windows platform
'''
ast_version = options.get('ast_version', ASN1.UniqueEnumeratedNames)
rename_policy = options.get('rename_policy', ASN1.NoRename)
flags = options.get('flags', [ASN1.AstOnly])
pprint = options.get('pretty_print', False)
assert isinstance(ast_version, ASN1)
assert isinstance(rename_policy, ASN1)
assert isinstance(flags, list)
path_to_asn1scc = spawn.find_executable('asn1.exe')
if not path_to_asn1scc:
raise TypeError('ASN.1 Compiler not found in path')
if os.name == 'posix':
path_to_mono = spawn.find_executable('mono')
if not path_to_mono:
raise TypeErorr('"mono" not found in path. Please install it.')
binary = path_to_mono
arg0 = path_to_asn1scc
else:
binary = path_to_asn1scc
arg0 = ''
asn1scc_root = os.path.abspath(os.path.dirname(path_to_asn1scc))
# Create a temporary directory to store dataview.py and import it
tempdir = tempfile.mkdtemp()
sys.path.append(tempdir)
if os.name == 'nt':
# On windows, remove the drive letter, workaround to ASN1SCC bug
tempdir = tempdir[2:]
asn1scc_root = asn1scc_root[2:]
filename = str(uuid.uuid4()).replace('-', '_')
filepath = tempdir + os.sep + filename + '.py'
stg = asn1scc_root + os.sep + 'python.stg'
if pprint:
# Generate an html file with pretty-printed ASN.1 types
stg_qrc = QFile(':misc/pretty_print_asn1.stg')
stg_qrc.open(1)
content = stg_qrc.readAll()
stgfile = tempdir + os.sep + 'pretty_print_asn1.stg'
with open(stgfile, 'w') as tmpfile:
tmpfile.write(content.data())
out_html = tempdir + os.sep + 'dataview.html'
html = ['-customIcdUper', stgfile + '::' + out_html]
else:
html = []
args = [
arg0, '-customStgAstVerion',
str(ast_version.value), '-customStg', stg + '::' + filepath,
'-renamePolicy',
str(rename_policy.value)
] + html + list(*files)
asn1scc = QProcess()
LOG.debug(os.getcwd())
LOG.debug(binary + ' ' + ' '.join(args))
asn1scc.start(binary, args)
_ = waitfor_qprocess(asn1scc, "ASN.1 Compiler")
if filename in AST.viewkeys():
# Re-import module if it was already loaded
ast = AST[filename]
reload(ast)
else:
ast = importlib.import_module(filename)
AST[filename] = ast
if pprint:
# add the path to the optionally-gernated pretty-printed HTML file
ast.html = out_html
return ast
def asn2dataModel(*files):
''' Call asn1DataModel, including the Makefile.python and return
the imported module "name_of_dataview_asn.py"
From this module it is possible to create native Asn1scc instances of
ASN.1 data types, and to access to DV.py, which contains constants
such as the _PRESENT fields for choice selectors '''
assert len(files) > 0
# 1) Create a temporary directory for the output
tempdir = tempfile.mkdtemp()
sys.path.insert(0, tempdir)
# Use a unique name for the asn1 concatenated module
concat_prefix = str(uuid.uuid4()).replace('-', '_')
concat_path = os.path.join(tempdir, concat_prefix)
# 2) Concat all input files to the output directory
cat_bin = spawn.find_executable('cat')
args = list(files)
cat = QProcess()
LOG.debug(os.getcwd())
LOG.debug(cat_bin + ' ' + ' '.join(args))
cat.start(cat_bin, args)
merged = waitfor_qprocess(cat, 'Merge dataviews')
with open(concat_path + '.asn', 'wt') as merged_file:
merged_file.write(merged)
# 3) Run asn2dataModel
asn2dm_bin = spawn.find_executable('asn2dataModel')
args = ['-toPython', '-o', tempdir, concat_path + '.asn']
asn2dm = QProcess()
LOG.debug(os.getcwd())
LOG.debug(asn2dm_bin + ' ' + ' '.join(args))
asn2dm.start(asn2dm_bin, args)
waitfor_qprocess(asn2dm, 'DMT tool "asn2dataModel"')
# 4) call make -f Makefile.python to build the .so
make_bin = spawn.find_executable('make')
args = ['-f', 'Makefile.python']
make = QProcess()
make.setWorkingDirectory(tempdir)
LOG.debug(os.getcwd())
LOG.debug(make_bin + ' ' + ' '.join(args))
make.start(make_bin, args)
waitfor_qprocess(make, 'make -f Makefile.python')
if concat_prefix in ASN2DM.viewkeys():
# Re-import module if it was already loaded
asn1mod = ASN2DM[concat_prefix]
reload(asn1mod)
reload(asn1mod.DV)
import Stubs
reload(Stubs)
else:
asn1mod = importlib.import_module(concat_prefix + '_asn')
# force reload of modules in case of multiple calls
reload(asn1mod.DV)
import Stubs
reload(Stubs)
ASN2DM[concat_prefix] = asn1mod
sys.path.pop(0)
return asn1mod
class VideoMediaView(MediaView):
def __init__(self, media, parent):
super(VideoMediaView, self).__init__(media, parent)
self._widget = QWidget(parent)
self._process = QProcess(self._widget)
self._process.setObjectName('%s-process' % self.objectName())
self._std_out = []
self._errors = []
self._stopping = False
self._mute = False
if 'mute' in self._options:
self._mute = bool(int(self._options['mute']))
self._widget.setGeometry(media['_geometry'])
self.connect(self._process, SIGNAL("error()"), self._process_error)
self.connect(self._process, SIGNAL("finished()"), self.stop)
self.connect(self._process, SIGNAL("readyReadStandardOutput()"), self.__grep_std_out)
self.set_default_widget_prop()
self._stop_timer = QTimer(self)
self._stop_timer.setSingleShot(True)
self._stop_timer.setInterval(1000)
self._stop_timer.timeout.connect(self._force_stop)
@Slot()
def _force_stop(self):
os.kill(self._process.pid(), signal.SIGTERM)
self._stopping = False
if not self.is_started():
self.started_signal.emit()
super(VideoMediaView, self).stop()
@Slot(object)
def _process_error(self, err):
self._errors.append(err)
self.stop()
@Slot()
def play(self):
self._finished = 0
path = "%s/%s" % (self._save_dir, self._options['uri'])
self._widget.show()
args = [
'-slave', '-identify', '-input',
'nodefault-bindings:conf=/dev/null',
'-wid', str(int(self._widget.winId())),
path
]
if self._mute:
args += ['-ao', 'null']
self._process.start('mplayer', args)
self._stop_timer.start()
@Slot()
def stop(self, delete_widget=False):
if self._stopping or self.is_finished():
return False
self._stop_timer.start()
self._stopping = True
if self._process.state() == QProcess.ProcessState.Running:
self._process.write("quit\n")
self._process.waitForFinished(50)
self._process.close()
super(VideoMediaView, self).stop(delete_widget)
self._stopping = False
self._stop_timer.stop()
return True
@Slot()
def __grep_std_out(self):
lines = self._process.readAllStandardOutput().split("\n")
for line in lines:
if not line.isEmpty():
if line.startsWith("Starting playback"):
self._widget.raise_()
self._play_timer.start()
self.started_signal.emit()
self._stop_timer.stop()
else:
part = line.split("=")
if 'ID_LENGTH' == part[0]:
if float(self._duration) > 0: # user set the video duration manually.
self._play_timer.setInterval(int(1000 * float(self._duration)))
else: # use duration found by mplayer.
self._play_timer.setInterval(int(1000 * float(part[1])))
def parse_asn1(*files, **options):
""" Call the ASN.1 parser on a number of files, and return the module
containing the AST
This function uses QProcess to launch the ASN.1 compiler because
the subprocess module from Python has issues on the Windows platform
"""
global AST
ast_version = options.get("ast_version", ASN1.UniqueEnumeratedNames)
rename_policy = options.get("rename_policy", ASN1.NoRename)
flags = options.get("flags", [ASN1.AstOnly])
assert isinstance(ast_version, ASN1)
assert isinstance(rename_policy, ASN1)
assert isinstance(flags, list)
# if os.name == 'posix' and hasattr(sys, 'frozen'):
# Frozen Linux binaries are expected to use the frozen ASN.1 compiler
# No: there are issues with freezing the .NET applications - discard
# asn1exe = 'asn1scc'
# else:
# asn1exe = 'asn1.exe'
path_to_asn1scc = spawn.find_executable("asn1.exe")
if not path_to_asn1scc:
raise TypeError("ASN.1 Compiler not found in path")
if os.name == "posix":
path_to_mono = spawn.find_executable("mono")
if not path_to_mono:
raise TypeErorr('"mono" not found in path. Please install it.')
binary = path_to_mono
arg0 = path_to_asn1scc
else:
binary = path_to_asn1scc
arg0 = ""
asn1scc_root = os.path.abspath(os.path.dirname(path_to_asn1scc))
# Create a temporary directory to store dataview.py and import it
tempdir = tempfile.mkdtemp()
sys.path.append(tempdir)
if os.name == "nt":
# On windows, remove the drive letter, workaround to ASN1SCC bug
tempdir = tempdir[2:]
asn1scc_root = asn1scc_root[2:]
filename = str(uuid.uuid4()).replace("-", "_")
filepath = tempdir + os.sep + filename + ".py"
stg = asn1scc_root + os.sep + "python.stg"
args = [
arg0,
"-customStgAstVerion",
str(ast_version.value),
"-customStg",
stg + "::" + filepath,
"-renamePolicy",
str(rename_policy.value),
] + list(*files)
asn1scc = QProcess()
LOG.debug(os.getcwd())
LOG.debug(binary + " " + " ".join(args))
asn1scc.start(binary, args)
if not asn1scc.waitForStarted():
raise TypeError("Could not start ASN.1 Compiler")
if not asn1scc.waitForFinished():
raise TypeError("Execution of ASN.1 Compiler timed out")
exitcode = asn1scc.exitCode()
result = asn1scc.readAllStandardError()
if exitcode != 0:
raise TypeError("ASN.1 Compiler Error (exit code = {}) - {}".format(exitcode, str(result)))
else:
if filename in AST.viewkeys():
# Re-import module if it was already loaded
ast = AST[filename]
reload(ast)
else:
ast = importlib.import_module(filename)
AST[filename] = ast
return ast
def parse_asn1(*files, **options):
''' Call the ASN.1 parser on a number of files, and return the module
containing the AST
This function uses QProcess to launch the ASN.1 compiler because
the subprocess module from Python has issues on the Windows platform
'''
# use basic caching to avoid re-parsing when loading the model
project_cache = os.getenv ("PROJECT_CACHE")
if project_cache is not None and not os.path.isdir(project_cache):
raise TypeError (
"The configured cache folder \""
+ project_cache + "\" is not there!\n")
# make sure the same files are not parsed more than once if not modified
filehash = hashlib.md5()
file_list = sorted(list(*files))
try:
for each in file_list:
filehash.update(open(each).read())
# also hash the file path: it is used in the AST, so it is
# not enough to hash the content of the ASN.1 files, as two sets
# of input files may have the same hash
filehash.update(each)
except IOError as err:
raise TypeError (str(err))
new_hash = filehash.hexdigest()
# names of the files that will be generated by asn1scc and then parsed
out_py_name = new_hash + ".py"
out_html_name = new_hash + ".html"
if new_hash in AST.viewkeys():
return AST[new_hash]
elif project_cache is not None:
outdir = project_cache
elif project_cache is None:
outdir = tempfile.mkdtemp()
# to allow the import
sys.path.append(outdir)
ast_version = options.get('ast_version', ASN1.UniqueEnumeratedNames)
rename_policy = options.get('rename_policy', ASN1.NoRename)
flags = options.get('flags', [ASN1.AstOnly])
pprint = options.get('pretty_print', False)
assert isinstance(ast_version, ASN1)
assert isinstance(rename_policy, ASN1)
assert isinstance(flags, list)
path_to_asn1scc = spawn.find_executable('asn1.exe')
if not path_to_asn1scc:
raise TypeError('ASN.1 Compiler not found in path')
if os.name == 'posix':
path_to_mono = spawn.find_executable('mono')
if not path_to_mono:
raise TypeError('"mono" not found in path. Please install it.')
binary = path_to_mono
arg0 = path_to_asn1scc
else:
binary = path_to_asn1scc
arg0 = ''
asn1scc_root = os.path.abspath(os.path.dirname(path_to_asn1scc))
if os.name == 'nt':
# On windows, remove the drive letter, workaround to ASN1SCC bug
outdir = outdir[2:]
asn1scc_root = asn1scc_root[2:]
# The two possible files that can be generated with complete path:
py_filepath = outdir + os.sep + out_py_name
html_filepath = outdir + os.sep + out_html_name
# call the ASN.1 compiler only if there is no existing cached file
if project_cache is None or not os.path.exists(py_filepath):
stg = asn1scc_root + os.sep + 'python.stg'
if pprint:
# Generate an html file with pretty-printed ASN.1 types
stg_qrc = QFile(':misc/pretty_print_asn1.stg')
stg_qrc.open(1)
content = stg_qrc.readAll()
stgfile = outdir + os.sep + 'pretty_print_asn1.stg'
with open(stgfile, 'w') as tmpfile:
tmpfile.write(content.data())
html = ['-customIcdUper', stgfile + '::' + html_filepath]
else:
html = []
args = [arg0, '-customStgAstVersion', str(ast_version.value),
'-customStg', stg + '::' + py_filepath,
'-renamePolicy', str(rename_policy.value)] + html + file_list
asn1scc = QProcess()
LOG.debug(os.getcwd())
LOG.debug(binary + ' ' + ' '.join(args))
asn1scc.start(binary, args)
_ = waitfor_qprocess(asn1scc, "ASN.1 Compiler")
ast = importlib.import_module(new_hash)
AST[new_hash] = ast
if pprint:
# add the path to the optionally-generated pretty-printed HTML file
ast.html = html_filepath
return ast
class TestPython(object):
def __init__(self, ID=None):
self.Test = QProcess()
self.ID = ID
#a and b to test if i get a output or command error
self.a = True
self.Settings = QtCore.QSettings('Tyrant.cfg',
QtCore.QSettings.IniFormat)
def TestVersion(self):
print('Test python version')
self.Test.readyReadStandardError.connect(self.getOutput)
self.Test.readyReadStandardOutput.connect(self.getOutput)
if self.ID is not None:
self.Test.error.connect(self.Error)
#if i have a custom pythonpath, i'll use it here
Res = Resources()
Python = Res.getPref('Python')
#test if is a pythonpath, if not open a default
if len(Python) < 5:
Python = 'python'
self.Test.start(Python, ['-V'])
self.Test.waitForFinished()
self.Test.terminate()
if (self.a is False) & (self.ID is None):
#test a diferent command to run python 2.7
a = self.TestVersion2()
print a
return a
elif self.a:
#say to program that python is working
print('Python version found')
self.Settings.setValue('Python/PythonPath', str(Python))
self.Settings.sync()
return True
elif ((self.ID is not None) & (self.a is False)):
return False
def Error(self):
self.a = False
def TestVersion2(self):
print('Testing python version 2')
self.Test.readyReadStandardError.connect(self.getOutput)
Python = 'python2.7'
self.Test.start(Python, ['-V'])
self.Test.waitForStarted()
self.Test.waitForFinished()
self.Test.terminate()
if (self.a is False):
#say thar python is not working
return False
else:
self.Settings.setValue('Python/PythonPath', str(Python))
self.Settings.sync()
return True
def getOutput(self):
Out = str(self.Test.readAllStandardError())
print(Out)
if Out > 'Python 2.8':
self.a = False
return
self.a = True
def __init__(self, patch=None, *args, **kwargs):
QProcess.__init__(self, *args, **kwargs)
self.patch = None
def generate_completes(force=False):
# check parsed functions
cache_file = vex_settings.get_autocomplete_cache_file()
if os.path.exists(cache_file) and not force:
return True
# get vcc
vcc = os.path.join(hou.getenv('HFS'), 'bin', 'vcc').replace('/','\\')
if os.name == 'nt':
vcc = vcc + '.exe'
if not os.path.exists(vcc):
return False
# generate new
funcs = {}
attrs = {}
process = QProcess()
process.start(' '.join([vcc, '-X']))
process.waitForFinished()
lines = str(process.readAll()).split('\n')
for context in lines:
if context:
process.start(' '.join([vcc, '-X', context]))
process.waitForFinished()
context_lines = str(process.readAll())
# variables
variables = re.search(r'Global Variables:(.*)Control Statements:', context_lines, re.DOTALL)
if variables:
lines = variables.group(1).strip().split('\n')
for l in lines:
s = l.split()
if len(s)==3:
attrs[s[-1]] = s[-2]
# functions
pat = r'^\s*(\w+\[?\]?)\s(\w+)(\(.+\))'
for l in context_lines.split('\n'):
func = re.findall(pat, str(l))
if func:
if func[0][1] in funcs:
funcs[func[0][1]].append({'ret': func[0][0], 'args':func[0][2]})
else:
funcs[func[0][1]] = [{'ret': func[0][0], 'args':func[0][2]}]
# save to cache
if os.path.exists(cache_file):
comp = json.load(open(cache_file))
else:
comp = {}
comp['functions'] = funcs
comp['attributes'] = attrs
json.dump(comp, open(cache_file, 'w'), indent=4)
return True
class CfdConsoleProcess:
""" Class to run a console process asynchronously, printing output and
errors to the FreeCAD console and allowing clean termination in Linux
and Windows """
def __init__(self, finishedHook=None, stdoutHook=None, stderrHook=None):
self.process = QProcess()
self.finishedHook = finishedHook
self.stdoutHook = stdoutHook
self.stderrHook = stderrHook
self.process.finished.connect(self.finished)
self.process.readyReadStandardOutput.connect(self.readStdout)
self.process.readyReadStandardError.connect(self.readStderr)
self.print_next_error_lines = 0
self.print_next_error_file = False
def __del__(self):
self.terminate()
def start(self, cmd, env_vars=None, working_dir=None):
""" Start process and return immediately """
self.print_next_error_lines = 0
self.print_next_error_file = False
env = QtCore.QProcessEnvironment.systemEnvironment()
if env_vars:
for key in env_vars:
env.insert(key, env_vars[key])
self.process.setProcessEnvironment(env)
if working_dir:
self.process.setWorkingDirectory(working_dir)
if platform.system() == "Windows":
# Run through a wrapper process to allow clean termination
cmd = [
os.path.join(FreeCAD.getHomePath(), "bin", "python.exe"),
'-u', # Prevent python from buffering stdout
os.path.join(os.path.dirname(__file__), "WindowsRunWrapper.py")
] + cmd
print("Raw command: ", cmd)
self.process.start(cmd[0], cmd[1:])
def terminate(self):
if platform.system() == "Windows":
# terminate() doesn't operate and kill() doesn't allow cleanup and leaves mpi processes running
# Instead, instruct wrapper program to kill child process and itself cleanly with ctrl-break signal
self.process.write(b"terminate\n")
self.process.waitForBytesWritten() # 'flush'
else:
self.process.terminate()
self.process.waitForFinished()
def finished(self, exit_code):
if self.finishedHook:
self.finishedHook(exit_code)
def readStdout(self):
# Ensure only complete lines are passed on
text = ""
while self.process.canReadLine():
byteArr = self.process.readLine()
text += QTextStream(byteArr).readAll()
if text:
print(text, end='') # Avoid displaying on FreeCAD status bar
if self.stdoutHook:
self.stdoutHook(text)
# Must be at the end as it can cause re-entrance
if FreeCAD.GuiUp:
FreeCAD.Gui.updateGui()
def readStderr(self):
# Ensure only complete lines are passed on
# Print any error output to console
self.process.setReadChannel(QProcess.StandardError)
text = ""
while self.process.canReadLine():
byteArr = self.process.readLine()
text += QTextStream(byteArr).readAll()
if text:
if self.stderrHook:
self.stderrHook(text)
FreeCAD.Console.PrintError(text)
# Must be at the end as it can cause re-entrance
if FreeCAD.GuiUp:
FreeCAD.Gui.updateGui()
self.process.setReadChannel(QProcess.StandardOutput)
def state(self):
return self.process.state()
def waitForStarted(self):
return self.process.waitForStarted()
def waitForFinished(self):
# For some reason waitForFinished doesn't always return - so we resort to a failsafe timeout:
while True:
ret = self.process.waitForFinished(1000)
if self.process.error() != self.process.Timedout:
self.readStdout()
self.readStderr()
return ret
if self.process.state() == self.process.NotRunning:
self.readStdout()
self.readStderr()
return True
def exitCode(self):
return self.process.exitCode()
def processErrorOutput(self, err):
"""
Process standard error text output from OpenFOAM
:param err: Standard error output, single or multiple lines
:return: A message to be printed on console, or None
"""
ret = ""
errlines = err.split('\n')
for errline in errlines:
if len(errline) > 0: # Ignore blanks
if self.print_next_error_lines > 0:
ret += errline + "\n"
self.print_next_error_lines -= 1
if self.print_next_error_file and "file:" in errline:
ret += errline + "\n"
self.print_next_error_file = False
words = errline.split(' ',
1) # Split off first field for parallel
FATAL = "--> FOAM FATAL ERROR"
FATALIO = "--> FOAM FATAL IO ERROR"
if errline.startswith(FATAL) or (len(words) > 1 and
words[1].startswith(FATAL)):
self.print_next_error_lines = 1
ret += "OpenFOAM fatal error:\n"
elif errline.startswith(FATALIO) or (
len(words) > 1 and words[1].startswith(FATALIO)):
self.print_next_error_lines = 1
self.print_next_error_file = True
ret += "OpenFOAM IO error:\n"
if len(ret) > 0:
return ret
else:
return None
class TestPython(object):
def __init__(self, ID=None):
self.Test = QProcess()
self.ID = ID
#a and b to test if i get a output or command error
self.a = True
self.Settings = QtCore.QSettings('Tyrant.cfg',
QtCore.QSettings.IniFormat)
def TestVersion(self):
print('Test python version')
self.Test.readyReadStandardError.connect(self.getOutput)
self.Test.readyReadStandardOutput.connect(self.getOutput)
if self.ID is not None:
self.Test.error.connect(self.Error)
#if i have a custom pythonpath, i'll use it here
Res = Resources()
Python = Res.getPref('Python')
#test if is a pythonpath, if not open a default
if len(Python) < 5:
Python = 'python'
self.Test.start(Python, ['-V'])
self.Test.waitForFinished()
self.Test.terminate()
if (self.a is False) & (self.ID is None):
#test a diferent command to run python 2.7
a = self.TestVersion2()
print a
return a
elif self.a:
#say to program that python is working
print('Python version found')
self.Settings.setValue('Python/PythonPath', str(Python))
self.Settings.sync()
return True
elif ((self.ID is not None) & (self.a is False)):
return False
def Error(self):
self.a = False
def TestVersion2(self):
print('Testing python version 2')
self.Test.readyReadStandardError.connect(self.getOutput)
Python = 'python2.7'
self.Test.start(Python, ['-V'])
self.Test.waitForStarted()
self.Test.waitForFinished()
self.Test.terminate()
if (self.a is False):
#say thar python is not working
return False
else:
self.Settings.setValue('Python/PythonPath', str(Python))
self.Settings.sync()
return True
def getOutput(self):
Out = str(self.Test.readAllStandardError())
print(Out)
if Out > 'Python 2.8':
self.a = False
return
self.a = True
def generate_completes2(force=False):
# check parsed functions
cache_file = vex_settings.get_autocomplete_cache_file()
if os.path.exists(cache_file) and not force:
return True
# get vcc
vcc = os.path.join(hou.getenv('HFS'), 'bin', 'vcc').replace('/','\\')
if os.name == 'nt':
vcc = vcc + '.exe'
if not os.path.exists(vcc):
return False
# generate new
funcs = {}
attrs = {}
process = QProcess()
process.start(' '.join([vcc, '-X']))
process.waitForFinished()
lines = str(process.readAll()).split('\n')
for context in lines:
if context:
process.start(' '.join([vcc, '-X', context]))
process.waitForFinished()
context_lines = str(process.readAll())
# variables
variables = re.search(r'Global Variables:(.*)Control Statements:', context_lines, re.DOTALL)
if variables:
lines = variables.group(1).strip().split('\n')
for l in lines:
s = l.split()
if len(s)==3:
attrs[s[-1]] = s[-2]
# functions
pat = r'^\s*(\w+\[?\]?)\s(\w+)(\(.+\))'
for l in context_lines.split('\n'):
func = re.findall(pat, str(l))
if func:
if func[0][1] in funcs:
funcs[func[0][1]].append({'ret': func[0][0], 'args':func[0][2]})
else:
funcs[func[0][1]] = [{'ret': func[0][0], 'args':func[0][2]}]
# save to cache
if os.path.exists(cache_file):
comp = json.load(open(cache_file))
else:
comp = {}
comp['functions'] = funcs
comp['attributes'] = attrs
json.dump(comp, open(cache_file, 'w'))
return True
class VideoMediaView(MediaView):
def __init__(self, media, parent):
super(VideoMediaView, self).__init__(media, parent)
self._widget = QWidget(parent)
self._process = QProcess(self._widget)
self._process.setObjectName('%s-process' % self.objectName())
self._std_out = []
self._errors = []
self._stopping = False
self._mute = False
if 'mute' in self._options:
self._mute = bool(int(self._options['mute']))
self._widget.setGeometry(media['_geometry'])
self.connect(self._process, SIGNAL("error()"), self._process_error)
self.connect(self._process, SIGNAL("finished()"), self.stop)
self.connect(self._process, SIGNAL("readyReadStandardOutput()"),
self.__grep_std_out)
self.set_default_widget_prop()
self._stop_timer = QTimer(self)
self._stop_timer.setSingleShot(True)
self._stop_timer.setInterval(1000)
self._stop_timer.timeout.connect(self._force_stop)
@Slot()
def _force_stop(self):
os.kill(self._process.pid(), signal.SIGTERM)
self._stopping = False
if not self.is_started():
self.started_signal.emit()
super(VideoMediaView, self).stop()
@Slot(object)
def _process_error(self, err):
self._errors.append(err)
self.stop()
@Slot()
def play(self):
self._finished = 0
path = "%s/%s" % (self._save_dir, self._options['uri'])
self._widget.show()
args = [
'-slave', '-identify', '-input',
'nodefault-bindings:conf=/dev/null', '-wid',
str(int(self._widget.winId())), path
]
if self._mute:
args += ['-ao', 'null']
self._process.start('mplayer', args)
self._stop_timer.start()
@Slot()
def stop(self, delete_widget=False):
if self._stopping or self.is_finished():
return False
self._stop_timer.start()
self._stopping = True
if self._process.state() == QProcess.ProcessState.Running:
self._process.write("quit\n")
self._process.waitForFinished(50)
self._process.close()
super(VideoMediaView, self).stop(delete_widget)
self._stopping = False
self._stop_timer.stop()
return True
@Slot()
def __grep_std_out(self):
lines = self._process.readAllStandardOutput().split("\n")
for line in lines:
if not line.isEmpty():
if line.startsWith("Starting playback"):
self._widget.raise_()
self._play_timer.start()
self.started_signal.emit()
self._stop_timer.stop()
else:
part = line.split("=")
if 'ID_LENGTH' == part[0]:
if float(
self._duration
) > 0: # user set the video duration manually.
self._play_timer.setInterval(
int(1000 * float(self._duration)))
else: # use duration found by mplayer.
self._play_timer.setInterval(
int(1000 * float(part[1])))
