def transpile_package(package, language): """ translate from crop2ml package""" sourcef = package namep = sourcef.split(".")[0] pkg = Path(sourcef) models = model_parser( pkg) # parse xml files and create python model object output = Path(os.path.join(pkg, 'src')) dir_test = Path(os.path.join(pkg, 'test')) # Generate packages if the directories does not exists. if not output.isdir(): output.mkdir() if not dir_test.isdir(): dir_test.mkdir() m2p = render_cyml.Model2Package(models, dir=output) m2p.generate_package() # generate cyml models in "pyx" directory tg_rep = Path(os.path.join( output, language)) # target language models directory in output dir_test_lang = Path(os.path.join(dir_test, language)) if not tg_rep.isdir(): tg_rep.mkdir() if not dir_test_lang.isdir(): #Create if it doesn't exist dir_test_lang.mkdir() m2p.write_tests() # generate cyml functions cyml_rep = Path(os.path.join(output, 'pyx')) # cyml model directory in output # cretae topology of composite model T = Topology(namep, package) namep = T.model.name.lower() # domain class if language in domain_class: getattr( getattr(pycropml.transpiler.generators, '%sGenerator' % NAMES[language]), 'to_struct_%s' % language)([T.model], tg_rep, namep) # wrapper if language in wrapper: getattr( getattr(pycropml.transpiler.generators, '%sGenerator' % NAMES[language]), 'to_wrapper_%s' % language)(T.model, tg_rep, namep) # Transform model unit to languages and platforms for k, file in enumerate(cyml_rep.files()): with open(file, 'r') as fi: source = fi.read() name = os.path.split(file)[1].split(".")[0] for model in models: # in the case we have'nt the same order if name.lower() == model.name.lower( ) and prefix(model) != "function": test = Main(file, language, model, T.model.name) test.parse() test.to_ast(source) code = test.to_source() filename = Path( os.path.join(tg_rep, "%s.%s" % (name.capitalize(), ext[language]))) with open(filename, "wb") as tg_file: tg_file.write(code.encode('utf-8')) Model2Nb(model, code, name, dir_test_lang).generate_nb(language, tg_rep, namep) #code2nbk.generate_notebook(code, name, dir_nb_lang) # Create Cyml Composite model T_pyx = T.algo2cyml() fileT = Path(os.path.join(cyml_rep, "%sComponent.pyx" % namep)) with open(fileT, "wb") as tg_file: tg_file.write(T_pyx.encode('utf-8')) filename = Path( os.path.join(tg_rep, "%sComponent.%s" % (namep.capitalize(), ext[language]))) with open(filename, "wb") as tg_file: tg_file.write(T.compotranslate(language).encode('utf-8')) status = 0 return status
from path import Path from natsort import natsorted files = natsorted(Path('../data/averaged/').glob('*.xyz')) content = \ """ universe = vanilla requirements = (OpSys == "LINUX") && (OpSysMajorVer == 6) executable = condor_run.sh arguments = $(Process) output = condor_outputs/$(Cluster)_$(Process).out error = condor_errors/$(Cluster)_$(Process).err log = $(Cluster).log should_transfer_files = YES when_to_transfer_output = ON_EXIT transfer_input_files = ../data/clusters.tar.gz, condor_run.sh, ../data/averaged transfer_output_files = ppm3d_correct/analysis/data/motif_results, ppm3d_correct/analysis/data/motif_errors request_cpus = 1 request_memory = 2GB request_disk = 2GB queue arguments from ( {} ) """.format("\n".join(files)) open("submit.sub", "w").write(content)
def crop(filename): file_path = Path(app.config['UPLOADED_CROP_DEST']) / filename if file_path.exists() and file_path.isfile(): return Path(app.config['PATH_CROP_KEY']) / filename return filename
import json from path import Path from collections import OrderedDict from quran import read_quran, read_simple, read_lines from almizan import read_tafsir, section_ayas, refine_numbers, resolve_footnotes, refine_section, resolve_phrases, resolve_headers USE_ALMIZAN_TRANSLATION = False data = Path('data') files = Path('../files') # read quran data ayas, suras = read_quran(open(data / 'quran.txt')) read_simple(open(data / 'quran-simple.txt'), ayas) pages = read_lines(open(data / 'quran-lines.txt'), ayas) # write quran pages with open(files / 'quran' / 'all', 'w') as quran_file: format = lambda aya: OrderedDict([('page', aya['page']), ('text', aya['text']), ('raw', aya['raw']), ('id', aya['id'])]) for p, ids in pages.items(): page = '\n'.join( [json.dumps(format(ayas[id]), ensure_ascii=False) for id in ids]) print(page, file=open(files / 'quran' / ('p%d' % p), 'w')) print(page, file=quran_file) # almizan almizan_sections, phrases, headers, translations = [], [], [], {} for ar_section, fa_section in zip(read_tafsir(open(data / 'almizan_ar.html')), read_tafsir(open(data / 'almizan_fa.html'))):
def module_tmpdir(request, tmpdir_factory, logger): suffix = request.module.__name__ temp_dir = Path(tmpdir_factory.mktemp(suffix)) logger.info('Created temp folder: %s', temp_dir) return temp_dir
def read(self, filename): filename = Path(filename).abspath() ret = elf_read_firmware(str(filename), self.backend) if ret == -1: raise ValueError(filename + ' could not be loaded!') self.filename = filename
def generate_project_scratch_dir(experiment): project_subdir = '{user_id}_{project}'.format(user_id=experiment.user_id, project=experiment.project) scratch_subdir = (experiment.scratch_subdir or DEFAULT_SCRATCH_SUBDIR) return Path(experiment._slurm_scratch_dir) / scratch_subdir / project_subdir
def run(ctx, neptune, spec, tags, requirements_file, base_image, script, params): """Run experiment""" context = ctx.obj['context'] # validate options and arguments requirements = requirements_file and [ req.strip() for req in Path(requirements_file).open('r') ] or [] if context['backend_type'] == 'kubernetes' and not base_image: raise click.ClickException('Provide docker base image') if context['backend_type'] == 'kubernetes' and not requirements_file: raise click.ClickException('Provide requirements.txt file') script_has_spec = get_experiments_spec_handle(script, spec) is not None neptune_support = context.get('neptune', None) or neptune if neptune_support and not neptune and not script_has_spec: raise click.ClickException( 'Neptune support is enabled in context ' 'but no neptune config or python experiment descriptor provided') if neptune and script_has_spec: raise click.ClickException( 'Provide only one of: neptune config or python experiment descriptor' ) if not neptune_support: # TODO: implement it if possible raise click.ClickException( 'Currentlu doesn\'t support experiments without neptune') neptune_dir = None try: # prepare neptune directory in case if neptune yamls shall be generated if neptune_support and not neptune: script_path = Path(script) neptune_dir = script_path.parent / 'neptune_{}'.format( script_path.stem) neptune_dir.makedirs_p() for neptune_path, experiment in generate_experiments( script, neptune, context, spec=spec, neptune_dir=neptune_dir): experiment.update({ 'base_image': base_image, 'requirements': requirements }) if neptune_support: script = experiment.pop('script') cmd = ' '.join([script] + list(params)) # tags from neptune.yaml will be extracted by neptune additional_tags = context.get('tags', []) + list(tags) cmd = NeptuneWrapperCmd(cmd=cmd, experiment_config_path=neptune_path, neptune_storage=context['storage_dir'], paths_to_dump=None, additional_tags=additional_tags) experiment['cmd'] = cmd experiment.setdefault('paths_to_copy', []) for possible_token_path in [ '~/.neptune_tokens/token', '~/.neptune/tokens/token' ]: neptune_path = Path( possible_token_path).expanduser().abspath() if neptune_path.exists(): neptune_token_files = experiment.setdefault( 'neptune_token_files', []) neptune_token_files.append(str(neptune_path)) assert len(experiment.get('neptune_token_files', [])) < 2, \ 'You have multiple neptune tokens ({}); remove obsolete'.format( ', '.join(experiment['neptune_token_files'])) else: # TODO: implement no neptune version # TODO: for sbatch set log path into something like os.path.join(resource_dir_path, "job_logs.txt") raise click.ClickException('Not implemented yet') run_kwargs = {'experiment': experiment} backend = { 'kubernetes': KubernetesBackend, 'slurm': SlurmBackend }[experiment['backend_type']]() # TODO: add calling experiments in parallel backend.run(**run_kwargs) finally: if neptune_dir: neptune_dir.rmtree_p()
def get_default_config_path(ctx): default_config_file_name = 'config.yaml' app_name = Path(ctx.command_path).stem app_dir = Path(click.get_app_dir(app_name)) return app_dir / default_config_file_name
help='Whether to tank the images after they have been scored') parser.add_argument('-out', type=str, default=None, help='save the result to file') args = parser.parse_args() resize_image = args.resize.lower() in ("true", "yes", "t", "1") target_size = (224, 224) if resize_image else None rank_images = args.rank.lower() in ("true", "yes", "t", "1") # give priority to directory if args.dir is not None: print("Loading images from directory : ", args.dir) imgs = Path(args.dir).files('*.png') imgs += Path(args.dir).files('*.jpg') imgs += Path(args.dir).files('*.jpeg') elif args.img[0] is not None: print("Loading images from path(s) : ", args.img) imgs = args.img else: raise RuntimeError( 'Either -dir or -img arguments must be passed as argument') if args.out is None: raise RuntimeError('Please specify the output') with tf.device('/GPU:0'):
def get_repository(): config = twittback.config.read_config() db_path = Path(config["db"]["path"]) db_path.parent.makedirs_p() return Repository(db_path)
# Run the following command in terminal to connect to redis channel # docker run -p 6379:6379 -d redis:5 User = get_user_model() #Initializing DeepCorrect corrector = DeepCorrect( '/home/pranshu/GAMR/gamr/meetingmode/deepcorrect/deeppunct_params_en', '/home/pranshu/GAMR/gamr/meetingmode/deepcorrect/deeppunct_checkpoint_google_news' ) #Initializing dataset for LexRank print('loading dataset and initializing...') documents = [] documents_dir = Path('/home/pranshu/GAMR/gamr/meetingmode/total') for file_path in documents_dir.files('*.txt'): with file_path.open(mode='rt', encoding='latin1') as fp: documents.append(fp.readlines()) lxr = LexRank(documents, stopwords=STOPWORDS['en']) print('dataset load done!') print('server is running!') class ChatConsumer(AsyncWebsocketConsumer): async def connect(self): self.room_name = self.scope['url_route']['kwargs']['meeting_code'] self.room_group_name = 'meeting_%s' % self.room_name # Join room group
#!/usr/bin/env python from __future__ import absolute_import, division __version__ = "$Revision: 1.5 $" import inspect import logging import logging.config from path import Path import sys LOGGINGRC_PATH = Path("~/.loggingrc").expand() if LOGGINGRC_PATH.exists(): logging.config.fileConfig(LOGGINGRC_PATH) else: logging.basicConfig() class autolog(object): def __init__(self): self._name = self._get_name() self._logger = logging.getLogger(self._name) def __getitem__(self, name): if name.startswith("."): name = self._name + name return logging.getLogger(name) def __getattr__(self, name): """
# full list see the documentation: # http://www.sphinx-doc.org/en/master/config from __future__ import absolute_import, unicode_literals import datetime import os import sys from subprocess import check_call import django import edx_theme import six from path import Path root = Path('../..').abspath() # Hack the PYTHONPATH to match what LMS and Studio use so all the code # can be successfully imported sys.path.insert(0, root) sys.path.append(root / "docs/guides") sys.path.append(root / "cms/djangoapps") sys.path.append(root / "common/djangoapps") sys.path.append(root / "common/lib/capa") sys.path.append(root / "common/lib/safe_lxml") sys.path.append(root / "common/lib/symmath") sys.path.append(root / "common/lib/xmodule") sys.path.append(root / "lms/djangoapps") sys.path.append(root / "lms/envs") sys.path.append(root / "openedx/core/djangoapps") sys.path.append(root / "openedx/features")
def initialize_train(parser): print("=> initializing train") args = parser.parse_args() save_path = save_path_formatter(args, parser) # workers to 0 in pycharm isRunningInPyCharm = "PYCHARM_HOSTED" in os.environ if isRunningInPyCharm: print('=> Pycharm mode - setting workers to 0') args.save_path = save_path = 'pycharm_' + save_path else: print('=> Shell mode - full settings') if args.DEBUG: args.save_path = save_path = 'debug_' + save_path args.print_freq = 5 args.epoch_size = 10 args.epochs = 10 try: stats_file = open(os.path.join(args.data, "stats.txt"), "r") args.std_vals = [float(val) for val in stats_file.readline().split('[')[1].split(']')[0].split()] args.mean_vals = [float(val) for val in stats_file.readline().split('[')[1].split(']')[0].split()] stats_file.close() except: args.std_vals = [0.5, 0.5, 0.5] args.mean_vals = [0.5, 0.5, 0.5] if args.final_act=='sigmoid' or args.final_act=='sigmoid4x' or args.final_act=='clamp01': args.norm_mm_by_act=[0, 1] else: args.norm_mm_by_act=[] #when only 1 channel out dont calc correlation loss if args.out_channels==1: args.multi_channel_corr_weight = 0 #when working channelwise use always i=out=1 for network if args.channel_wise: args.out_channels=1 args.in_channels=1 if args.final_act == 'None': args.final_act = None args.save_path = 'checkpoints' / save_path if args.manual_save_path is not None: args.save_path = 'checkpoints' / Path(args.manual_save_path) print('=> will save everything to {}'.format(args.save_path)) args.save_path.makedirs_p() torch.manual_seed(args.seed) # saving execution args to file with open(args.save_path / 'args_in_run.txt', 'w') as f: f.write("command line in run:\n") f.write(' '.join(sys.argv[1:])) f.write("\n\nargs in run:\n") for a in vars(args): f.write('--{} {}\n'.format(a, getattr(args, a))) f.close() # define writers for Tensorboard training_writer = SummaryWriter(args.save_path) return training_writer, args
def getWebDriverInstance(self): """ Get WebDriver Instance based on the browser configuration Returns: 'WebDriver Instance' """ baseURL = "https://www.xome.com/" items = [] if self.browser != "none" and self.os == "none": if self.browser == "safari": driver = webdriver.Safari() self.log.info("Running Safari Tests") elif self.browser == "firefox": #driver = webdriver.Firefox(executable_path=r'./zfiles/geckodriver') driverpath = os.path.join(self.thisdir, 'zfiles/geckodriver') driver = webdriver.Firefox(executable_path=driverpath) self.log.info("Running Firefox Tests") elif self.browser == "chrome": # Set chrome driver #driver = webdriver.Chrome(executable_path=r'./zfiles/chromedriver') driverpath = os.path.join(self.thisdir, 'zfiles/chromedriver') driver = webdriver.Chrome(executable_path=driverpath) self.log.info("Running Chrome Tests") # Loading browser with App URL driver.get(baseURL) # Maximize the window driver.maximize_window() #driver.set_window_size(1440, 900) # mac 15inch screen resolution time.sleep(5) # Setting Driver Implicit Time out for An Element driver.implicitly_wait(30) items.append(driver) items.append(self.browser) items.append(self.os) items.append(self.thisdir) return items elif self.browser == "none" and self.os != "none": desired_caps = {} if self.os == "android": desired_caps['platformName'] = 'Android' desired_caps['platformVersion'] = '7.1.1' desired_caps['automationName'] = 'uiautomator2' desired_caps['deviceName'] = 'Nexus' desired_caps['appPackage'] = "com.xome.android" #adb shell dumpsys window windows|grep -E 'mCurrentFocus' to get app info desired_caps[ 'appActivity'] = "com.xome.android.ui.map.MapActivity2" desired_caps['newCommandTimeout'] = 120 #desired_caps['app'] = Path('../zfiles/base.apk') appzpath = os.path.join(self.thisdir, 'zfiles/base.apk') desired_caps['app'] = Path(appzpath) driver = appdriver.Remote("http://localhost:4723/wd/hub", desired_caps) self.log.info("Running Android Tests") items.append(driver) items.append(self.browser) items.append(self.os) items.append(self.thisdir) return items elif self.os == "ios": desired_caps['platformName'] = 'iOS' desired_caps['platformVersion'] = '10.3.3' desired_caps['automationName'] = 'xcuitest' desired_caps['deviceName'] = 'iPhone 5' desired_caps[ 'udid'] = '8319807bbbc1d04c9bbc0634e14d28aca946b536' desired_caps['xcodeOrgid'] = 'Angela Tong' desired_caps['xcodeSigningId'] = 'iPhone Developer' desired_caps['newCommandTimeout'] = 120 #desired_caps['app'] = Path('../zfiles/base.apk') appzpath = os.path.join(self.thisdir, 'zfiles/base.ipa') desired_caps['app'] = Path(appzpath) driver = appdriver.Remote("http://localhost:4723/wd/hub", desired_caps) self.log.info("Running iOS Tests") items.append(driver) items.append(self.browser) items.append(self.os) items.append(self.thisdir) return items else: self.log.info( "Have to enter a value for both browser and os. Please enter --browser none for appium automation or --os none for selenium automation" )
required=True) location = schema.TextLine(title=_(u"label_location", default=u"Location"), max_length=256, required=False) start = UTCDatetime(title=_('label_start', default=u"Start"), required=True) end = UTCDatetime(title=_('label_end', default=u"End"), required=False) ADD_MEETING_STEPS = (('add-meeting', _(u'Add Meeting')), ('add-meeting-dossier', _(u'Add Dossier for Meeting'))) TEMPLATES_DIR = Path(__file__).joinpath('..', 'templates').abspath() def get_dm_key(committee_oguid=None): """Return the key used to store meeting-data in the wizard-storage.""" committee_oguid = committee_oguid or get_committee_oguid() return 'create_meeting:{}'.format(committee_oguid) def get_committee_oguid(): return Oguid.parse(getRequest().get('committee-oguid')) class AddMeetingWizardStep(BaseWizardStepForm, Form): step_name = 'add-meeting' label = _('Add Meeting')
from path import Path from itertools import chain import os # get all files d = Path('./'); # text files config = d.walkfiles(".*"); md = d.walkfiles("*.md"); licensefiles = d.walkfiles("*.license"); # concat all lists files = chain(md, config, licensefiles); # delete them for file in files: print("Deleting :" + file); file.remove() # compress media files mp3 = d.walkfiles("*.mp3"); m4a = d.walkfiles("*.m4a"); wav = d.walkfiles("*.wav"); # concat all lists allmedia = chain(mp3, m4a, wav); # compress for media in allmedia: directory = os.path.dirname(media);
import re import pytest from path import Path import nodely TEST_DIR = ( Path(__file__) # pylint: disable=no-value-for-parameter .realpath().dirname()) exec((TEST_DIR / 'variables.py').text()) @pytest.fixture def node_package(): return NODE_PACKAGE # pylint: disable=undefined-variable @pytest.fixture def install_node_package(node_package): nodely.install(node_package) @pytest.fixture def node_package_command(): return 'coffee' @pytest.fixture def node_package_command_args():
from path import Path from asm1.main.play_one_game import play_one_game from asm1.model.hex_board import HexBoard from asm1.model.search import Search import trueskill as ts from itertools import combinations import matplotlib.pyplot as plt from others.system_config import SystemConfig from util.common_util import CommonUtil from util.plot_util import PlotUtil if __name__ == '__main__': save_dir_path: str = SystemConfig.FILE_OUTPUT_HOME_DIR + CommonUtil.generate_date_time_str( ) + "_" + Path(__file__).stem print("start_time", CommonUtil.generate_date_time_str(), "file_path", save_dir_path) CommonUtil.make_dir(save_dir_path) board_size: int = 4 num_of_games_to_run = 500 data_analysis_interval: int = 20 is_save_data: bool = True mcts_cp: int = 2 mcts_search_iterations: int = 100 player_random_3 = Search(
import click import logging import logging.config import yaml from path import Path from qface.generator import FileSystem, RuleGenerator from qface.helper.qtcpp import Filters from qface.helper.doc import parse_doc from qface.watch import monitor from qface.shell import sh import qface.filters from jinja2 import environmentfilter here = Path(__file__).dirname() logging.basicConfig() log_config = Path('log.yaml') if log_config.exists(): logging.config.dictConfig(yaml.load(log_config.open('r'))) log = logging.getLogger(__name__) features = set() class CustomFilters: @staticmethod def path(symbol):
def test__getitem__(self, node_package_command): command = nodely.bin[node_package_command] assert type(command) is Command assert Path(command).normcase() \ == nodely.which(node_package_command).normcase()
def main(): args = parser.parse_args() model = get_depth_model(args.model_name).to(device) weights = torch.load(args.model_path) # weights = torch.load(args.model_path, map_location=lambda storage, loc: storage) model.load_state_dict(weights['model_state']) model.eval() seq_length = 0 dataset_dir = Path(args.dataset_dir) with open(args.dataset_list, 'r') as f: test_files = list(f.read().splitlines()) framework = test_framework(dataset_dir, test_files, seq_length, args.min_depth, args.max_depth) print('{} files to test'.format(len(test_files))) errors = np.zeros((2, 7, len(test_files)), np.float32) for j, sample in enumerate(tqdm(framework)): tgt_img = sample['tgt'] # [375, 1242, 3] ndarray, original RGB image h, w, _ = tgt_img.shape if h != args.img_height or w != args.img_width: tgt_img = imresize( tgt_img, (args.img_height, args.img_width)).astype(np.float32) tgt_img = np.transpose(tgt_img, (2, 0, 1)) tgt_img = torch.from_numpy(tgt_img).unsqueeze(0) tgt_img = ((tgt_img / 255 - 0.5) / 0.5).to( device) # normalize to [-1, 1] pred = model(tgt_img).cpu().numpy()[0, 0] gt_depth = sample['gt_depth'] if args.pred_disp: pred_depth = 1 / pred else: pred_depth = pred # upsample to gt depth resolution, [375, 1242] # and mask out pixels with depth not in [min_depth, max_depth] pred_depth_zoomed = zoom( pred_depth, (gt_depth.shape[0] / pred_depth.shape[0], gt_depth.shape[1] / pred_depth.shape[1])).clip(args.min_depth, args.max_depth) if sample['mask'] is not None: pred_depth_zoomed = pred_depth_zoomed[sample['mask']] gt_depth = gt_depth[sample['mask']] errors[1, :, j] = compute_errors(gt_depth, pred_depth_zoomed) mean_errors = errors.mean(2) error_names = ['abs_rel', 'sq_rel', 'rms', 'log_rms', 'a1', 'a2', 'a3'] print("Results : ") print("{:>10}, {:>10}, {:>10}, {:>10}, {:>10}, {:>10}, {:>10}".format( *error_names)) print( "{:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}, {:10.4f}". format(*mean_errors[1]))
def test__getattr__(self, node_package_command): command = getattr(nodely.bin, node_package_command) assert type(command) is Command assert Path(command).normcase() \ == nodely.which(node_package_command).normcase()
release = pkg_version[0:-42] else: # Or we try to get it from Resources try: pkg_version = open('../Resources/exe/version').readline() release = pkg_version[0:-42] except: release = "unknown" # We try to get the revision from the version file (if it exists) revision = pkg_version[-40:] if pkg_version else '' # Compose version string version = release + "-r" + revision if revision else release # SNAP version and release snap_environ = os.environ.get('SNAP') if snap_environ: try: snap_base_path = Path(snap_environ) changelog_path = snap_base_path / 'lib'/ 'python2.7' / 'site-packages' / 'usr' / 'share' / 'exe' / 'ChangeLog' line = open(changelog_path).readline() release = line.split(':')[1].split(')')[0] version = release revision = release except: pass # If this file is executed directly, we print the project and version info if __name__ == '__main__': print project, version
def test__new__(self, node_package_command): command = Command(node_package_command) assert Path(command).normcase() \ == nodely.which(node_package_command).normcase()
import os from time import sleep import fabric import vagrant from entrypoint2 import entrypoint from path import Path # pip3 install fabric vncdotool python-vagrant entrypoint2 DIR = Path(__file__).parent.parent.parent class Options: halt = True recreate = True destroy = False def run_box(options, vagrantfile, cmds): env = os.environ env["VAGRANT_VAGRANTFILE"] = DIR / vagrantfile if vagrantfile != "Vagrantfile": env["VAGRANT_DOTFILE_PATH"] = DIR / ".vagrant_" + vagrantfile else: env["VAGRANT_DOTFILE_PATH"] = "" v = vagrant.Vagrant(env=env, quiet_stdout=False, quiet_stderr=False) status = v.status() state = status[0].state print(status)
par.add_argument('action', choices=['draw_roc', 'roc5_stats']) par.add_argument('args') par.add_argument('-xlim', type=int, default=500) par.add_argument('-ylim', type=int, default=900) par.add_argument('-max_evalue', type=float, default=1) par.add_argument('-rocn_max_evalue', type=float) par.add_argument('-standards', nargs='+', choices=["fold", "superfamily", "JG"]) par.add_argument('--compare', action="store_true") args = par.parse_args() ARGS = json.load(open(args.args)) if args.action == "draw_roc": name = ARGS['benchmark'] Path("./fig").mkdir_p() draw_SF(ARGS, './fig/ROC_' + name + '_' + '_'.join(args.standards), args.standards, xlim=args.xlim, ylim=args.ylim, dpi=600, max_evalue=args.max_evalue, rocn_max_evalue=args.rocn_max_evalue) elif args.action == "roc5_stats": calc_rocn_stats(ARGS, args.standards[0], max_evalue=args.max_evalue, rocn_max_evalue=args.rocn_max_evalue)
def inject_static_file(filepath): data = None with open(Path(app.static_folder) / filepath, 'r') as f: data = f.read() return Markup(data)
def _save(s): Path(s.path).write_text(s.as_text)