Returns the name of the current :py:class:`Detrender` subclass.
347907
def name(self):
        '''
        

        '''

        if self.cadence == 'lc':
            return self.__class__.__name__
        else:
            return '%s.sc' % self.__class__.__name__
1223887
def name(self):
        
        return self.NAME_SEPARATOR.join([super(InfinityVertex, self).name, self.NAME_SUFFIX])
700009
def get_classname(o):
    
    if inspect.isclass(o):
        target = o
    elif callable(o):
        target = o
    else:
        target = o.__class__
    try:
        return target.__qualname__
    except AttributeError:  # pragma: no cover
        return target.__name__
960147
def _get_current_label(self):
        """"""
        if len(self._last) == 0:
            raise StopIteration
        return self._last[:self._last.find(":")]
714224
def get_class(self, name):
        
        for i in self.get_classes():
            if i.get_name() == name:
                return i
        return None
488072
function() {
			if (this._name === null) {
				var range = this.nameRange();
				if (range) {
					this._name = range.substring(this.source());
				}
			}

			return this._name;
		}
419937
def name(self):
        
        if not hasattr(self, '_name'):
            self._name = re.search('[a-z]+\.([a-z]+)\.([a-z]+)', str(self.__class__), re.IGNORECASE).group(2)

        return self._name
255482
public static String getMainClassName() {
		StackTraceElement trace[] = Thread.currentThread().getStackTrace();
		if (trace.length > 0) {
			return trace[trace.length - 1].getClassName();
		}
		return "Unknown";
	}
530864
def get(self, **kwargs):
        
        old_state = self.state.copy()
        self.merge_dict(kwargs)
        result = rendering.InputRenderer.render_nomenclative(self)
        self.merge_dict(old_state)
        return result
540821
def get(self, name=None):
        
        if name is None:
            return self._classes
        else:
            if name not in self._classes.keys():
                return None
            else:
                return self._classes[name]
985557
def name(self):
        """"""
        try:
            return self._name
        except AttributeError:
            self._name = "%s.%s[%i]" % (self.__module__,
                                        self.__class__.__name__,
                                        next(Loggable.__ids))
            return self._name
69584
def generator_name(cls):
		
		if cls.__generator_name__ is None:
			raise ValueError('"__generator_name__" should be override in a derived class')
		if isinstance(cls.__generator_name__, str) is False:
			raise TypeError('"__generator_name__" should be a str instance')
		return cls.__generator_name__.upper()
374801
def _key_name(self):  # type: () -> str
        
        if self._key is not None:
            return self._key

        return self.__class__.__name__.lower()
1114212
def get_view_name(self):
        
        func = self.settings.VIEW_NAME_FUNCTION
        return func(self.__class__, getattr(self, 'suffix', None))
257340
def name(self):
        """"""
        # pylint:disable=E1101
        return next((self.names.get(x) for x in self._locales if x in
                     self.names), None)
1290816
def getDisplayName(self):
        """"""
        displayName = self.name + "("
        if self.isAsync:
            displayName = "async " + displayName
        first = True
        for arg in self.arguments:
            if first:
                displayName += str(arg)
                first = False
            else:
                displayName += ", " + str(arg)
        displayName += ")"
        if self.returnAnnotation is not None:
            displayName += ' -> ' + self.returnAnnotation
        return displayName
365582
def class_name(self, cls, parts=0, aliases=None):
        # type: (Any, int, Optional[Dict[unicode, unicode]]) -> unicode
        
        module = cls.__module__
        if module in ('__builtin__', 'builtins'):
            fullname = cls.__name__
        else:
            fullname = '%s.%s' % (module, cls.__name__)
        if parts == 0:
            result = fullname
        else:
            name_parts = fullname.split('.')
            result = '.'.join(name_parts[-parts:])
        if aliases is not None and result in aliases:
            return aliases[result]
        return result