Returns a list of names ignoring any aliases.
776939
def not_as_alias_handler(names_list):
    """"""
    list_ = list()
    for alias in names_list:
        list_.append(alias.name)
    return list_
1146345
def get_names(self):
        '''  '''
        # Overridden to support autocompletion for the ROBOFORTH commands.
        return (['do_' + x for x in self.commands['shell']]
              + ['do_' + x for x in self.commands['forth']])
1215221
def GetNames(cls):
    
    names = []
    for plugin_class in cls._plugins.values():
      name = getattr(plugin_class, 'ARTIFACT_DEFINITION_NAME', None)
      if name:
        names.append(name)

    return names
582657
def get_all_names( self, offset=None, count=None, include_expired=False ):
        
        if offset is not None and offset < 0:
            offset = None

        if count is not None and count < 0:
            count = None 

        cur = self.db.cursor()
        names = namedb_get_all_names( cur, self.lastblock, offset=offset, count=count, include_expired=include_expired )
        return names
762848
def wall_of_name(self):
        '''
        
        '''
        names = []
        if self.standard_name:
            names.append(self.standard_name)
        if self.systematic_name:
            names.append(self.systematic_name)
        names.extend([xref.xrid for xref in self.crossref_set.all()])
        for i in range(len(names)):
            names[i] = re.sub(nonalpha, '', names[i])

        names_string = ' '.join(names)
        if self.standard_name:
            names_string += ' ' + re.sub(num, '', self.standard_name)
        return names_string
486471
def type_names(prefix, sizerange):
        
        namelist = []
        for i in sizerange: namelist.append(prefix + str(i))
        return tuple(namelist)
801812
def adj_names(self):
        
        return list(self.pst.parameter_data.parnme.loc[~self.fixed_indexer])
771602
function(name) {
    var nameList = name.split('.');

    return nameList
      .map(function(item, i, list) {
        return list.slice(0, i+1).join('.');
      })
      .filter(function(item) {
        return item !== null;
      });
  }
357513
def get_names():
    
    return [n.strip() for n in codecs.open(os.path.join("data", "names.txt"),"rb",'utf8').readlines()]
49999
def _get_names(self):
        
        names = self._read_name_file('names.json')
        names = self._compute_weights(names)

        return names
269842
def all_es_aliases(self):
        """"""

        r = self.requests.get(self.url + "/_aliases", headers=HEADER_JSON, verify=False)
        try:
            r.raise_for_status()
        except requests.exceptions.HTTPError as ex:
            logger.warning("Something went wrong when retrieving aliases on %s.",
                           self.anonymize_url(self.index_url))
            logger.warning(ex)
            return

        aliases = []
        for index in r.json().keys():
            aliases.extend(list(r.json()[index]['aliases'].keys()))

        aliases = list(set(aliases))
        return aliases
1182503
def names(self):
        
        # We must sort to preserve the order between calls.
        # The set comprehension is to drop the duplicates.
        return tuple(sorted({
            instr.arg for instr in self.instrs if instr.uses_name
        }))
89733
def get_filter_fields(self, exclude=None):
        

        exclude_set = set(self.exclude)
        if exclude:
            exclude_set = exclude_set.union(set(exclude))

        return [name for name in self.fields
                if name not in exclude_set]
1331621
def get_search_names(name):
    
    parts = re.split('[-_.]', name)
    if len(parts) == 1:
        return parts

    result = set()
    for i in range(len(parts) - 1, 0, -1):
        for s1 in '-_.':
            prefix = s1.join(parts[:i])
            for s2 in '-_.':
                suffix = s2.join(parts[i:])
                for s3 in '-_.':
                    result.add(s3.join([prefix, suffix]))
    return list(result)
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
220277
public String[] getFeatNames() {
        String[] namesArray = new String[nameIndexMap.size()];

        for (Map.Entry<String, Integer> entry : nameIndexMap.entrySet()) {
            namesArray[entry.getValue()] = entry.getKey();
        }

        return namesArray;
    }
61793
def aliases
      list = []
      return list unless namespace.is_a?(HeaderObject)
      namespace.aliases.each do |o, aname|
        list << o if aname == name && o.scope == scope
      end
      list
    end