Provide old install directory for configuration with GEMINI supplied tidy VCFs.

    Handles new style (bcbio installed) and old style (GEMINI installed)
    configuration and data locations.
767030
def _back_compatible_gemini(conf_files, data):
    
    if vcfanno.is_human(data, builds=["37"]):
        for f in conf_files:
            if f and os.path.basename(f) == "gemini.conf" and os.path.exists(f):
                with open(f) as in_handle:
                    for line in in_handle:
                        if line.startswith("file"):
                            fname = line.strip().split("=")[-1].replace('"', '').strip()
                            if fname.find(".tidy.") > 0:
                                return install.get_gemini_dir(data)
    return None
468500
def _domain_event_disk_change_cb(conn, domain, old_src, new_src, dev, reason, opaque):
    '''
    
    '''
    _salt_send_domain_event(opaque, conn, domain, opaque['event'], {
        'oldSrcPath': old_src,
        'newSrcPath': new_src,
        'dev': dev,
        'reason': _get_libvirt_enum_string('VIR_DOMAIN_EVENT_DISK_', reason)
    })
965979
def create_gemini_db(gemini_vcf, data, gemini_db=None, ped_file=None):
    
    if not gemini_db:
        gemini_db = "%s.db" % utils.splitext_plus(gemini_vcf)[0]
    if not vcfutils.vcf_has_variants(gemini_vcf):
        return None
    if not utils.file_exists(gemini_db):
        with file_transaction(data, gemini_db) as tx_gemini_db:
            vcf2db = config_utils.get_program("vcf2db.py", data)
            if "vcf2db_expand" in dd.get_tools_on(data):
                vcf2db_args = ["--expand", "gt_types", "--expand", "gt_ref_depths", "--expand", "gt_alt_depths"]
            else:
                vcf2db_args = []
            cmd = [vcf2db, gemini_vcf, ped_file, tx_gemini_db] + vcf2db_args
            do.run(cmd, "GEMINI: create database with vcf2db")
    return gemini_db
575400
private File updateMonitoredDirectory(String newMonitoredFolder) {

        File oldDir = monitoredDirectory.get();
        File newDir = new File(newMonitoredFolder);

        // If it is relative, resolve against server dir
        if (!!!newDir.isAbsolute()) {
            newMonitoredFolder = locationService.resolveString(WsLocationConstants.SYMBOL_SERVER_CONFIG_DIR + newMonitoredFolder);
            newDir = new File(newMonitoredFolder);
        }

        if (!!!newDir.equals(oldDir)) {
            if (monitoredDirectory.compareAndSet(oldDir, newDir)) {
                for (ServiceReg<FileMonitor> mon : _monitors.values()) {
                    mon.unregister();
                }
                _monitors.clear();

                if (!!!newDir.exists()) {
                    createdMonitoredDir.set(newDir.mkdirs());
                }
            } else {
                oldDir = null;
            }
        } else {
            oldDir = null;
        }

        return oldDir;
    }
57459
function setupBundler(cwd, entryPoints, flags, noWatchify, ready) {
  noWatchify ?
    onlocalwatchify() :
    resolve('watchify', {basedir: cwd}, onlocalwatchify)

  function onlocalwatchify(err, localDir) {
    if(err || !localDir) {
      return resolve('browserify', {basedir: cwd}, onlocalbrowserify)
    }

    setupWatchify(path.dirname(localDir), entryPoints, flags, ready)
  }

  function onlocalbrowserify(err, localDir) {
    if(err || !localDir) {
      return findGlobals(onglobals)
    }

    setupBrowserify(path.dirname(localDir), entryPoints, flags, ready)
  }

  function onglobals(err, dirs) {
    if(err) {
      return ready(err)
    }

    dirs = dirs.sort()

    for(var i = 0, len = dirs.length; i < len; ++i) {
      if(!noWatchify && path.basename(dirs[i]) === 'watchify') {
        return setupWatchify(dirs[i], entryPoints, flags, ready)
      }

      if(path.basename(dirs[i]) === 'browserify') {
        return setupBrowserify(dirs[i], entryPoints, flags, ready)
      }
    }

    return ready(new Error('Could not find a suitable bundler!'))
  }
}
551654
def prep_system(run_info_yaml, bcbio_system=None):
    
    work_dir = os.getcwd()
    config, config_file = config_utils.load_system_config(bcbio_system, work_dir)
    dirs = setup_directories(work_dir, os.path.normpath(os.path.dirname(os.path.dirname(run_info_yaml))),
                             config, config_file)
    return [dirs, config, run_info_yaml]
672345
def _update_conda_devel():
    
    conda_bin = _get_conda_bin()
    channels = _get_conda_channels(conda_bin)
    assert conda_bin, "Could not find anaconda distribution for upgrading bcbio"
    subprocess.check_call([conda_bin, "install", "--quiet", "--yes"] + channels +
                           ["bcbio-nextgen>=%s" % version.__version__.replace("a0", "a")])
    return os.path.dirname(os.path.dirname(conda_bin))
650017
def cleanup(test_data, udfs, tmp_data, tmp_db):
    """"""
    con = make_ibis_client(ENV)

    if udfs:
        # this comes before test_data bc the latter clobbers this too
        con.hdfs.rmdir(os.path.join(ENV.test_data_dir, 'udf'))

    if test_data:
        con.drop_database(ENV.test_data_db, force=True)
        con.hdfs.rmdir(ENV.test_data_dir)

    if tmp_data:
        con.hdfs.rmdir(ENV.tmp_dir)

    if tmp_db:
        con.drop_database(ENV.tmp_db, force=True)
253684
def _canonical_hsdir(hsdir):
    
    if not isabs(hsdir):
        abs_hsdir = abspath(hsdir)
        warnings.warn(
            "Onions service directory ({}) is relative and has"
            " been resolved to '{}'".format(hsdir, abs_hsdir)
        )
        hsdir = abs_hsdir
    return hsdir
201488
def get_config_directory(override_files=False):
    
    if override_files:
        possible_dirs = [override_files]

    else:
        xdg_config_home = os.environ.get('XDG_CONFIG_HOME') or \
            os.path.expanduser('~/.config')
        possible_dirs = [os.path.join(xdg_config_home, "supernova.d/"),
                         os.path.expanduser("~/.supernova.d/"),
                         ".supernova.d/"]

    for config_dir in reversed(possible_dirs):
        if os.path.isdir(config_dir):
            return config_dir

    return False
798680
def default_working_dir():
    
    import nameset.virtualchain_hooks as virtualchain_hooks
    return os.path.expanduser('~/.{}'.format(virtualchain_hooks.get_virtual_chain_name()))
91611
def view(ctx, host, port, debug, pattern, family_file, family_type,
         variant_source, root, no_browser, phenomizer):
    
    main_loop = (not debug) or (os.environ.get('WERKZEUG_RUN_MAIN') == 'true')
    root = root or ctx.obj.get('root') or os.path.expanduser("~/.puzzle")
    phenomizer_auth = phenomizer or ctx.obj.get('phenomizer_auth')
    BaseConfig.PHENOMIZER_AUTH = True if ctx.obj.get('phenomizer_auth') else False
    BaseConfig.STORE_ENABLED = True

    if variant_source is None:
        logger.info("Root directory is: {}".format(root))

        db_path = os.path.join(root, 'puzzle_db.sqlite3')
        logger.info("db path is: {}".format(db_path))
        if not os.path.exists(db_path):
            logger.warn("database not initialized, run 'puzzle init'")
            ctx.abort()

        if os.path.isfile(root):
            logger.error("'root' can't be a file")
            ctx.abort()

        store = SqlStore(db_path, phenomizer_auth=phenomizer_auth)
        for case_obj in store.cases():
            if case_obj.variant_mode == 'gemini':
                if not GEMINI:
                    logger.error("Need to have gemini instaled to view gemini database")
                    ctx.abort()

    else:
        logger.info("Using in memory database")
        tmpdir = tempfile.mkdtemp()
        tmpdb = os.path.join(tmpdir, 'puzzle.sqlite3')
        logger.info("building database: {}".format(tmpdb))
        store = SqlStore("sqlite:///{}".format(tmpdb),
                         phenomizer_auth=phenomizer_auth)
        if main_loop:
            store.set_up()
            cases = []
            if os.path.isfile(variant_source):
                file_type = get_file_type(variant_source)
                #Test if gemini is installed
                if file_type == 'unknown':
                    logger.error("File has to be vcf or gemini db")
                    ctx.abort()
                elif file_type == 'gemini':
                    #Check if gemini is installed
                    if not GEMINI:
                        logger.error("Need to have gemini installed to use gemini plugin")
                        ctx.abort()
                variant_type = get_variant_type(variant_source)
                cases = get_cases(
                    variant_source=variant_source,
                    case_lines=family_file,
                    case_type=family_type,
                    variant_type=variant_type,
                    variant_mode=file_type
                )
            else:
                for file in path(variant_source).walkfiles(pattern):
                    file_type = get_file_type(file)
                    if file_type != 'unknown':
                        variant_type = get_variant_type(file)
                        #Test if gemini is installed
                        if file_type == 'gemini':
                            if not GEMINI:
                                logger.error("Need to have gemini installed to use gemini plugin")
                                ctx.abort()

                        for case in get_cases(
                            variant_source=file,
                            case_type=family_type,
                            variant_type=variant_type,
                            variant_mode=file_type):

                            cases.append(case)

            for case_obj in cases:
                if store.case(case_obj.case_id) is not None:
                    logger.warn("{} already exists in the database"
                                .format(case_obj.case_id))
                    continue

                # extract case information
                logger.debug("adding case: {}".format(case_obj.case_id))
                store.add_case(case_obj, vtype=case_obj.variant_type, mode=case_obj.variant_mode)

    logger.debug("Plugin setup was succesfull")
    BaseConfig.PUZZLE_BACKEND = store
    BaseConfig.UPLOAD_DIR = os.path.join(root, 'resources')

    app = create_app(config_obj=BaseConfig)

    if no_browser is False:
        webbrowser.open_new_tab("http://{}:{}".format(host, port))

    app.run(host=host, port=port, debug=debug)
1050599
def Setup():
    '''
    

    '''

    if not os.path.exists(os.path.join(EVEREST_DAT, 'k2', 'cbv')):
        os.makedirs(os.path.join(EVEREST_DAT, 'k2', 'cbv'))
    GetK2Stars(clobber=False)
327336
function bsconfigToOptions(bsconfig) /*: Options */ {
  const bsSuffix = bsconfig.suffix
  const suffix = typeof bsSuffix === 'string' ? bsSuffix : '.js'

  if (!bsconfig['package-specs']) {
    const options /*: Options */ = {
      moduleDir: 'js',
      inSource: false,
      suffix,
    }
    return options
  }

  const packageSpecs = bsconfig['package-specs']
  const moduleSpec =
    packageSpecs instanceof Array ? packageSpecs[0] : packageSpecs
  const moduleDir /*: BsModuleFormat */ =
    typeof moduleSpec === 'string' ? moduleSpec : moduleSpec.module
  const inSource =
    typeof moduleSpec === 'string' ? false : moduleSpec['in-source']

  const options /*: Options */ = {moduleDir, inSource, suffix}
  return options
}
179880
def create_gemini_db_orig(gemini_vcf, data, gemini_db=None, ped_file=None):
    
    if not gemini_db:
        gemini_db = "%s.db" % utils.splitext_plus(gemini_vcf)[0]
    if not utils.file_exists(gemini_db):
        if not vcfutils.vcf_has_variants(gemini_vcf):
            return None
        with file_transaction(data, gemini_db) as tx_gemini_db:
            gemini = config_utils.get_program("gemini", data["config"])
            load_opts = ""
            if "gemini_allvariants" not in dd.get_tools_on(data):
                load_opts += " --passonly"
            # For small test files, skip gene table loading which takes a long time
            if _is_small_vcf(gemini_vcf):
                load_opts += " --skip-gene-tables"
            if "/test_automated_output/" in gemini_vcf:
                load_opts += " --test-mode"
            # Skip CADD or gerp-bp if neither are loaded
            gemini_dir = install.get_gemini_dir(data)
            for skip_cmd, check_file in [("--skip-cadd", "whole_genome_SNVs.tsv.compressed.gz")]:
                if not os.path.exists(os.path.join(gemini_dir, check_file)):
                    load_opts += " %s" % skip_cmd
            # skip gerp-bp which slows down loading
            load_opts += " --skip-gerp-bp "
            num_cores = data["config"]["algorithm"].get("num_cores", 1)
            tmpdir = os.path.dirname(tx_gemini_db)
            eanns = _get_effects_flag(data)
            # Apply custom resource specifications, allowing use of alternative annotation_dir
            resources = config_utils.get_resources("gemini", data["config"])
            gemini_opts = " ".join([str(x) for x in resources["options"]]) if resources.get("options") else ""
            exports = utils.local_path_export()
            cmd = ("{exports} {gemini} {gemini_opts} load {load_opts} "
                   "-v {gemini_vcf} {eanns} --cores {num_cores} "
                   "--tempdir {tmpdir} {tx_gemini_db}")
            cmd = cmd.format(**locals())
            do.run(cmd, "Create gemini database for %s" % gemini_vcf, data)
            if ped_file:
                cmd = [gemini, "amend", "--sample", ped_file, tx_gemini_db]
                do.run(cmd, "Add PED file to gemini database", data)
    return gemini_db
1322517
def load(self, updates):
        """"""
        # Go through in order and override the config (`.mbed_cloud_config.json` loader)
        for path in self.paths():
            if not path:
                continue
            abs_path = os.path.abspath(os.path.expanduser(path))
            if not os.path.isfile(abs_path):
                self._using_paths.append('missing: %s' % abs_path)
                continue
            self._using_paths.append(' exists: %s' % abs_path)
            with open(abs_path) as fh:
                self.update(json.load(fh))

        # New dotenv loader - requires explicit instructions to use current working directory
        load_dotenv(find_dotenv(usecwd=True))

        # Pluck config values out of the environment
        for env_var, key in {ENVVAR_API_HOST: 'host', ENVVAR_API_KEY: 'api_key'}.items():
            env_value = os.getenv(env_var)
            if env_value is not None:
                self[key] = env_value
        if updates:
            self.update(updates)
        self.validate()
1327525
private void upgradeIfNeeded(File oldPidGenDir) throws IOException {
        if (oldPidGenDir != null && oldPidGenDir.isDirectory()) {
            String[] names = oldPidGenDir.list();
            Arrays.sort(names);
            if (names.length > 0) {
                BufferedReader in =
                        new BufferedReader(new InputStreamReader(new FileInputStream(new File(oldPidGenDir,
                                                                                              names[names.length - 1]))));
                String lastLine = null;
                String line;
                while ((line = in.readLine()) != null) {
                    lastLine = line;
                }
                in.close();
                if (lastLine != null) {
                    String[] parts = lastLine.split("|");
                    if (parts.length == 2) {
                        neverGeneratePID(parts[0]);
                    }
                }
            }
        }
    }