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

Overview

Eval results

Files

Specialized Data Providers

Name: tessl/pypi-mimesis
Author: tessl

Additional providers for specific domains including development data, scientific data, file information, and transportation data for specialized testing scenarios.

Capabilities

Development and Software

class Development(BaseProvider):
    def programming_language(self) -> str:
        """Generate programming language name."""
    
    def software_license(self) -> str:
        """Generate software license name."""
    
    def version(self) -> str:
        """Generate version string like '1.2.3'."""
    
    def boolean(self) -> bool:
        """Generate boolean value."""

class Code(BaseProvider):
    def locale_code(self) -> str:
        """Generate locale code like 'en-US'."""
    
    def issn(self) -> str:
        """Generate ISSN number."""
    
    def ean(self, fmt: EANFormat = EANFormat.EAN13) -> str:
        """Generate EAN barcode."""
    
    def imei(self) -> str:
        """Generate IMEI number."""
    
    def pin(self, mask: str = "####") -> str:
        """Generate PIN code."""

Scientific Data

class Science(BaseProvider):
    def dna_sequence(self, length: int = 10) -> str:
        """Generate DNA sequence."""
    
    def rna_sequence(self, length: int = 10) -> str:
        """Generate RNA sequence."""

class Numeric(BaseProvider):
    def integer_number(self, start: int = -1000, end: int = 1000) -> int:
        """Generate integer in range."""
    
    def integers(self, start: int = 0, end: int = 10, n: int = 10) -> list[int]:
        """Generate list of integers."""
    
    def decimal_number(self, start: float = -1000.0, end: float = 1000.0) -> Decimal:
        """Generate decimal number."""
    
    def increment(self, accumulator: int = None) -> int:
        """Generate incrementing numbers."""

File and System Data

class File(BaseProvider):
    def extension(self) -> str:
        """Generate file extension like '.txt'."""
    
    def mime_type(self) -> str:
        """Generate MIME type."""
    
    def file_name(self) -> str:
        """Generate filename with extension."""
    
    def size(self, minimum: int = 1, maximum: int = 100) -> int:
        """Generate file size in MB."""

class BinaryFile(BaseProvider):
    def image(self) -> bytes:
        """Generate binary image data."""
    
    def video(self) -> bytes:
        """Generate binary video data."""
    
    def audio(self) -> bytes:
        """Generate binary audio data."""
    
    def document(self) -> bytes:
        """Generate binary document data."""
    
    def compressed(self) -> bytes:
        """Generate binary compressed file data."""

class Path(BaseProvider):
    def root(self) -> str:
        """Generate root path."""
    
    def home(self) -> str:
        """Generate home directory path."""
    
    def user(self) -> str:
        """Generate user directory path."""
    
    def project_dir(self) -> str:
        """Generate project directory path."""

Food and Hardware

class Food(BaseDataProvider):
    def vegetable(self) -> str:
        """Generate vegetable name."""
    
    def fruit(self) -> str:
        """Generate fruit name."""
    
    def dish(self) -> str:
        """Generate dish name."""
    
    def spices(self) -> str:
        """Generate spice name."""
    
    def drink(self) -> str:
        """Generate drink name."""

class Hardware(BaseProvider):
    def resolution(self) -> str:
        """Generate screen resolution."""
    
    def cpu(self) -> str:
        """Generate CPU name."""
    
    def ram_type(self) -> str:
        """Generate RAM type."""
    
    def graphics(self) -> str:
        """Generate graphics card name."""
    
    def manufacturer(self) -> str:
        """Generate hardware manufacturer."""

Transportation and Cryptographic

class Transport(BaseDataProvider):
    def manufacturer(self) -> str:
        """Generate vehicle manufacturer."""
    
    def car(self) -> str:
        """Generate car model."""
    
    def airplane(self) -> str:
        """Generate airplane model."""
    
    def vehicle_registration_code(self) -> str:
        """Generate vehicle registration."""

class Cryptographic(BaseProvider):
    def uuid(self) -> str:
        """Generate UUID string."""
    
    def hash(self, algorithm: Algorithm = Algorithm.MD5) -> str:
        """Generate hash string."""
    
    def mnemonic_phrase(self, length: int = 12) -> str:
        """Generate mnemonic phrase."""

class Payment(BaseDataProvider):
    def credit_card_number(self, card_type: CardType = None) -> str:
        """Generate credit card number."""
    
    def credit_card_network(self) -> str:
        """Generate credit card network name."""
    
    def credit_card_owner(self) -> dict:
        """Generate credit card owner info."""
    
    def paypal(self) -> str:
        """Generate PayPal email."""

class Choice(BaseProvider):
    def choice(self, *args, **kwargs) -> Any:
        """Make random choice from arguments."""

Usage Examples

from mimesis import Development, Science, Hardware, Cryptographic
from mimesis.enums import Algorithm, CardType

# Development data
dev = Development()
project_data = {
    'language': dev.programming_language(),
    'license': dev.software_license(),
    'version': dev.version(),
    'feature_flag': dev.boolean()
}

# Scientific data
science = Science()
bio_data = {
    'dna': science.dna_sequence(length=20),
    'rna': science.rna_sequence(length=15)
}

# Hardware specs
hardware = Hardware()
system_specs = {
    'cpu': hardware.cpu(),
    'resolution': hardware.resolution(),
    'manufacturer': hardware.manufacturer()
}

# Cryptographic data
crypto = Cryptographic()
security_data = {
    'uuid': crypto.uuid(),
    'md5_hash': crypto.hash(Algorithm.MD5),
    'mnemonic': crypto.mnemonic_phrase(length=24)
}

Install with Tessl CLI