def test_model(model_name, source_name, env_name, batch_size, vep=False, create_env=True, verbose=False): """kipoi test ... Args: model_name (str) source_name: source name """ if create_env: create_model_env(model_name, source_name, env_name, vep, verbose=verbose) # run the tests in the environment cmd = get_kipoi_bin(env_name) args = [ "test", "--batch_size", str(batch_size), "--source", source_name, model_name ] # New, modified path for conda. Source activate namely does the following: # - CONDA_DEFAULT_ENV=${env_name} # - CONDA_PREFIX=${env_path} # - PATH=$conda_bin:$PATH new_env = os.environ.copy() new_env['PATH'] = os.path.dirname(cmd) + os.pathsep + new_env['PATH'] returncode, logs = _call_command(cmd, args, use_stdout=True, return_logs_with_stdout=True, env=new_env) assert returncode == 0 # detect WARNING in the output log warn = 0 for line in logs: warn_start = escape_codes[default_log_colors['WARNING']] + \ 'WARNING' + escape_codes['reset'] if line.startswith(warn_start): logger.error("Warning present: {0}".format(line)) warn += 1 if warn > 0: raise ValueError("{0} warnings were observed for model {1}".format( warn, model_name))
def test_model(model_name, caplog): """kipoi test ... """ caplog.set_level(logging.INFO) source_name = "kipoi" assert source_name == "kipoi" env_name = conda_env_name(model_name, model_name, source_name) env_name = "test-" + env_name # prepend "test-" # if environment already exists, remove it if env_exists(env_name): print("Removing the environment: {0}".format(env_name)) remove_env(env_name) # create the model test environment args = [ "kipoi", "env", "create", "--source", source_name, "--env", env_name, model_name ] returncode = subprocess.call(args=args) assert returncode == 0 if model_name == "basenji": batch_size = str(2) else: batch_size = str(4) # run the tests in the environment args = [ get_kipoi_bin(env_name), "test", "--batch_size", batch_size, "--source", source_name, model_name ] returncode = subprocess.call(args=args) assert returncode == 0 for record in caplog.records: # there shoudn't be any warning assert record.levelname not in ['WARN', 'WARNING', 'ERROR', 'CRITICAL']
def cli_create(cmd, raw_args): """Create a conda environment for a model """ from kipoi_conda import get_kipoi_bin import uuid parser = argparse.ArgumentParser( 'kipoi env {}'.format(cmd), description='Create a conda environment for a specific model.') add_env_args(parser) parser.add_argument( '-e', '--env', default=None, help="Special environment name. default: kipoi-<model>[-<dataloader>]") parser.add_argument('--dry-run', action='store_true', help="Don't actually create the environment") parser.add_argument( '-t', '--tmpdir', default=None, help= ("Temporary directory path where to create the conda environment file" "Defaults to /tmp/kipoi/envfiles/<uuid>/")) parser.add_argument('-v', '--verbose', action='store_true', help="Increase output verbosity. Show conda stdout.") args = parser.parse_args(raw_args) # create the tmp dir if args.tmpdir is None: tmpdir = "/tmp/kipoi/envfiles/" + str(uuid.uuid4())[:8] else: tmpdir = args.tmpdir if not os.path.exists(tmpdir): os.makedirs(tmpdir) # write the env file logger.info("Writing environment file: {0}".format(tmpdir)) if args.model == ['all']: from kipoi.cli.source_test import get_common_env src = kipoi.get_source(args.source) model_envs = yaml.safe_load( open( os.path.join(src.local_path, SPECIAL_ENV_PREFIX, "models.yaml"))) # TODO - test this by mocking up the CLI command execution # setup the args for all the models df = kipoi.list_models() dfg = list_models_by_group(df, "") for model_group in dfg.group.unique().tolist(): existing_envs = get_envs_by_model(model_group, args.source, only_valid=True) if existing_envs or existing_envs is None: # No need to create the environment existing_envs_str = "\n".join( [e.create_args.env for e in existing_envs]) logger.info( "Environment for {} already exists ({}). Skipping installation" .format(model_group, existing_envs_str)) continue logger.info( "Environment doesn't exists for model group {}. Installing it". format(model_group)) # Figure out which <model> to use for installation common_env = get_common_env(model_group, model_envs) if common_env is not None: # common environment exists for the model. Use it logger.info("Using common environment: {}".format(common_env)) model_group = os.path.join(SPECIAL_ENV_PREFIX, common_env) # Run cli_create def optional_replace(x, ref, alt): if x == ref: return alt else: return x new_raw_args = [ optional_replace(x, 'all', model_group) for x in raw_args if x is not None ] cli_create(cmd, new_raw_args) logger.info("Done installing all environments!") return None env, env_file = export_env(args.model, args.dataloader, args.source, env_file=None, env_dir=tmpdir, env=args.env, vep=args.vep, interpret=args.interpret, gpu=args.gpu) if not args.dry_run: env_db_entry = generate_env_db_entry(args, args_env_overload=env) envdb = get_model_env_db() envdb.append(env_db_entry) envdb.save() # setup the conda env from file logger.info("Creating conda env from file: {0}".format(env_file)) kipoi_conda.create_env_from_file(env_file, use_stdout=args.verbose) env_db_entry.successful = True # env is environment name env_db_entry.cli_path = get_kipoi_bin(env) get_model_env_db().save() logger.info("Done!") print("\nActivate the environment via:") print("conda activate {0}".format(env)) else: print("Dry run. Conda file path: {}".format(env_file))