A full name, intended to uniquely identify a parameter
344028
def fullName(self):
        """"""
        # join with '_' if both are set (cannot put '.', because it is used as
        # **kwargs)
        if self.parentName and self.name:
            return self.parentName + '_' + self.name
        # otherwise just use the one that is set
        # (this allows empty name for "anonymous nests")
        return self.name or self.parentName
1036326
def full_name(self):
        
        if self._full_name is None:
            fn = self.name.replace(".", "\\.")
            parent = self._parent
            if parent is not None:
                fn = parent.full_name + "." + fn
            self._full_name = fn

        return self._full_name
246428
def _normalize_custom_param_name(name):
    

    replacements = (("\u2018", "'"), ("\u2019", "'"), ("\u201C", '"'), ("\u201D", '"'))
    for orig, replacement in replacements:
        name = name.replace(orig, replacement)
    return name
32695
public String findParameterAliasByName(String name) {
		if (parameterName2Alias.containsKey(name)) {
			return parameterName2Alias.get(name);
		}

		return name;
	}
461404
def make_unique_name(name, existing_names, name_format="{name}_{index}", start=2):
    """"""
    index = start
    new_name = name
    while new_name in existing_names:
        new_name = name_format.format(name=name, index=index)
        index += 1

    return new_name
515237
def unique_file_name(base_name, extension=''):
    '''
    
    '''
    idcount = 0

    if extension and not extension.startswith('.'):
        extension = '.%s' % extension

    fname = base_name + extension

    while os.path.exists(fname):
        fname = "%s-%d%s" % (base_name, idcount, extension)
        idcount += 1

    return fname
933515
def name(self):
        

        if self.moc is None:
            self.moc = MOC()

        self.moc.name = self.params.pop()
213034
def full_name(self):
        
        import ibis.expr.operations as ops

        return ops.DayOfWeekName(self.op().arg).to_expr()
77557
def identifier(self, camelsplit=False, ascii=True):
        """"""
        return self.nameify(camelsplit=camelsplit, ascii=ascii, sep='_')
987660
def name(self, value):
        

        if isinstance(value, string_types):

            match = Parameter._PARAM_NAME_COMPILER_MATCHER(value)

            if match is None or match.group() != value:
                value = re_compile(value)

        self._name = value
889935
def full_name(self):
        """"""
        if self._full_name is None:
            ancestors = [ self.name ]
            current = self.parent
            while current is not None and type(current).__name__ != "CodeParser":
                ancestors.append(current.name)
                current = current.parent

            self._full_name = ".".join(reversed(ancestors))
        
        return self._full_name
49040
def v_unique_name_defintions(ctx, stmt):
    """"""
    defs = [('typedef', 'TYPE_ALREADY_DEFINED', stmt.i_typedefs),
            ('grouping', 'GROUPING_ALREADY_DEFINED', stmt.i_groupings)]
    def f(s):
        for (keyword, errcode, dict) in defs:
            if s.keyword == keyword and s.arg in dict:
                err_add(ctx.errors, dict[s.arg].pos,
                        errcode, (s.arg, s.pos))

    for i in stmt.search('include'):
        submodulename = i.arg
        subm = ctx.get_module(submodulename)
        if subm is not None:
            for s in subm.substmts:
                for ss in s.substmts:
                    iterate_stmt(ss, f)
609052
def unique_name(self, name, mark_as_used=True):
    
    scope_name = tf.get_variable_scope().name
    if scope_name:
      name = scope_name + "/" + name

    # As in TensorFlow, treat names as case insensitive when deciding whether
    # they are in use.
    name_key = name.lower()
    i = self._names_in_use.get(name_key, 0)
    if mark_as_used:
      self._names_in_use[name_key] = i + 1
    if i > 0:
      base_name_key = name_key
      while name_key in self._names_in_use:
        name_key = "%s_%d" % (base_name_key, i)
        i += 1
      if mark_as_used:
        self._names_in_use[name_key] = 1
      name = "%s_%d" % (name, i-1)

    return name
162550
def get_unique_name(self, name):
        

        if name not in self._db:
            self._db[name] = 0
            return name
        else:
            index = self._db[name]
            self._db[name] = index + 1
            return f"{name}_{index}"
646749
def __safe_name(self, method_name):
    """"""
    # Endpoints backend restricts what chars are allowed in a method name.
    safe_name = re.sub(r'[^\.a-zA-Z0-9_]', '', method_name)

    # Strip any number of leading underscores.
    safe_name = safe_name.lstrip('_')

    # Ensure the first character is lowercase.
    # Slice from 0:1 rather than indexing [0] in case safe_name is length 0.
    return safe_name[0:1].lower() + safe_name[1:]
666492
private String getUniqueScriptName(String name, String ext) {
		if (this.getScriptImpl(name) == null) {
			// Its unique
			return name;
		}
		// Its not unique, add a suitable index...
		String stub = name.substring(0, name.length() - ext.length() - 1);
		int index = 1;
		do {
			index++;
			name = stub + "(" + index + ")." + ext;
		}
		while (this.getScriptImpl(name) != null);
		
		return name;
	}
1220616
def get_definitive_name(self, unique_ajps, join_character = '-', prepend_label = True):
        
        name = ''
        for ajp in unique_ajps:
            if len(name) > 0:
                name += join_character
            if prepend_label:
                name += str(ajp) + '_'
            name += str(self.additional_join_parameters[ajp]['short_name'])
        if name == '':
            name = 'ddg-benchmark'
        return name