If ``name`` is already the full name of an object, return
        ``name``.  Otherwise, if ``name`` is a partial object name,
        look up the full name and return it.
326642
def get_full_name(self, role, name):
        

        # An initial '.' indicates a partial name
        if name[0] == '.':
            # Find matches for the partial name in the string
            # containing all full names for this role
            ptrn = r'(?<= )[^,]*' + name + r'(?=,)'
            ml = re.findall(ptrn, self.rolnam[role])
            # Handle cases depending on the number of returned matches,
            # raising an error if exactly one match is not found
            if len(ml) == 0:
                raise KeyError('name matching %s not found' % name,
                               'name', len(ml))
            elif len(ml) > 1:
                raise KeyError('multiple names matching %s found' % name,
                               'name', len(ml))
            else:
                return ml[0]
        else:
            # The absence of an initial '.' indicates a full
            # name. Return the name if it is present in the inventory,
            # otherwise raise an error
            try:
                dom = IntersphinxInventory.roledomain[role]
            except KeyError:
                raise KeyError('role %s not found' % role, 'role', 0)
            if name in self.inv[dom]:
                return name
            else:
                raise KeyError('name %s not found' % name, 'name', 0)
336030
def named_object(name):
    """"""
    name_parts = name.split('.')
    module = named_module('.'.join(name_parts[:-1]))
    return getattr(module, name_parts[-1])
1281901
private boolean doesMatchFullName(String firstName, String fullName){
        boolean matching = false;
        if(firstName != null && !firstName.isEmpty() && fullName != null && !fullName.isEmpty()){
            String firstFromCMDB;
            String[] array = fullName.split(" ");

            firstName = firstName.toLowerCase();
            firstFromCMDB = array[0];
            firstFromCMDB = firstFromCMDB.toLowerCase();
            if(firstFromCMDB.length() < firstName.length()){
                if(firstName.indexOf(firstFromCMDB) != -1){
                    matching = true;
                }
            }else if (firstFromCMDB.indexOf(firstName) != -1){
                matching = true;
            }
        }
        return matching;
    }
367301
def _get_callable_full_name(self, fob, fin, uobj):
        """"""
        # Check if object is a class property
        name = self._property_search(fob)
        if name:
            del fob, fin, uobj
            return name
        if os.path.isfile(fin):
            lineno = fob.f_lineno
            ret = self._callables_obj.get_callable_from_line(fin, lineno)
            del fob, fin, uobj, name, lineno
            return ret
        # Code executed in doctests does not have an actual callable object
        # exec-based callables do not have a valid file name
        fname = uobj and _get_func_code(uobj).co_filename
        if (not fname) or (fname and (not os.path.isfile(fname))):
            del fob, fin, uobj, name, fname
            return "dynamic"
        code_id = (
            inspect.getfile(uobj).replace(".pyc", "py"),
            inspect.getsourcelines(uobj)[1],
        )
        self._callables_obj.trace([code_id[0]])
        ret = self._callables_obj.reverse_callables_db[code_id]
        del fob, fin, uobj, name, fname, code_id
        return ret
385041
def _qname(self, name):
        
        if isinstance(name, QName):
            return name
        if not isinstance(name, str):
            raise TypeError("{} must be str".format(name))
        if name == '':
            return name
        if name.startswith('{'):
            return name
        prefix, tag = name.split(':', maxsplit=1)
        uri = self.NS[prefix]
        return QName(uri, tag)
1069151
public String getFullName() {
	String fullName;
	if (tagLib != null) {
	    fullName = tagLib.getNameSpaceAndSeparator() + name;
	}
	else {
	    fullName = name;
	}
	return fullName;
    }
739066
function _getName(fullname, extension) {
        return extension !== "" ? fullname.substring(0, fullname.length - extension.length - 1) : fullname;
    }
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
1272818
def name(self, name=None):
        ''''''
        if name:
            self._name = name
            return self
        return self._name
690470
def get_name(self):
        
        self.name = self.name or graceful_get(self.inspect(refresh=False), "Name")
        return self.name
21922
def partial_name(self):
        

        if None is self._partial_name:
            self._partial_name = self._get_partial_name_impl()

        return self._partial_name
95923
def _get_reconciled_name_object(self, other):
        
        name = get_op_result_name(self, other)
        if self.name != name:
            return self._shallow_copy(name=name)
        return self
546747
def with_name(self, name):
        """"""
        if not self.name:
            raise ValueError("%r has an empty name" % (self,))
        drv, root, parts = self._flavour.parse_parts((name,))
        if (not name or name[-1] in [self._flavour.sep, self._flavour.altsep]
                or drv or root or len(parts) != 1):
            raise ValueError("Invalid name %r" % (name))
        return self._from_parsed_parts(self._drv, self._root,
                                       self._parts[:-1] + [name])
117928
def get_full_typename(o):
    
    instance_name = o.__class__.__module__ + "." + o.__class__.__name__
    if instance_name in ["builtins.module", "__builtin__.module"]:
        return o.__name__
    else:
        return instance_name
1261573
def cls_get_by_name(cls, name):
    
    try:
        val = getattr(cls, name)
    except AttributeError:
        for attr in (a for a in dir(cls) if not a.startswith('_')):
            try:
                val = getattr(cls, attr)
            except AttributeError:
                # Is known to happen.
                continue
            valname = getattr(val, 'name', None)
            if valname == name:
                return val
        else:
            raise ValueError('No {} with that name: {}'.format(
                cls.__name__,
                name,
            ))
    else:
        return val
746714
def _full_name(self, record_name):
        """"""
        # Handle None and empty strings
        if not record_name:
            return self.domain
        return super(Provider, self)._full_name(record_name)
565591
def getFullName(obj):
    '''
    
    '''
    if hasattr(obj, 'firstName') and hasattr(obj, 'lastName'):
        return ' '.join([obj.firstName or '', obj.lastName or ''])
    return ' '.join([getattr(obj, 'first_name', ''),getattr(obj, 'last_name', '')])