Get a name for nice representation.

        This is either :attr:`name`, :attr:`attrname`, or the empty string.

        :returns: The nice name.
        :rtype: str
358779
def _repr_name(self):
        
        names = {"name", "attrname"}
        if all(name not in self._astroid_fields for name in names):
            return getattr(self, "name", getattr(self, "attrname", ""))
        return ""
970736
def __attr_name(self, name):
		
		if name not in self.cookie_attr_value_compliance.keys():
			suggested_name = name.replace('_', '-').lower()
			if suggested_name not in self.cookie_attr_value_compliance.keys():
				raise ValueError('Invalid attribute name is specified')
			name = suggested_name
		return name
1132819
def name(self):
        
        name = self._name.rstrip('/')
        if self._bytes_path:
            name = fsencode(name)
        return name
24540
def get_name(self):
        
        dependent_host_name = 'unknown'
        if getattr(self, 'dependent_host_name', None):
            dependent_host_name = getattr(
                getattr(self, 'dependent_host_name'), 'host_name', 'unknown'
            )
        host_name = 'unknown'
        if getattr(self, 'host_name', None):
            host_name = getattr(getattr(self, 'host_name'), 'host_name', 'unknown')
        return dependent_host_name + '/' + host_name
466792
def name(self):
        
        if not self._name:
            self._name = self._alternatives[self._choice][0]
        return self._name
568751
def attr_name(self):
        ""
        return self.schema.name if self.schema else self.field.name
1180362
def absolute_name(self):
        
        if self.is_root() or self.parent.is_root():
            return utils.slugify(self.name)
        return ':'.join([self.parent.absolute_name, utils.slugify(self.name)])
439826
def name(self):
        
        name = super(Interface, self).name
        return name if name else self.data.get('name')
644610
def get_full_name(self):
        
        full_name = '{first_name} {last_name}'.format(first_name=self.first_name, last_name=self.last_name)
        return full_name.strip()
51906
def getName(self, length=512):
        
        name = ctypes.create_string_buffer(length)
        self._ioctl(_HIDIOCGRAWNAME(length), name, True)
        return name.value.decode('UTF-8')
268355
async def get_friendly_name(self) -> Text:
        
        u = await self._get_user()
        f = u.get('first_name', '').strip()
        l = u.get('last_name', '').strip()

        return f or l
670172
def _get_name(self):
        
        if self._name is None:
            self._name = self._generate_name()
        return self._name
94682
def name(self, name):
        
        if name is None:
            raise ValueError("Invalid value for `name`, must not be `None`")
        if name is not None and len(name) > 128:
            raise ValueError("Invalid value for `name`, length must be less than or equal to `128`")
        if name is not None and len(name) < 1:
            raise ValueError("Invalid value for `name`, length must be greater than or equal to `1`")
        if name is not None and not re.search('^[^\/]+$', name):
            raise ValueError("Invalid value for `name`, must be a follow pattern or equal to `/^[^\/]+$/`")

        self._name = name
1085427
def _object_name_html(self):
        
        if self.presently.exists:
            url = self.url()
            return "<a href=\"%s\">%s</a>" % (url,
                                              unicode(self.get_object()),)
        else:
            return "(deleted)"
138916
def _get_fullname(obj):
        # type: (Any) -> str
        
        if not hasattr(obj, "__name__"):
            obj = obj.__class__
        if obj.__module__ in ("builtins", "__builtin__"):
            return obj.__name__
        return "{}.{}".format(obj.__module__, obj.__name__)
313272
def get_name(cls):
        
        if not hasattr(cls.Meta, 'name'):
            class_name = getattr(cls.get_model(), '__name__', None)
            setattr(
                cls.Meta,
                'name',
                inflection.underscore(class_name) if class_name else None
            )

        return cls.Meta.name
1040484
def name(self) -> str:
        
        return OPENSSL_TO_RFC_NAMES_MAPPING[self.ssl_version].get(self.openssl_name, self.openssl_name)