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

Internet and Network Data

Name: tessl/pypi-mimesis
Author: tessl

Generate internet-related data including IP addresses, domains, URLs, user agents, and network protocols with proper formatting and validation for testing web applications and network systems.

Capabilities

Email and Domain Generation

Generate email addresses and domain names with realistic formatting.

class Internet(BaseProvider):
    
    def top_level_domain(self, tld_type: TLDType = TLDType.CCTLD) -> str:
        """
        Generate a top-level domain.
        
        Parameters:
        - tld_type (TLDType): Type of TLD (CCTLD, GTLD, etc.)
        
        Returns:
        str: TLD like ".com", ".org", ".uk"
        """
    
    def tld(self) -> str:
        """
        Alias for top_level_domain().
        
        Returns:
        str: Top-level domain
        """

IP Address Generation

Generate IPv4 and IPv6 addresses with various purposes and formats.

class Internet(BaseProvider):
    def ip_v4(self) -> str:
        """
        Generate a random IPv4 address.
        
        Returns:
        str: IPv4 address like "192.168.1.1"
        """
    
    def ip_v4_object(self) -> ipaddress.IPv4Address:
        """
        Generate an IPv4 address object.
        
        Returns:
        IPv4Address: IPv4 address object
        """
    
    def ip_v4_with_port(self, port_range: PortRange = PortRange.ALL) -> str:
        """
        Generate IPv4 address with port number.
        
        Parameters:
        - port_range (PortRange): Port range type (ALL, WELL_KNOWN, etc.)
        
        Returns:
        str: IPv4 with port like "192.168.1.1:8080"
        """
    
    def ip_v6(self) -> str:
        """
        Generate a random IPv6 address.
        
        Returns:
        str: IPv6 address like "2001:db8::1"
        """
    
    def ip_v6_object(self) -> ipaddress.IPv6Address:
        """
        Generate an IPv6 address object.
        
        Returns:
        IPv6Address: IPv6 address object
        """
    
    def special_ip_v4(self, purpose: IPv4Purpose = None) -> str:
        """
        Generate special-purpose IPv4 address.
        
        Parameters:
        - purpose (IPv4Purpose): Purpose type (PRIVATE, LOOPBACK, etc.)
        
        Returns:
        str: Special IPv4 address
        """
    
    def special_ip_v4_object(self, purpose: IPv4Purpose = None) -> ipaddress.IPv4Address:
        """
        Generate special-purpose IPv4 address object.
        
        Parameters:
        - purpose (IPv4Purpose): Purpose type
        
        Returns:
        IPv4Address: Special IPv4 address object
        """

Network Infrastructure

Generate network-related identifiers and infrastructure data.

class Internet(BaseProvider):
    def mac_address(self) -> str:
        """
        Generate a MAC address.
        
        Returns:
        str: MAC address like "00:1B:63:84:45:E6"
        """
    
    def port(self, port_range: PortRange = PortRange.ALL) -> int:
        """
        Generate a port number.
        
        Parameters:
        - port_range (PortRange): Port range (ALL, WELL_KNOWN, EPHEMERAL)
        
        Returns:
        int: Port number like 8080, 80, 443
        """
    
    def asn(self) -> str:
        """
        Generate an Autonomous System Number.
        
        Returns:
        str: ASN like "AS64512"
        """
    
    def public_dns(self) -> str:
        """
        Generate a public DNS server address.
        
        Returns:
        str: DNS server IP like "8.8.8.8"
        """

URL and Web Data

Generate URLs, slugs, and web-related data structures.

class Internet(BaseProvider):
    def url(self, scheme: URLScheme = None) -> str:
        """
        Generate a complete URL.
        
        Parameters:
        - scheme (URLScheme): URL scheme (HTTP, HTTPS, FTP, etc.)
        
        Returns:
        str: URL like "https://example.com/path"
        """
    
    def slug(self, parts_count: int = None) -> str:
        """
        Generate a URL slug.
        
        Parameters:
        - parts_count (int): Number of parts in slug
        
        Returns:
        str: Slug like "some-url-slug"
        """
    
    def query_string(self, length: int = None) -> str:
        """
        Generate a URL query string.
        
        Parameters:
        - length (int): Number of query parameters
        
        Returns:
        str: Query string like "param1=value1&param2=value2"
        """
    
    def query_parameters(self, length: int = None) -> dict:
        """
        Generate query parameters as dictionary.
        
        Parameters:
        - length (int): Number of parameters
        
        Returns:
        dict: Parameters like {"param1": "value1", "param2": "value2"}
        """

HTTP Protocol Data

Generate HTTP-related data including status codes, methods, and headers.

class Internet(BaseProvider):
    def http_status_code(self) -> int:
        """
        Generate an HTTP status code.
        
        Returns:
        int: Status code like 200, 404, 500
        """
    
    def http_status_message(self) -> str:
        """
        Generate an HTTP status message.
        
        Returns:
        str: Status message like "OK", "Not Found"
        """
    
    def http_method(self) -> str:
        """
        Generate an HTTP method.
        
        Returns:
        str: Method like "GET", "POST", "PUT"
        """
    
    def http_request_headers(self) -> dict:
        """
        Generate HTTP request headers.
        
        Returns:
        dict: Headers dictionary
        """
    
    def http_response_headers(self) -> dict:
        """
        Generate HTTP response headers.
        
        Returns:
        dict: Headers dictionary
        """
    
    def user_agent(self) -> str:
        """
        Generate a user agent string.
        
        Returns:
        str: User agent like "Mozilla/5.0 (Windows NT 10.0; Win64; x64)..."
        """

Content Types and Data Sources

Generate MIME types and database connection strings.

class Internet(BaseProvider):
    def content_type(self, mime_type: MimeType = None) -> str:
        """
        Generate a content type/MIME type.
        
        Parameters:
        - mime_type (MimeType): MIME type category
        
        Returns:
        str: Content type like "application/json", "text/html"
        """
    
    def dsn(self, dsn_type: DSNType = None, **kwargs) -> str:
        """
        Generate a Data Source Name (database connection string).
        
        Parameters:
        - dsn_type (DSNType): Database type (POSTGRESQL, MYSQL, etc.)
        - **kwargs: Additional connection parameters
        
        Returns:
        str: DSN like "postgresql://user:pass@localhost:5432/db"
        """

Additional Web Resources

Generate additional internet resources including hostnames, URIs, paths, and stock images.

class Internet(BaseProvider):
    def hostname(self, tld_type: TLDType = None, subdomains: list[str] = None) -> str:
        """
        Generate a hostname without scheme.
        
        Parameters:
        - tld_type (TLDType): Type of top-level domain
        - subdomains (list[str]): List of subdomains to choose from
        
        Returns:
        str: Hostname like "api.example.com"
        """
    
    def uri(
        self, 
        scheme: URLScheme = URLScheme.HTTPS,
        tld_type: TLDType = None,
        subdomains: list[str] = None,
        query_params_count: int = None
    ) -> str:
        """
        Generate a complete URI with optional query parameters.
        
        Parameters:
        - scheme (URLScheme): URL scheme (HTTP, HTTPS, FTP, etc.)
        - tld_type (TLDType): Type of top-level domain  
        - subdomains (list[str]): List of subdomains
        - query_params_count (int): Number of query parameters
        
        Returns:
        str: Complete URI like "https://api.example.com/path?param=value"
        """
    
    def path(self, *args, **kwargs) -> str:
        """
        Generate a URL path.
        
        Parameters:
        - *args: Arguments passed to slug method
        - **kwargs: Keyword arguments passed to slug method
        
        Returns:
        str: Path like "/some/url/path"
        """
    
    @staticmethod
    def stock_image_url(
        width: int | str = 1920,
        height: int | str = 1080, 
        keywords: list[str] = None
    ) -> str:
        """
        Generate a stock image URL from Unsplash.
        
        Parameters:
        - width (int|str): Image width in pixels
        - height (int|str): Image height in pixels
        - keywords (list[str]): Search keywords for image
        
        Returns:
        str: Unsplash image URL
        """

Usage Examples

Basic Internet Data

from mimesis import Internet

internet = Internet()

# Generate basic internet data
web_data = {
    'ip': internet.ip_v4(),
    'url': internet.url(),
    'user_agent': internet.user_agent(),
    'mac': internet.mac_address(),
    'port': internet.port()
}

IP Address Generation

from mimesis import Internet
from mimesis.enums import PortRange, IPv4Purpose

internet = Internet()

# Different IP formats
ipv4_basic = internet.ip_v4()                    # "192.168.1.1"
ipv4_with_port = internet.ip_v4_with_port()      # "192.168.1.1:8080"
ipv6_basic = internet.ip_v6()                    # "2001:db8::1"

# Special-purpose addresses
private_ip = internet.special_ip_v4(IPv4Purpose.PRIVATE)    # "10.0.0.1"
loopback_ip = internet.special_ip_v4(IPv4Purpose.LOOPBACK)  # "127.0.0.1"

# IP objects for advanced operations
ipv4_obj = internet.ip_v4_object()
network = ipv4_obj.network  # Can access network methods

Network Infrastructure

from mimesis import Internet
from mimesis.enums import PortRange

internet = Internet()

# Network identifiers
mac = internet.mac_address()           # "00:1B:63:84:45:E6"
dns = internet.public_dns()            # "8.8.8.8"
asn = internet.asn()                   # "AS64512"

# Port numbers
well_known_port = internet.port(PortRange.WELL_KNOWN)  # 80, 443, 22
ephemeral_port = internet.port(PortRange.EPHEMERAL)    # 32768-65535

HTTP and Web Data

from mimesis import Internet
from mimesis.enums import URLScheme

internet = Internet()

# HTTP data
status_code = internet.http_status_code()    # 200
status_msg = internet.http_status_message()  # "OK"
method = internet.http_method()              # "GET"

# URLs and slugs
https_url = internet.url(URLScheme.HTTPS)    # "https://example.com/path"
ftp_url = internet.url(URLScheme.FTP)        # "ftp://files.example.com/"
slug = internet.slug(parts_count=3)          # "some-nice-slug"

# Query parameters
query_str = internet.query_string(length=3)  # "a=1&b=2&c=3"
query_dict = internet.query_parameters(length=2)  # {"param1": "value1", "param2": "value2"}

Headers and Content Types

from mimesis import Internet
from mimesis.enums import MimeType

internet = Internet()

# HTTP headers
request_headers = internet.http_request_headers()
# {'User-Agent': '...', 'Accept': '...', 'Accept-Language': '...'}

response_headers = internet.http_response_headers()
# {'Content-Type': '...', 'Server': '...', 'Content-Length': '...'}

# Content types
json_type = internet.content_type(MimeType.APPLICATION)  # "application/json"
html_type = internet.content_type(MimeType.TEXT)         # "text/html"

Database Connection Strings

from mimesis import Internet
from mimesis.enums import DSNType

internet = Internet()

# Different database types
postgres_dsn = internet.dsn(DSNType.POSTGRESQL)
# "postgresql://user:password@localhost:5432/database"

mysql_dsn = internet.dsn(DSNType.MYSQL)
# "mysql://user:password@localhost:3306/database"

# Custom DSN parameters
custom_dsn = internet.dsn(
    DSNType.POSTGRESQL,
    host="custom-host",
    port=5433,
    database="mydb"
)

Complete Web Service Profile

from mimesis import Internet
from mimesis.enums import URLScheme, PortRange

def generate_web_service_profile():
    internet = Internet()
    
    return {
        'service': {
            'domain': internet.domain_name(),
            'url': internet.url(URLScheme.HTTPS),
            'api_endpoint': f"{internet.url()}/api/v1",
        },
        'infrastructure': {
            'ip_v4': internet.ip_v4(),
            'ip_v6': internet.ip_v6(),
            'port': internet.port(PortRange.WELL_KNOWN),
            'mac_address': internet.mac_address(),
        },
        'monitoring': {
            'dns_servers': [internet.public_dns() for _ in range(2)],
            'asn': internet.asn(),
        },
        'http': {
            'methods': [internet.http_method() for _ in range(3)],
            'user_agents': [internet.user_agent() for _ in range(2)],
            'content_types': [internet.content_type() for _ in range(3)],
        },
        'database': {
            'dsn': internet.dsn(DSNType.POSTGRESQL),
            'backup_dsn': internet.dsn(DSNType.MYSQL),
        }
    }

service_profile = generate_web_service_profile()

Install with Tessl CLI