Modern software development often requires large amounts of realistic test data. While Python’s Faker library has been a popular choice for generating synthetic data, Mimesis offers a fresh approach with improved performance and a more intuitive API. In this article, we’ll explore how to set up Mimesis and use it effectively for generating high-quality, reproducible synthetic data.
Setting Up Mimesis and Ensuring Reproducibility
Before we begin generating synthetic data, let’s ensure we have Mimesis properly configured. The latest version (18.0.0) requires Python 3.10 or higher, which allows us to take advantage of all the modern features Python offers. While Mimesis can work with earlier Python versions (3.8 and 3.9) using version 11.1.0, I recommend using Python 3.10 or higher to access all the latest capabilities.
To install Mimesis, we’ll use pip:
pip install mimesis==18.0.0
I’m explicitly specifying the version number here, which is a best practice that prevents unintended upgrades and ensures your code remains reproducible. Before running this command, make sure you’re working in a virtual environment – this helps keep your project dependencies isolated and manageable. For additional details and guidelines on how to install this library, please visit the official documentation.
To ensure reproducibility in our examples, we’ll set up a random seed that we’ll use throughout this article:
from mimesis.random import Random from mimesis import Generic, Person, Address, Finance from mimesis.locales import Locale # Set up our random seed for reproducibility random = Random() random.seed(42) # Initialize our generic provider with the seed generic = Generic(locale=Locale.EN, seed=42)
By setting this seed, you’ll be able to reproduce exactly the same synthetic data shown in our examples. This is particularly useful when you’re debugging or writing tests that need consistent data.
Understanding How Mimesis Works
Mimesis takes its name from the ancient Greek concept of mimicking or imitating reality. This philosophy is reflected in its design: rather than generating purely random data, Mimesis focuses on creating realistic, contextually appropriate synthetic data. The library achieves this through a carefully structured provider system and built-in locale support.
Let’s explore basic data generation with our seeded instance of Mimesis:
# Initialize providers with locale and seed
person = Person(locale=Locale.EN, seed=42)
address = Address(locale=Locale.EN, seed=42)
finance = Finance(locale=Locale.EN, seed=42)
# Generate basic personal and financial information
print("Name:", person.full_name())
print("Email:", person.email())
print("Address:", address.address())
print("Job:", person.occupation())
print("\nFinancial Information:")
print("Company:", finance.company())
When we run this code, we’ll get the same output every time:
Name: Anthony Reilly Email: holds1871@live.com Address: 1310 Collingwood Avenue Job: Choreographer Financial Information: Company: Bradley Pharmaceuticals
Let’s examine what makes this output interesting. Each piece of generated data shows Mimesis’s ability to create realistic, diverse information that mirrors real-world patterns. The person’s name follows natural naming conventions, while the email address demonstrates how Mimesis can generate credible usernames paired with real email providers. The address includes proper street numbering and naming conventions, and the occupation “Choreographer” shows how Mimesis extends beyond typical corporate roles to include a wide range of professions. Finally, the company name “Bradley Pharmaceuticals” reflects common business naming patterns by combining a plausible surname with an industry descriptor, making it particularly valuable for generating test data across different business sectors.
Understanding Provider Categories in Depth
One of Mimesis’s most powerful features is its organized provider system. At the heart of this system is the Generic provider, which serves as a convenient gateway to all of Mimesis’s specialized data generators. Let’s start by exploring what providers are available to us:
from mimesis import Generic
from mimesis.locales import Locale
generic = Generic(locale=Locale.EN)
# Let's see what providers are available
print("Available providers through Generic:")
for attr in dir(generic):
if not attr.startswith('_'): # Skip internal attributes
print(attr)
Available providers through Generic: address binaryfile choice code cryptographic datetime development file finance food hardware internet numeric path payment person science text transport
Think of the Generic provider as a well-organized toolbox, where each provider is a specialized set of tools designed for a specific type of data generation. These providers can be grouped into several logical categories based on their purpose:
Personal and Business Information: The ‘person’, ‘address’, and ‘finance’ providers work together to create realistic human and business profiles. For example, while the person provider handles names and personal identifiers, the finance provider manages everything from bank accounts to company names, and the address provider ensures location data follows real-world formats.
Digital and Technical Data: The ‘internet’, ‘development’, and ‘code’ providers are essential for generating technology-related data. Whether you need email addresses, usernames, programming language names, or even repository URLs, these providers have you covered. The ‘cryptographic’ provider adds another layer by generating secure tokens and hashes.
Date and Number Handling: The ‘datetime’ and ‘numeric’ providers offer specialized tools for generating dates, times, and numbers in various formats. These are particularly useful when you need to create test data for date-dependent applications or numerical analysis.
Leveraging Locale Support for International Applications
One of Mimesis’s standout features is its sophisticated handling of locales. When creating test data for international applications, it’s important that our synthetic data reflects not just different languages, but also the cultural norms and formatting conventions of different regions. Mimesis handles this elegantly through its locale system.
Let’s explore how Mimesis adapts its data generation based on locale settings. First, we’ll look at the available locales:
from mimesis.locales import Locale
print("Available Locales:")
for locale in Locale:
print(f"- {locale}: {locale.value}")
Available Locales: - Locale.AR_AE: ar-ae - Locale.AR_DZ: ar-dz - Locale.AR_EG: ar-eg - Locale.AR_JO: ar-jo - Locale.AR_OM: ar-om - Locale.AR_SY: ar-sy - Locale.AR_YE: ar-ye - Locale.CS: cs - Locale.DA: da - Locale.DE: de - Locale.DE_AT: de-at - Locale.DE_CH: de-ch - Locale.EL: el - Locale.EN: en - Locale.EN_AU: en-au - Locale.EN_CA: en-ca - Locale.EN_GB: en-gb - Locale.ES: es - Locale.ES_MX: es-mx - Locale.ET: et - Locale.FA: fa - Locale.FI: fi - Locale.FR: fr - Locale.HU: hu - Locale.HR: hr - Locale.IS: is - Locale.IT: it - Locale.JA: ja - Locale.KK: kk - Locale.KO: ko - Locale.NL: nl - Locale.NL_BE: nl-be - Locale.NO: no - Locale.PL: pl - Locale.PT: pt - Locale.PT_BR: pt-br - Locale.RU: ru - Locale.SK: sk - Locale.SV: sv - Locale.TR: tr - Locale.UK: uk - Locale.ZH: zh
To understand how locales affect data generation, let’s create a simple example that generates person and address information across different regions. We’ll maintain our use of seeds to ensure reproducible results:
from mimesis import Person
from mimesis.locales import Locale
# Create a dictionary to store our examples
examples = {}
# Generate examples for a few diverse locales
locales = [Locale.EN, Locale.JA, Locale.FR, Locale.RU]
for locale in locales:
person = Person(locale=locale, seed=42) # Using the same seed for consistency
examples[locale] = {
"Full Name": person.full_name(),
"Phone": person.telephone(),
"Email": person.email(),
"Job": person.occupation()
}
# Display the results
for locale, data in examples.items():
print(f"\n{locale.value.upper()} Examples:")
for key, value in data.items():
print(f"{key}: {value}")
EN Examples: Full Name: Anthony Reilly Phone: +1-309-276-8040 Email: guitars1813@yahoo.com Job: Yacht Master JA Examples: Full Name: 石松 田場 Phone: +81 117 5500 2657 Email: readers2029@example.org Job: レコーディング・エンジニア FR Examples: Full Name: Alexy Rigal Phone: 0427680402 Email: appeared1901@example.org Job: Responsable de la promotion des ventes RU Examples: Full Name: Альберт Замятина Phone: +7-(937)-680-40-25 Email: water2079@duck.com Job: Диетолог
Looking at the available locales, we can see that Mimesis provides extensive support for regional variations within languages. For instance, it doesn’t just support “English” as a single locale, but includes specific variants for Australia (en-au), Canada (en-ca), and Great Britain (en-gb). Similarly, Arabic support includes multiple regional dialects (ar-ae, ar-dz, ar-eg, etc.), recognizing the importance of cultural and linguistic variations within the same language family.
When we examine the generated data across different locales, several sophisticated features become apparent:
Name Formatting: Each locale generates culturally appropriate names. The Japanese example (石松 田場) uses proper kanji characters and follows Japanese naming conventions. The Russian name (Альберт Замятина) uses Cyrillic characters and appropriate name structures. The French name (Alexy Rigal) demonstrates how Mimesis handles Western European naming patterns.
Phone Numbers: Phone number formatting is particularly interesting as it follows region-specific conventions. The US number includes the North American country code (+1), the Japanese number uses the correct country code (+81), and the Russian number follows the standard Russian mobile format with the +7 prefix. Notice how the French number uses a local format without the country code, as would be common in domestic French applications.
Email Addresses: While email addresses are generally following international conventions, Mimesis includes modern providers like ‘duck.com’ alongside traditional ones like ‘yahoo.com’. The system generates usernames that could plausibly belong to users from any locale, making the data feel more natural and less obviously synthetic.
Job Titles: The job titles demonstrate Mimesis’s deep cultural awareness. Rather than simple translations, we see job titles that make sense in their cultural context. The Japanese ‘レコーディング・エンジニア’ (Recording Engineer) uses katakana as appropriate for technical roles, while the French ‘Responsable de la promotion des ventes’ (Sales Promotion Manager) uses the formal business terminology common in French corporate settings.
This level of locale support makes Mimesis particularly valuable for testing international applications. The generated data isn’t just linguistically appropriate – it’s culturally authentic, following the conventions and patterns that real users would expect in each region. This attention to detail helps catch locale-specific issues early in the development process, whether they’re related to character encoding, string length, or formatting conventions.
Embracing Modern Synthetic Data Generation
Throughout this article, we’ve explored how Mimesis provides a modern, performant approach to synthetic data generation. Its thoughtfully organized provider system, comprehensive locale support, and focus on reproducibility through seeding make it a powerful tool for today’s development challenges.
What sets Mimesis apart from traditional solutions like Faker (which we explored in our previous article) is its architectural approach. While both libraries serve the purpose of generating synthetic data, Mimesis introduces several modern improvements:
- Performance-First Design: Mimesis is built with performance in mind, using pre-computed data sets and efficient algorithms instead of regular expressions for data generation. This makes it particularly suitable for generating large datasets in modern applications.
- Intuitive Provider Organization: The provider system we explored offers a more structured approach to data generation. Rather than mixing different types of data generation methods, each provider has a clear, specific purpose, making the code more maintainable and easier to understand.
- Enhanced Locale Support: As we demonstrated, Mimesis goes beyond simple translation to provide culturally aware data generation. This is crucial for modern applications that need to serve a global audience while maintaining cultural authenticity.
- Built-in Reproducibility: The seed-based approach we used throughout our examples ensures consistent data generation across different environments – a critical feature for modern testing and development workflows.
Whether you’re building a new application, testing an existing system, or creating demonstration data, Mimesis offers a fresh perspective on synthetic data generation that aligns well with modern development practices. Its focus on performance, structure, and cultural awareness makes it a valuable addition to any developer’s toolkit.
