tessl/pypi-mimesis
Mimesis is a robust fake data generator for Python that produces realistic fake data across 35 different locales with high performance and multilingual support.
—
Pending
personal-data.mddocs/
Personal Data Generation
Generate realistic personal information including names, demographics, contact details, and identification data with proper localization support across 35+ locales.
Capabilities
Name Generation
Generate names with locale-appropriate formatting and gender considerations.
class Person(BaseDataProvider):
def full_name(self, gender: Gender = None) -> str:
"""
Generate a full name (first + last).
Parameters:
- gender (Gender, optional): Specify gender for name selection
Returns:
str: Full name like "John Smith"
"""
def first_name(self, gender: Gender = None) -> str:
"""
Generate a first name.
Parameters:
- gender (Gender, optional): MALE or FEMALE for gender-specific names
Returns:
str: First name like "John" or "Jane"
"""
def surname(self) -> str:
"""
Generate a surname/family name.
Returns:
str: Last name like "Smith"
"""
def last_name(self) -> str:
"""
Alias for surname().
Returns:
str: Last name like "Johnson"
"""
def name(self, gender: Gender = None) -> str:
"""
Alias for full_name().
Parameters:
- gender (Gender, optional): Specify gender for name selection
Returns:
str: Full name
"""
def title(self, gender: Gender = None, title_type: TitleType = None) -> str:
"""
Generate a personal title.
Parameters:
- gender (Gender, optional): Gender for title selection
- title_type (TitleType, optional): Type of title (TYPICAL, ACADEMIC, etc.)
Returns:
str: Title like "Mr.", "Dr.", "Prof."
"""
def username(self, mask: str = None, drange: tuple[int, int] = (1800, 2100)) -> str:
"""
Generate a username.
Parameters:
- mask (str, optional): Format mask for username
- drange (tuple): Date range for numeric components
Returns:
str: Username like "user123", "john_doe2024"
"""Contact Information
Generate email addresses, phone numbers, and other contact details.
class Person(BaseDataProvider):
def email(self) -> str:
"""
Generate an email address.
Returns:
str: Email like "user@example.com"
"""
def phone_number(self, mask: str = "", placeholder: str = "#") -> str:
"""
Generate a phone number with optional formatting.
Parameters:
- mask (str): Format mask (e.g., "+1-###-###-####")
- placeholder (str): Character to replace in mask (default "#")
Returns:
str: Formatted phone number
Usage:
```python
person.phone_number() # "555-123-4567"
person.phone_number(mask="+1 (###) ###-####") # "+1 (555) 123-4567"
```
"""
def telephone(self) -> str:
"""
Alias for phone_number().
Returns:
str: Phone number
"""Demographics and Physical Attributes
Generate demographic data and physical characteristics.
class Person(BaseDataProvider):
def birthdate(self, min_year: int = 1980, max_year: int = 2023) -> datetime.date:
"""
Generate a birth date.
Parameters:
- min_year (int): Minimum birth year
- max_year (int): Maximum birth year
Returns:
datetime.date: Birth date
"""
def gender(self) -> str:
"""
Generate a gender.
Returns:
str: Gender like "Male" or "Female"
"""
def gender_symbol(self) -> str:
"""
Generate a gender symbol.
Returns:
str: Symbol like "♂" or "♀"
"""
def gender_code(self) -> int:
"""
Generate a gender code.
Returns:
int: 0 for male, 1 for female
"""
def sex(self) -> str:
"""
Alias for gender().
Returns:
str: Sex/gender
"""
def height(self, minimum: float = 1.5, maximum: float = 2.0) -> str:
"""
Generate height in meters.
Parameters:
- minimum (float): Minimum height in meters
- maximum (float): Maximum height in meters
Returns:
str: Height like "1.75 m"
"""
def weight(self, minimum: int = 38, maximum: int = 90) -> int:
"""
Generate weight in kilograms.
Parameters:
- minimum (int): Minimum weight in kg
- maximum (int): Maximum weight in kg
Returns:
int: Weight in kg
"""
def blood_type(self) -> str:
"""
Generate a blood type.
Returns:
str: Blood type like "A+", "O-", "AB+"
"""Professional and Educational Information
Generate career, education, and professional data.
class Person(BaseDataProvider):
def occupation(self) -> str:
"""
Generate an occupation/job title.
Returns:
str: Job title like "Software Engineer", "Teacher"
"""
def university(self) -> str:
"""
Generate a university name.
Returns:
str: University name
"""
def academic_degree(self) -> str:
"""
Generate an academic degree.
Returns:
str: Degree like "Bachelor of Science", "Master of Arts"
"""
def language(self) -> str:
"""
Generate a language name.
Returns:
str: Language like "English", "Spanish"
"""Personal Views and Characteristics
Generate personal beliefs, views, and characteristics.
class Person(BaseDataProvider):
def political_views(self) -> str:
"""
Generate political views.
Returns:
str: Political leaning like "Liberal", "Conservative"
"""
def worldview(self) -> str:
"""
Generate a worldview/philosophy.
Returns:
str: Worldview like "Humanist", "Pragmatist"
"""
def views_on(self) -> str:
"""
Generate random views on various topics.
Returns:
str: Views on topics like politics, religion, etc.
"""
def nationality(self, gender: Gender = None) -> str:
"""
Generate nationality based on locale.
Parameters:
- gender (Gender, optional): Gender for language-specific forms
Returns:
str: Nationality like "American", "German"
"""Identification and Security
Generate identification numbers, passwords, and security-related data.
class Person(BaseDataProvider):
def identifier(self, mask: str = "##-##/##") -> str:
"""
Generate an identifier with custom format.
Parameters:
- mask (str): Format mask using # as placeholder
Returns:
str: Formatted identifier
Usage:
```python
person.identifier("##-##/##") # "12-34/56"
person.identifier("ID-####") # "ID-1234"
```
"""
def password(self, length: int = 8, hashed: bool = False) -> str:
"""
Generate a password.
Parameters:
- length (int): Password length
- hashed (bool): Return hashed password if True
Returns:
str: Password or hashed password
"""Usage Examples
Basic Personal Data
from mimesis import Person
from mimesis.locales import Locale
person = Person(Locale.EN)
# Generate complete profile
profile = {
'name': person.full_name(),
'email': person.email(),
'phone': person.phone_number(),
'age': person.age(),
'occupation': person.occupation()
}Localized Names
from mimesis import Person
from mimesis.locales import Locale
# Different locales produce appropriate names
person_en = Person(Locale.EN)
person_ja = Person(Locale.JA)
person_de = Person(Locale.DE)
english_name = person_en.full_name() # "John Smith"
japanese_name = person_ja.full_name() # "田中太郎"
german_name = person_de.full_name() # "Hans Müller"Gender-Specific Data
from mimesis import Person
from mimesis.enums import Gender
person = Person()
# Generate gender-specific names
male_name = person.first_name(gender=Gender.MALE) # "James"
female_name = person.first_name(gender=Gender.FEMALE) # "Sarah"
# Gender-specific nationality (for languages with gender forms)
male_nationality = person.nationality(gender=Gender.MALE)
female_nationality = person.nationality(gender=Gender.FEMALE)Formatted Contact Information
from mimesis import Person
person = Person()
# Different phone number formats
us_phone = person.phone_number(mask="+1 (###) ###-####") # "+1 (555) 123-4567"
intl_phone = person.phone_number(mask="+##-##-###-####") # "+12-34-567-8901"
# Custom identifiers
ssn = person.identifier(mask="###-##-####") # "123-45-6789"
employee_id = person.identifier(mask="EMP-####") # "EMP-1234"Complete User Profile
from mimesis import Person
from mimesis.enums import Gender
person = Person(Locale.EN)
def generate_user_profile():
gender = person.gender()
return {
'personal': {
'name': person.full_name(),
'gender': gender,
'age': person.age(minimum=18, maximum=65),
'birthdate': person.birthdate(min_year=1960, max_year=2005),
'nationality': person.nationality(),
},
'contact': {
'email': person.email(),
'phone': person.phone_number(mask="+1-###-###-####"),
},
'physical': {
'height': person.height(),
'weight': person.weight(),
'blood_type': person.blood_type(),
},
'professional': {
'occupation': person.occupation(),
'university': person.university(),
'degree': person.academic_degree(),
},
'personal_views': {
'political': person.political_views(),
'worldview': person.worldview(),
}
}
profile = generate_user_profile()Install with Tessl CLI
npx tessl i tessl/pypi-mimesis