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 get_output(cmd): if isinstance(cmd, list): cmd = ' '.join(cmd) process = QProcess() process.start(cmd) process.waitForFinished() return str(process.readAll())
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 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 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, 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 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: f_name = func[0][1] f_args = func[0][2] if f_name in funcs: if not f_args in funcs[f_name].get('args', []): funcs[f_name]['args'].append(f_args) else: funcs[f_name] = {'args': [f_args]} # parse help if Houdini 15 if hou.applicationVersion()[0] >= 15: funcs = parse_help(funcs) # 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
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): 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 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 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)
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 __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 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) 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 __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 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
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
def __init__(self, parent=None): super(RobocompDslGui, self).__init__(parent) self.setWindowTitle("Create new component") # self._idsl_paths = [] self._communications = { "implements": [], "requires": [], "subscribesTo": [], "publishes": [] } self._interfaces = {} self._cdsl_doc = CDSLDocument() self._command_process = QProcess() self._main_widget = QWidget() self._main_layout = QVBoxLayout() self.setCentralWidget(self._main_widget) self._name_layout = QHBoxLayout() self._name_line_edit = QLineEdit() self._name_line_edit.textEdited.connect(self.update_component_name) self._name_line_edit.setPlaceholderText("New component name") self._name_layout.addWidget(self._name_line_edit) self._name_layout.addStretch() # DIRECTORY SELECTION self._dir_line_edit = QLineEdit() # self._dir_line_edit.textEdited.connect(self.update_completer) self._dir_completer = QCompleter() self._dir_completer_model = QFileSystemModel() if os.path.isdir(ROBOCOMP_COMP_DIR): self._dir_line_edit.setText(ROBOCOMP_COMP_DIR) self._dir_completer_model.setRootPath(ROBOCOMP_COMP_DIR) self._dir_completer.setModel(self._dir_completer_model) self._dir_line_edit.setCompleter(self._dir_completer) self._dir_button = QPushButton("Select directory") self._dir_button.clicked.connect(self.set_output_directory) self._dir_layout = QHBoxLayout() self._dir_layout.addWidget(self._dir_line_edit) self._dir_layout.addWidget(self._dir_button) # LIST OF ROBOCOMP INTERFACES self._interface_list = QListWidget() self._interface_list.setSelectionMode( QAbstractItemView.ExtendedSelection) self._interface_list.itemSelectionChanged.connect( self.set_comunication) # LIST OF CONNECTION TyPES self._type_combo_box = QComboBox() self._type_combo_box.addItems( ["publishes", "implements", "subscribesTo", "requires"]) self._type_combo_box.currentIndexChanged.connect( self.reselect_existing) # BUTTON TO ADD A NEW CONNECTION # self._add_connection_button = QPushButton("Add") # self._add_connection_button.clicked.connect(self.add_new_comunication) self._add_connection_layout = QHBoxLayout() # self._add_connection_layout.addWidget(self._add_connection_button) self._language_combo_box = QComboBox() self._language_combo_box.addItems(["Python", "Cpp", "Cpp11"]) self._language_combo_box.currentIndexChanged.connect( self.update_language) self._add_connection_layout.addWidget(self._language_combo_box) self._add_connection_layout.addStretch() self._gui_check_box = QCheckBox() self._gui_check_box.stateChanged.connect(self.update_gui_selection) self._gui_label = QLabel("Use Qt GUI") self._add_connection_layout.addWidget(self._gui_label) self._add_connection_layout.addWidget(self._gui_check_box) # WIDGET CONTAINING INTERFACES AND TYPES self._selection_layout = QVBoxLayout() self._selection_layout.addWidget(self._type_combo_box) self._selection_layout.addWidget(self._interface_list) self._selection_layout.addLayout(self._add_connection_layout) self._selection_widget = QWidget() self._selection_widget.setLayout(self._selection_layout) # TEXT EDITOR WITH THE RESULTING CDSL CODE self._editor = QTextEdit(self) self._editor.setHtml("") self._document = self._editor.document() self._component_directory = None # SPLITTER WITH THE SELECTION AND THE CODE self._body_splitter = QSplitter(Qt.Horizontal) self._body_splitter.addWidget(self._selection_widget) self._body_splitter.addWidget(self._editor) self._body_splitter.setStretchFactor(0, 2) self._body_splitter.setStretchFactor(1, 9) # CREATION BUTTONS self._create_button = QPushButton("Create .cdsl") self._create_button.clicked.connect(self.write_cdsl_file) self._creation_layout = QHBoxLayout() self._creation_layout.addStretch() self._creation_layout.addWidget(self._create_button) self._console = QConsole() self._command_process.readyReadStandardOutput.connect( self._console.standard_output) self._command_process.readyReadStandardError.connect( self._console.error_output) # ADDING WIDGETS TO MAIN LAYOUT self._main_widget.setLayout(self._main_layout) self._main_layout.addLayout(self._name_layout) self._main_layout.addLayout(self._dir_layout) self._main_layout.addWidget(self._body_splitter) self._main_layout.addLayout(self._creation_layout) self._main_layout.addWidget(self._console) self.setMinimumSize(800, 500) self._editor.setText(self._cdsl_doc.generate_doc())
def testIt(self): self.arg = None p = QProcess() p.stateChanged.connect(self.slot) p.stateChanged.emit(QProcess.NotRunning) self.assertEqual(self.arg, QProcess.NotRunning)
def testArgsToNoArgsSignal(self): '''Passing arguments to a signal without arguments''' process = QProcess() self.assertRaises(TypeError, process.emit, SIGNAL('started()'), 42)
def testMoreArgs(self): '''Passing more arguments than needed''' process = QProcess() self.assertRaises(TypeError, process.emit, SIGNAL('finished(int)'), 55, 55)