The list of alternates for this repo from which objects can be retrieved

        :return: list of strings being pathnames of alternates
425417
def _get_alternates(self):
        """"""
        alternates_path = osp.join(self.git_dir, 'objects', 'info', 'alternates')

        if osp.exists(alternates_path):
            with open(alternates_path, 'rb') as f:
                alts = f.read().decode(defenc)
            return alts.strip().splitlines()
        else:
            return []
378613
def labels(self):
        
        return [
            name for name in os.listdir(self.root)
            if os.path.isdir(os.path.join(self.root, name))
        ]
932676
def crossref_paths(self):
        """"""
        return set(
            [address.new(repo=x.repo, path=x.path) for x in self.crossrefs])
402640
private JSONArray getAlternativeNames(Collection<List<?>> alternativeNames) {

        if (alternativeNames == null || alternativeNames.size() == 0) {
            return null;
        }

        JSONArray altNames = new JSONArray();
        for (List<?> altName : alternativeNames) {
            //int altNameType = (Integer) altName.get(0);  // XXX For now we're going to ignore the type
            //                                             // We might want to do something special later.
            String altNameValue = altName.get(1).toString();
            altNames.put(altNameValue);
        }

        return altNames;
    }
149966
def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
    
    _ensure_cfg_read()
    if expand:
        return _expand_vars(scheme, vars)
    else:
        return dict(_SCHEMES.items(scheme))
707387
def url_paths(self):
        
        unformatted_paths = self._url_module.url_paths

        paths = {}
        for unformatted_path, handler in unformatted_paths.items():
            path = unformatted_path.format("")
            paths[path] = handler

        return paths
759369
def installed_list(cls):
        
        logger.debug("")

        res = []
        for x in repo_dirlist():
            d = x['path']
            try:
                res.append(Repo(repo_dir=d, name=x['base']))
            except InvalidRepo:
                logger.warning("Invalid repo '%s' in the installation directory.", d)

        return res
419108
def list(self, path=None, with_metadata=False, include_partitions=False):
        ''''''
        from os import walk
        import json

        l = {}

        if not path:
            start_path = self.cache_dir
        else:
            start_path = os.path.join(self.cache_dir, path)

        for root, dirs, files in os.walk(start_path):

            root = root.replace(self.cache_dir, '', 1).strip('/')

            if root.startswith('meta') or root.startswith('_'):
                continue

            if not include_partitions and root.count('/') > 0:
                continue  # partition files

            for f in files:
                rel_path = os.path.join(root, f)
                d = self.metadata(rel_path) if with_metadata else {}

                if d and 'identity' in d:
                    d['identity'] = json.loads(d['identity'])

                d['caches'] = [self.repo_id]

                l[rel_path] = d

        if self.upstream:
            for k, v in self.upstream.list(path, with_metadata, include_partitions).items():
                upstreams = (l[k]['caches'] if k in l else []) + \
                    v.get('caches', self.upstream.repo_id)

                l[k] = v
                l[k]['caches'] = upstreams

        return l
576879
def _get_dir_list(load):
    '''
    
    '''
    if 'env' in load:
        # "env" is not supported; Use "saltenv".
        load.pop('env')

    if 'saltenv' not in load or load['saltenv'] not in envs():
        return []
    ret = set()
    for repo in init():
        repo['repo'].open()
        ref = _get_ref(repo, load['saltenv'])
        if ref:
            manifest = repo['repo'].manifest(rev=ref[1])
            for tup in manifest:
                filepath = tup[4]
                split = filepath.rsplit('/', 1)
                while len(split) > 1:
                    relpath = os.path.relpath(split[0], repo['root'])
                    # Don't add '.'
                    if relpath != '.':
                        # Don't add files outside the hgfs_root
                        if not relpath.startswith('../'):
                            ret.add(os.path.join(repo['mountpoint'], relpath))
                    split = split[0].rsplit('/', 1)
        repo['repo'].close()
    if repo['mountpoint']:
        ret.add(repo['mountpoint'])
    return sorted(ret)
427830
def alternate(*iterables):
    
    items = []
    for tup in zip(*iterables):
        items.extend([item for item in tup])
    return items
1279630
def get_organized_repos(repos)
      forks = []
      publics = []
      mirrors = []
      privates = []
      repos.each do |r|
        repo_name = r[:full_name]
        forks << repo_name if r[:fork]

        if r[:private]
          privates << repo_name
        else
          publics << repo_name
        end

        mirrors << repo_name unless r[:mirror_url].nil?
      end

      {
        public: publics,
        forks: forks,
        mirrors: mirrors,
        privates: privates
      }
    end
1316432
def get_paths(self, key):
        
        final_paths = []

        if key in self.__cli:
            paths = self.__cli[key] or []
            from_conf = False
        else:
            paths = self.__config.get(key) or []
            from_conf = True

        for path in flatten_list(paths):
            final_path = self.__abspath(path, from_conf)
            if final_path:
                final_paths.append(final_path)

        return final_paths
1011005
def getRepositories(self):
        
        if self.srcdir and not self.duplicate:
            return self.srcdir.get_all_rdirs() + self.repositories
        return self.repositories
645985
def get_urls(self):
        
        parts = []
        seen = set()

        # Process item views in order
        for v in list(self._meta.item_views)+list(self._meta.action_views):
            if not v in seen:
                view, name = self.get_view_and_name(v)
                if view and name:
                    parts.append(self.get_url(name, view, v))
                seen.add(v)

        # Process everything else that we have not seen
        for v in set(self._views).difference(seen):
            # Get the url name
            view, name = self.get_view_and_name(v)
            if view and name:
                parts.append(self.get_url(name, view, v))

        return parts
867694
def get_alternative_short_names(cls, entry):
        
        names = []
        query = "./protein/alternativeName/shortName"
        for name in entry.iterfind(query):
            names.append(models.AlternativeShortName(name=name.text))

        return names
558901
def _tpl_possibilities(self):
        
        tpl_possibilities = [
            os.path.realpath(self.tpl)
        ]
        for tpl_dir in self.tpl_dirs:
            tpl_possibilities.append(os.path.realpath(os.path.join(tpl_dir, "{0}.tpl".format(self.tpl))))
            tpl_possibilities.append(os.path.realpath(os.path.join(tpl_dir, "{0}.py".format(self.tpl))))

        return tpl_possibilities
1295252
def get_list_of_paths(self):
        
        all_paths = []
        for p in self.fl_metadata:
            try:
                all_paths.append(p['path'])
            except:
                try:
                    print('cls_filelist - no key path, ignoring folder ' + str(p))
                except:
                    print('cls_filelist - no key path, ignoring odd character folder')

        return list(set(all_paths))