Configuration and Utilities

class Locale(Enum):
    """Supported locales for data generation."""
    
    DEFAULT = "en"
    EN = "en"
    EN_US = "en-us"
    EN_GB = "en-gb"
    DE = "de"
    DE_DE = "de-de"
    FR = "fr"
    ES = "es"
    IT = "it"
    JA = "ja"
    ZH = "zh"
    RU = "ru"
    # ... 35+ total locales

def validate_locale(locale: Union[str, Locale]) -> Locale:
    """Validate and convert locale to Locale enum."""

def luhn_checksum(num: str) -> str:
    """
    Calculate Luhn checksum for validation algorithms.
    
    Parameters:
    - num (str): Number string to calculate checksum for
    
    Returns:
    str: Number with checksum digit appended
    """

def romanize(locale: Locale) -> callable:
    """
    Create romanization function for specific locale.
    
    Parameters:
    - locale (Locale): Source locale for romanization
    
    Returns:
    callable: Function that romanizes text from locale
    """

def maybe(value: Any, probability: float = 0.5) -> callable:
    """
    Create probabilistic value function.
    
    Parameters:
    - value: Value to return probabilistically
    - probability (float): Probability of returning value (0.0-1.0)
    
    Returns:
    callable: Function that returns value or None based on probability
    """

class Gender(Enum):
    MALE = "male"
    FEMALE = "female"

class CountryCode(Enum):
    A2 = "a2"        # ISO 3166-1 alpha-2
    A3 = "a3"        # ISO 3166-1 alpha-3
    NUMERIC = "numeric"

class TimezoneRegion(Enum):
    AFRICA = "africa"
    AMERICA = "america"
    ANTARCTICA = "antarctica"
    ARCTIC = "arctic"
    ASIA = "asia"
    ATLANTIC = "atlantic"
    AUSTRALIA = "australia"
    EUROPE = "europe"
    INDIAN = "indian"
    PACIFIC = "pacific"

class CardType(Enum):
    VISA = "visa"
    MASTERCARD = "mastercard"
    AMERICAN_EXPRESS = "american_express"
    DISCOVER = "discover"

class Algorithm(Enum):
    MD5 = "md5"
    SHA1 = "sha1"
    SHA224 = "sha224"
    SHA256 = "sha256"
    SHA384 = "sha384"
    SHA512 = "sha512"

class FileType(Enum):
    SOURCE = "source"
    TEXT = "text"
    DATA = "data"
    AUDIO = "audio"
    VIDEO = "video"
    IMAGE = "image"
    EXECUTABLE = "executable"
    COMPRESSED = "compressed"

class MimeType(Enum):
    APPLICATION = "application"
    AUDIO = "audio"
    EXAMPLE = "example"
    FONT = "font"
    IMAGE = "image"
    MESSAGE = "message"
    MODEL = "model"
    MULTIPART = "multipart"
    TEXT = "text"
    VIDEO = "video"

class PortRange(Enum):
    ALL = "all"
    WELL_KNOWN = "well_known"        # 1-1023
    EPHEMERAL = "ephemeral"          # 32768-65535

class URLScheme(Enum):
    HTTP = "http"
    HTTPS = "https"
    FTP = "ftp"
    SFTP = "sftp"
    WS = "ws"
    WSS = "wss"

class LocaleError(Exception):
    """Raised when locale is not supported or invalid."""

class SchemaError(Exception):
    """Raised when schema definition is invalid."""

class NonEnumerableError(Exception):
    """Raised when value is not a valid enum member."""

class FieldError(Exception):
    """Raised when field operation fails."""

class FieldsetError(Exception):
    """Raised when fieldset operation fails."""

class FieldArityError(Exception):
    """Raised when field handler has wrong number of arguments."""

class FieldNameError(Exception):
    """Raised when field name is invalid."""

# Factory Boy Integration
class FactoryField:
    """Integration with Factory Boy for factory definitions."""
    
    def __init__(self, provider_method: str, **kwargs):
        """Initialize with provider method and arguments."""

MimesisField = FactoryField  # Alias

# Pytest Integration
def mimesis_locale() -> Locale:
    """Pytest fixture providing default locale."""

def mimesis() -> Field:
    """Pytest fixture providing Field instance."""

from mimesis.locales import Locale, validate_locale

# Using different locales
person_en = Person(Locale.EN)
person_de = Person(Locale.DE)
person_ja = Person(Locale.JA)

# Locale validation
valid_locale = validate_locale("en-us")  # Returns Locale.EN_US

from mimesis.keys import romanize, maybe
from mimesis.shortcuts import luhn_checksum

# Romanization
romanize_ja = romanize(Locale.JA)
romanized_text = romanize_ja("こんにちは")  # "konnichiwa"

# Probabilistic values
maybe_value = maybe("special", probability=0.3)
result = maybe_value()  # Returns "special" 30% of the time, None 70%

# Luhn checksum
card_number = "424242424242424"
valid_card = luhn_checksum(card_number)  # Adds checksum digit

from mimesis import Internet, Finance, Address
from mimesis.enums import PortRange, CardType, CountryCode

internet = Internet()
finance = Finance()
address = Address()

# Configure with enums
port = internet.port(PortRange.WELL_KNOWN)     # Port 1-1023
card = finance.credit_card_number(CardType.VISA)
country = address.country_code(CountryCode.A3)  # 3-letter code

import factory
from mimesis.plugins.factory import MimesisField

class UserFactory(factory.Factory):
    class Meta:
        model = User
    
    name = MimesisField('person.full_name')
    email = MimesisField('internet.email')
    age = MimesisField('person.age', minimum=18, maximum=65)

# Create users
user = UserFactory()

import pytest
from mimesis.plugins.pytest import mimesis, mimesis_locale

def test_user_creation(mimesis):
    """Test using mimesis pytest fixture."""
    name = mimesis('person.full_name')
    email = mimesis('internet.email')
    
    assert isinstance(name, str)
    assert '@' in email

def test_with_locale(mimesis_locale):
    """Test using locale fixture."""
    person = Person(mimesis_locale)
    name = person.full_name()
    assert isinstance(name, str)

from mimesis import Person
from mimesis.exceptions import LocaleError, NonEnumerableError
from mimesis.enums import Gender

try:
    person = Person("invalid-locale")
except LocaleError as e:
    print(f"Invalid locale: {e}")

try:
    person = Person()
    name = person.first_name(gender="invalid")
except NonEnumerableError as e:
    print(f"Invalid enum value: {e}")

import mimesis

# Package information
print(mimesis.__version__)      # "18.0.0"
print(mimesis.__title__)        # "mimesis"
print(mimesis.__description__)  # "Mimesis: Fake Data Generator."
print(mimesis.__author__)       # "Isaak Uchakaev (Likid Geimfari)"
print(mimesis.__license__)      # "MIT License"