Return a Name string for this object.
336356
def getName(self):
		""""""

		name=self.findattr('name')
		if not name:
			name="_directinput_"
			if self.classname().lower()=="line":
				name+="."+str(self).replace(" ","_").lower()
		else:
			name=name.replace('.txt','')

		while name.startswith("."):
			name=name[1:]

		return name
221567
def name(self) -> str:
        """"""
        if self.direction == DIRECTION_IN:
            return self.raw.get('Input.Name', '')
        return self.raw.get('Output.Name', '')
583017
def _gen_name(self):
        
        """
        n = [0]
        for item in self.keys():
            if item.startswith('sim_'):
                n.append(int(item.split('sim_')[1]))
        name = 'sim_'+str(max(n)+1).zfill(2)
        return name
308346
def getName(self, value, defaultName = None):
        '''
        
        '''
        for k,v in self._values.items():
            if v == value:
                return k
        return defaultName
6816
def get_name(self, key):
        '''
        '''
        try:
            return self.nameDict[key]
        except IndexError as e:
            print 'IndexError {0}: {1}'.format(e.errno, e.strerror)
1011628
def name(self):
    
    base_str = 'd{}{}_'.format(self.derivative_count if
                               self.derivative_count > 1 else '', self.expr)
    for var, count in self.variable_count:
        base_str += 'd{}{}'.format(var,  count if count > 1 else '')
    return base_str
1058796
def name(self):
    """"""
    path = getattr(self.path_spec, 'location', None)
    if path is not None and not isinstance(path, py2to3.UNICODE_TYPE):
      try:
        path = path.decode(self._file_system.encoding)
      except UnicodeDecodeError:
        path = None
    return self._file_system.BasenamePath(path)
935357
def _fullname(o):
    """"""
    return o.__module__ + "." + o.__name__ if o.__module__ else o.__name__
844513
def name(self):
        
        if hasattr(self._element, "name"):
            return self._element.name
        else:
            return str(self._element)
219985
def name(self):
    """"""
    row_index = getattr(self.path_spec, 'row_index', None)
    if row_index is not None:
      return 'OFFSET {0:d}'.format(row_index)

    row_condition = getattr(self.path_spec, 'row_condition', None)
    if row_condition is not None:
      if len(row_condition) > 2 and isinstance(
          row_condition[2], py2to3.STRING_TYPES):
        return 'WHERE {0:s} {1:s} \'{2:s}\''.format(*row_condition)
      return 'WHERE {0:s} {1:s} {2!s}'.format(*row_condition)

    # Directory name is full name of column: <table>.<column>
    table_name = getattr(self.path_spec, 'table_name', None)
    column_name = getattr(self.path_spec, 'column_name', None)
    if table_name and column_name:
      return '{0:s}.{1:s}'.format(table_name, column_name)

    return ''
1326511
def get_name(self):
        """"""
        if len(self.taxid2asscs) == 1:
            return '{BASE}_{TAXID}'.format(
                BASE=self.name, TAXID=next(iter(self.taxid2asscs.keys())))
        return '{BASE}_various'.format(BASE=self.name)
1209836
def name(self):
        """"""
        if self.path:
            # follow h5py convention: add leading slash
            name = self.path
            if name[0] != '/':
                name = '/' + name
            return name
        return None
262602
def write_name(self, name):
        """"""

        try:
            # Find existing instance of this name in packet
            #
            index = self.names[name]
        except KeyError:
            # No record of this name already, so write it
            # out as normal, recording the location of the name
            # for future pointers to it.
            #
            self.names[name] = self.size
            parts = name.split('.')
            if parts[-1] == '':
                parts = parts[:-1]
            for part in parts:
                self.write_utf(part)
            self.write_byte(0)
            return

        # An index was found, so write a pointer to it
        #
        self.write_byte((index >> 8) | 0xC0)
        self.write_byte(index)
1300047
def getNamedItem(self, name: str) -> Optional[Attr]:
        
        return self._dict.get(name, None)
639319
def displayName( self ):
        
        if ( not self._displayName ):
            return projex.text.pretty(self.objectName())
        return self._displayName
925066
def get_object_name(object):
    

    if type(object) is property:
        return object.fget.__name__
    elif hasattr(object, "__name__"):
        return object.__name__
    elif hasattr(object, "__class__"):
        return object.__class__.__name__
    else:
        return NULL_OBJECT_NAME
295622
def name(self):
        """"""
        if self._name == '' and self.details != None and 'name' in self.details:
            self._name = self.details['name']
        return self._name