Random full name (male or female). Arguments :male, :female, :any
432587
def full_name(gender = :any)
      case gender
      when :any then rand(0..1) == 0 ? male_full_name : female_full_name
      when :male then male_full_name
      when :female then female_full_name
      else raise ArgumentError, 'Invalid gender, must be one of :any, :male, :female'
      end
    end
213034
def full_name(self):
        
        import ibis.expr.operations as ops

        return ops.DayOfWeekName(self.op().arg).to_expr()
203676
def noun(self, plural: bool = False) -> str:
        
        key = 'plural' if \
            plural else 'noun'

        return self.random.choice(self._data[key])
1212442
function () {
		let name = '';
		const scount = randomizer.getWeightedRandom(namedata.holmesian_scount.values, namedata.holmesian_scount.weights);
	
		for (let i = 1; i <= scount; i++) {
			name += randomizer.rollRandom(namedata.holmesian_syllables); // array
			if (i < scount) {
				name += randomizer.getWeightedRandom(['', ' ', '-'], [3, 2, 2]);
			}
		}
		name = name.toLowerCase() + ' ' + randomizer.rollRandom(namedata.holmesian_title);
		
		name = randomizer.findToken(name);
		
		name = name.replace(/[\s\-]([a-z]{1})/g, (match) => {
			return match.toUpperCase();
		});
		return name;
	}
97094
function randomString(holder) {
        var chars, randomstring, i;
        if (!holder) {
            throw new Error("cannot create a random attribute name for an undefined object");
        }
        chars = "ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
        randomstring = "";
        do {
            randomstring = "";
            for (i = 0; i < 12; i++) {
                randomstring += chars[Math.floor(Math.random() * chars.length)];
            }
        } while (holder[randomstring]);
        return randomstring;
    }
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
757745
function (person, gcase) {
        var result = {};
        // gender detection
        if (person.gender != null) {
            if (!contains(predef.genders, person.gender))
                throw new Error('Invalid gender: ' + person.gender);
            result.gender = person.gender;
        } else if (person.middle != null) {
            result.gender = petrovich.detect_gender(person.middle);
        } else {
            throw new Error('Unknown gender');
        }
        if (!contains(predef.cases, gcase))
            throw new Error('Invalid case: ' + gcase);
        // look over possible names of properties, inflect them and add to result object
        for (var i = 0; i < predef.nametypes.length; i++) {
            var nametype = predef.nametypes[i];
            if (person[nametype] != null) {
                result[nametype] =
                    inflect(result.gender, person[nametype], gcase, nametype + 'name');
            }
        }
        return result;
    }
85810
def save(self, *args, **kwargs):
        
        if not self.full_name:
            self.full_name = '{0}{1}{2}'.format(
                self.first_name,
                '{}'.format(
                    ' ' + self.middle_name + ' ' if self.middle_name else ' ',
                ),
                self.last_name,
                '{}'.format(' ' + self.suffix if self.suffix else '')
            )

        self.slug = uuslug(
            self.full_name,
            instance=self,
            max_length=100,
            separator='-',
            start_no=2
        )
        if not self.uid:
            self.uid = 'person:{}'.format(self.slug)

        super(Person, self).save(*args, **kwargs)
274671
def name_parts(self):
        """"""

        default = PartialMixin.ANY

        return ([(k, default, True)
                for k, _, _ in PartitionName._name_parts]
                +
                [(k, default, True)
                 for k, _, _ in Name._generated_names]
                )
875944
def _unique_names():
    
    characters = ("abcdefghijklmnopqrstuvwxyz"
                  "0123456789")
    characters = [characters[i:i + 1] for i in irange(len(characters))]
    rng = random.Random()
    while True:
        letters = [rng.choice(characters) for i in irange(10)]
        yield ''.join(letters)
1276020
def random_name(num_surnames=2):
    
    a = []

    # Prefix
    if random.random() < _PROB_PREF:
        a.append(_prefixes[random.randint(0, len(_prefixes) - 1)])

    # Forename
    a.append(_forenames[random.randint(0, len(_forenames) - 1)])

    # Surnames
    for i in range(num_surnames):
        a.append(_surnames[random.randint(0, len(_surnames) - 1)])

    # Suffix
    if random.random() < _PROB_SUFF:
        a.append(_suffixes[random.randint(0, len(_suffixes) - 1)])

    return " ".join(a)
537159
def full_name(self, gender: Optional[Gender] = None,
                  reverse: bool = False) -> str:
        
        if gender is None:
            gender = get_random_item(Gender, rnd=self.random)

        if gender and isinstance(gender, Gender):
            gender = gender
        else:
            raise NonEnumerableError(Gender)

        fmt = '{1} {0}' if reverse else '{0} {1}'
        return fmt.format(
            self.name(gender),
            self.surname(gender),
        )
319159
def full_name(self):
        
        full_name = self.first_name
        if self.last_name:
            full_name += ' ' + self.last_name
        return full_name
698835
def username_or(user, attr):
    
    if not settings.ACCOUNTS_NO_USERNAME:
        attr = "username"
    value = getattr(user, attr)
    if callable(value):
        value = value()
    return value
592365
def arg_name(self):
        
        if self.constraint is bool and self.value:
            return '--no-%s' % self.name.replace('_', '-')
        return '--%s' % self.name.replace('_', '-')
795573
def display_user(value, arg):
    ''' 
    '''
    if value.user == arg and arg.username != ANONYMOUS_USERNAME:
        return "You"
    else:
        return value.user.get_full_name()
619954
def t_NAME(self,t):
    ''
    # warning: this allows stuff like SeLeCt with mixed case. who cares.
    t.type = KEYWORDS[t.value.lower()] if t.value.lower() in KEYWORDS else 'BOOL' if t.value.lower() in ('is','not') else 'NAME'
    return t