Return a list of (lower-cased) names if available (unloaded) Packs.
17670
def get_available_pack_names():
    
    installed_pack_names = [pack.name.lower() for pack in Pack.objects.all()]
    fortunes_path = get_fortunes_path()
    for path in fortunes_path.iterdir():
        if path.is_dir():
            pass
        elif path.suffix == ".dat":
            pass
        elif path.name.lower() in installed_pack_names:
            pass
        else:
            yield path.name.lower()
337300
def _get_names(dirs):
  """"""
  alphabets = set()
  label_names = {}
  for d in dirs:
    for example in _walk_omniglot_dir(d):
      alphabet, alphabet_char_id, label, _ = example
      alphabets.add(alphabet)
      label_name = "%s_%d" % (alphabet, alphabet_char_id)
      if label in label_names:
        assert label_names[label] == label_name
      else:
        label_names[label] = label_name
  label_names = [label_names[k] for k in sorted(label_names)]
  return alphabets, label_names
322194
def board_names(hwpack='arduino'):
    """"""
    ls = list(boards(hwpack).keys())
    ls.sort()
    return ls
571251
def get_dump_order(self, names):
        
        finded_names = self.get_dump_names(names)
        return [item for item in self if item in finded_names]
1295257
def get_environ_list(name, default=None):
    
    packed = os.environ.get(name)
    if packed is not None:
        return packed.split(':')
    elif default is not None:
        return default
    else:
        return []
420393
def get_module_names(package_path, pattern="lazy_*.py*"):
  
  package_contents = glob(os.path.join(package_path[0], pattern))
  relative_path_names = (os.path.split(name)[1] for name in package_contents)
  no_ext_names = (os.path.splitext(name)[0] for name in relative_path_names)
  return sorted(set(no_ext_names))
1356615
def names(self) -> [str]:
        
        return sorted([name for name in self.axes_by_sname.keys() if name is not ''])
762613
def filter(self, names):
        
        names = list_strings(names)

        fnames = []
        for f in names:
            for pat in self.pats:
                if fnmatch.fnmatch(f, pat):
                    fnames.append(f)

        return fnames
23408
function lowerCaseHeaders(headers) {
	var res = {};

	Object.keys(headers).forEach(headerName => {
		res[headerName.toLowerCase()] = headers[headerName];
	});

	return res;
}
187833
def get_all_fix_names(fixer_pkg, remove_prefix=True):
    """"""
    pkg = __import__(fixer_pkg, [], [], ["*"])
    fixer_dir = os.path.dirname(pkg.__file__)
    fix_names = []
    for name in sorted(os.listdir(fixer_dir)):
        if name.startswith("fix_") and name.endswith(".py"):
            if remove_prefix:
                name = name[4:]
            fix_names.append(name[:-3])
    return fix_names
641077
def infer_game_name_from_filenames(data_dir, snake_case=True):
  """"""
  names = os.listdir(data_dir)
  game_names = [re.findall(pattern=r"^Gym(.*)NoFrameskip", string=name)
                for name in names]
  assert game_names, "No data files found in {}".format(data_dir)
  game_names = sum(game_names, [])
  game_name = game_names[0]
  assert all(game_name == other for other in game_names), \
      "There are multiple different game names in {}".format(data_dir)
  if snake_case:
    game_name = camelcase_to_snakecase(game_name)
  return game_name
1268898
def _get_all_ns_packages(self):
        """"""
        pkgs = self.distribution.namespace_packages or []
        return sorted(flatten(map(self._pkg_names, pkgs)))
483042
def downcaseTokens(s,l,t):
    """"""
    return [ tt.lower() for tt in map(_ustr,t) ]
187124
def output_names(self) -> Iterable[str]:
        """"""
        self._load_models()
        return chain.from_iterable(map(lambda m: m.output_names, self._models))
387381
def get_realnames(packages):
    
    return sorted({get_distribution(p).project_name for p in packages},
                  key=lambda n: n.lower())
196304
def get_name_variants(pkg):
    # type: (STRING_TYPE) -> Set[STRING_TYPE]
    

    if not isinstance(pkg, six.string_types):
        raise TypeError("must provide a string to derive package names")
    from pkg_resources import safe_name
    from packaging.utils import canonicalize_name

    pkg = pkg.lower()
    names = {safe_name(pkg), canonicalize_name(pkg), pkg.replace("-", "_")}
    return names
1150188
def sorted_names(names):
    
    names = list(names)

    have_default = False
    if 'default' in names:
        names.remove('default')
        have_default = True

    sorted_names = sorted(names)

    if have_default:
        sorted_names = ['default'] + sorted_names

    return sorted_names