fake module

https://github.com/barseghyanartur/fake.py/

class fake.AuthorshipData

Bases: object

first_names: Set[str] = {'Andre', 'Andrew', 'Andrey', 'Anthony', 'Barry', 'Ben', 'Benjamin', 'Christian', 'Collin', 'David', 'Donald', 'Eric', 'Ezio', 'George', 'Gregor', 'Guido', 'Guilherme', 'Jack', 'Jacques', 'Jiwon', 'Ka-Ping', 'Keith', 'Kenneth', 'Lars', 'Marc-Andre', 'Martin', 'Michael', 'Mike', 'Nadeem', 'Nick', 'Paul', 'Piers', 'Skip', 'Steen', 'Steven', 'Thomas', 'Victor', 'Vinay', 'Zooko'}

last_names: Set[str] = {'Ascher', 'Baxter', 'Bland', 'Boutsioukis', 'Dalke', 'Dart', 'Diederich', 'Dragon De Monsyne', 'Edds', 'Felt', 'Frechet', 'Gertzfield', 'Gust', 'Heimes', 'J', 'Kippes', 'Larson', 'Lauder', 'Lemburg', 'Lingl', 'Lumholt', 'McGuire', 'Melotti', 'Montanaro', "O'Whielacronx", 'Peterson', 'Petrov', 'Polo', 'Reitz', 'Roberge', 'Sajip', 'Seo', 'Stinner', 'Stufft and individual contributors', 'Vawda', 'Warsaw', 'Winter', 'Wouters', 'Yee', 'van Rossum', 'von Loewis'}

class fake.BaseStorage(*args, **kwargs)

Bases: object

Base storage.

abstract abspath(filename: Any) → str

Return absolute path.

abstract exists(filename: Any) → bool

Check if file exists.

abstract generate_filename(extension: str, prefix: Optional[str] = None, basename: Optional[str] = None) → Any

Generate filename.

abstract relpath(filename: Any) → str

Return relative path.

abstract unlink(filename: Any) → None

Delete the file.

abstract write_bytes(filename: Any, data: bytes) → int

Write bytes.

abstract write_text(filename: Any, data: str, encoding: Optional[str] = None) → int

Write text.

class fake.CLI(faker: Optional[Faker] = None)

Bases: object

execute_command() → None

setup_parser() → ArgumentParser

class fake.DjangoModelFactory(**kwargs)

Bases: ModelFactory

Django ModelFactory.

classmethod create(**kwargs)

classmethod save(instance)

Save the instance.

class fake.DocxGenerator(faker: Faker)

Bases: object

DocxGenerator - generates a DOCX file with text.

Usage example:

from pathlib import Path
from fake import FAKER

Path("/tmp/example.docx").write_bytes(
    DocxGenerator(FAKER).create(nb_pages=100)
)

create(nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None) → bytes

class fake.Factory(faker: Optional[Faker] = None)

Bases: object

Factory.

property faker

class fake.FactoryMethod(method_name: str, faker: Optional[Faker] = None, **kwargs)

Bases: object

class fake.Faker(alias: Optional[str] = None)

Bases: object

fake.py - simplified, standalone alternative with no dependencies.

---

Usage example:

from fake import FAKER

print(FAKER.first_name())  # Random first name
print(FAKER.last_name())  # Random last name
print(FAKER.name())  # Random name
print(FAKER.word())  # Random word from the Zen of Python
print(FAKER.words(nb=3))  # List of 3 random words from Zen of Python
print(FAKER.sentence())  # Random sentence (5 random words by default)
print(FAKER.paragraph())  # Paragraph (5 random sentences by default)
print(FAKER.paragraphs())  # 3 random paragraphs
print(FAKER.text())  # Random text up to 200 characters
print(FAKER.file_name())  # Random filename with '.txt' extension
print(FAKER.email())  # Random email
print(FAKER.url())  # Random URL
print(FAKER.pyint())  # Random integer
print(FAKER.pybool())  # Random boolean
print(FAKER.pystr())  # Random string
print(FAKER.pyfloat())  # Random float

---

PDF:

from pathlib import Path
from fake import FAKER, TextPdfGenerator, GraphicPdfGenerator

Path("/tmp/graphic_pdf.pdf").write_bytes(
    FAKER.pdf(nb_pages=100, generator=GraphicPdfGenerator)
)

Path("/tmp/text_pdf.pdf").write_bytes(
    FAKER.pdf(nb_pages=100, generator=TextPdfGenerator)
)

---

Various image formats:

from pathlib import Path
from fake import FAKER

Path("/tmp/image.png").write_bytes(FAKER.png())

Path("/tmp/image.svg").write_bytes(FAKER.svg())

Path("/tmp/image.bmp").write_bytes(FAKER.bmp())

Path("/tmp/image.gif").write_bytes(FAKER.gif())

Note, that all image formats accept size (default: (100, 100)) and color`(default: `(255, 0, 0)) arguments.

bmp(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255)) → bytes

Create a BMP image of a specified size and color.

Parameters:

• size – Tuple of width and height of the image in pixels.

• color – Color of the image in RGB format (tuple of three integers).

Returns:

Byte content of the BMP image.

Return type:

bytes

bmp_file(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, extension: Optional[str] = None) → StringValue

Create a BMP image file of a specified size and color.

company_email(domain_names: Optional[Tuple[str, ...]] = None) → str

Generate a random company email.

country_code() → str

date(start_date: str = '-7d', end_date: str = '+0d', tzinfo: timezone = datetime.timezone.utc) → date

Generate random date between start_date and end_date.

Parameters:

• start_date – The start date from which the random date should be generated in the shorthand notation.

• end_date – The end date up to which the random date should be generated in the shorthand notation.

• tzinfo – The timezone.

Returns:

A string representing the formatted date.

Return type:

date

date_time(start_date: str = '-7d', end_date: str = '+0d', tzinfo: timezone = datetime.timezone.utc) → datetime

Generate a random datetime between start_date and end_date.

Parameters:

• start_date – The start datetime from which the random datetime should be generated in the shorthand notation.

• end_date – The end datetime up to which the random datetime should be generated in the shorthand notation.

• tzinfo – The timezone.

Returns:

A string representing the formatted datetime.

Return type:

datetime

docx(nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None) → bytes

Create a DOCX document.

docx_file(nb_pages: int = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None) → StringValue

Create a DOCX document file.

domain_name(tlds: Optional[Tuple[str, ...]] = None) → str

Generate a random domain name.

email(domain_names: Optional[Tuple[str, ...]] = None) → str

Generate a random email.

file_extension() → str

Generate a random extension.

file_name(extension: str = 'txt') → str

Generate a random filename.

first_name() → str

Generate a first name.

first_names(nb: int = 5) → List[str]

Generate a list of first names.

free_email(domain_names: Optional[Tuple[str, ...]] = None) → str

Generate a random free email.

free_email_domain() → str

Generate a random free email domain.

generic_file(content: Union[bytes, str], extension: str, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None) → StringValue

Create a generic file.

static get_by_alias(alias: str) → Optional[Faker]

static get_by_uid(uid: str) → Optional[Faker]

gif(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255)) → bytes

Create a GIF image of a specified size and color.

Parameters:

• size – Tuple of width and height of the image in pixels.

• color – Color of the image in RGB format (tuple of three integers).

Returns:

Byte content of the GIF image.

Return type:

bytes

gif_file(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, extension: Optional[str] = None) → StringValue

Create a GIF image file of a specified size and color.

iban(country_code: Optional[str] = None, bank_length: int = 8, account_length: int = 10) → str

Generate a random valid IBAN number.

image(image_format: Literal['png', 'svg', 'bmp', 'gif', 'tif', 'ppm'] = 'png', size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255)) → bytes

Create an image of a specified format, size and color.

image_url(width: int = 800, height: int = 600, service_url: Optional[str] = None) → str

Generate a random image URL.

ipv4() → str

Generate a random IP v4.

isbn10()

Generate a random valid ISBN-10.

isbn13() → str

Generate a random valid ISBN-13, starting with 978 or 979.

last_name() → str

Generate a last name.

last_names(nb: int = 5) → List[str]

Generate a list of last names.

load_names() → None

load_words() → None

locale() → str

mime_type() → str

Generate a random mime type.

name() → str

Generate a name.

names(nb: int = 5) → List[str]

Generate a list of names.

odt(nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None) → bytes

Create a ODT document.

odt_file(nb_pages: int = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None) → StringValue

Create a ODT document file.

paragraph(nb_sentences: int = 5) → str

Generate a paragraph.

paragraphs(nb: int = 3) → List[str]

Generate a list of paragraphs.

pdf(nb_pages: int = 1, generator: ~typing.Union[~typing.Type[~fake.TextPdfGenerator], ~typing.Type[~fake.GraphicPdfGenerator]] = <class 'fake.GraphicPdfGenerator'>, metadata: ~typing.Optional[~fake.MetaData] = None, **kwargs) → bytes

Create a PDF document of a given size.

pdf_file(nb_pages: int = 1, generator: ~typing.Union[~typing.Type[~fake.TextPdfGenerator], ~typing.Type[~fake.GraphicPdfGenerator]] = <class 'fake.GraphicPdfGenerator'>, metadata: ~typing.Optional[~fake.MetaData] = None, storage: ~typing.Optional[~fake.BaseStorage] = None, basename: ~typing.Optional[str] = None, prefix: ~typing.Optional[str] = None, **kwargs) → StringValue

Create a PDF file.

png(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255)) → bytes

Create a PNG image of a specified size and color.

Parameters:

• size – Tuple of width and height of the image in pixels.

• color – Color of the image in RGB format (tuple of three integers).

Returns:

Byte content of the PNG image.

Return type:

bytes

png_file(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, extension: Optional[str] = None) → StringValue

Create a PNG image file of a specified size and color.

ppm(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255)) → bytes

Create a PPM image of a specified size and color.

Parameters:

• size – Tuple of width and height of the image in pixels.

• color – Color of the image in RGB format, tuple of three integers: (0-255, 0-255, 0-255).

Returns:

Byte content of the PPM image.

Return type:

bytes

ppm_file(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, extension: Optional[str] = None) → StringValue

Create a PPM image file of a specified size and color.

pybool() → bool

Generate a random boolean.

pydecimal(left_digits: int = 5, right_digits: int = 2, positive: bool = True) → Decimal

Generate a random Decimal number.

Parameters:

• left_digits – Number of digits to the left of the decimal point.

• right_digits – Number of digits to the right of the decimal point.

• positive – If True, the number will be positive, otherwise it can be negative.

Returns:

A randomly generated Decimal number.

Return type:

Decimal

Raises:

ValueError

pyfloat(min_value: float = 0.0, max_value: float = 10.0) → float

Generate a random float number.

pyint(min_value: int = 0, max_value: int = 9999) → int

Generate a random integer.

pystr(nb_chars: int = 20) → str

Generate a random string.

random_choice(elements: Sequence[T]) → T

random_element(elements: Sequence[T]) → T

random_elements(elements: Sequence[T], length: int) → List[T]

random_sample(elements: Sequence[T], length: int) → List[T]

sentence(nb_words: int = 5) → str

Generate a sentence.

sentences(nb: int = 3) → List[str]

Generate a list of sentences.

slug() → str

Generate a slug.

slugs(nb: int = 5) → List[str]

Generate a list of slugs.

svg(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255)) → bytes

Create an SVG image of a specified size and color.

Parameters:

• size – Tuple of width and height of the image in pixels.

• color – Color of the image in RGB format (tuple of three integers).

Returns:

Byte content of the SVG image.

Return type:

bytes

svg_file(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, extension: Optional[str] = None) → StringValue

Create an SVG image file of a specified size and color.

text(nb_chars: int = 200) → str

Generate a text.

text_pdf(nb_pages: int = 1, generator: ~typing.Type[~fake.TextPdfGenerator] = <class 'fake.TextPdfGenerator'>, metadata: ~typing.Optional[~fake.MetaData] = None, **kwargs) → bytes

Create a PDF document of a given size.

text_pdf_file(nb_pages: int = 1, generator: ~typing.Type[~fake.TextPdfGenerator] = <class 'fake.TextPdfGenerator'>, metadata: ~typing.Optional[~fake.MetaData] = None, storage: ~typing.Optional[~fake.BaseStorage] = None, basename: ~typing.Optional[str] = None, prefix: ~typing.Optional[str] = None, **kwargs) → StringValue

Create a text PDF file.

texts(nb: int = 3) → List[str]

Generate a list of texts.

tif(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255)) → bytes

Create a TIF image of a specified size and color.

Parameters:

• size – Tuple of width and height of the image in pixels.

• color – Color of the image in RGB format (tuple of three integers).

Returns:

Byte content of the TIF image.

Return type:

bytes

tif_file(size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, extension: Optional[str] = None) → StringValue

Create a TIF image file of a specified size and color.

tld(tlds: Optional[Tuple[str, ...]] = None) → str

Generate a random TLD.

txt_file(nb_chars: Optional[int] = 200, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, text: Optional[str] = None) → StringValue

Create a text document file.

url(protocols: Optional[Tuple[str, ...]] = None, tlds: Optional[Tuple[str, ...]] = None, suffixes: Optional[Tuple[str, ...]] = None) → str

Generate a random URL.

username() → str

Generate a username.

usernames(nb: int = 5) → List[str]

Generate a list of usernames.

uuid() → UUID

Generate a UUID.

uuids(nb: int = 5) → List[UUID]

Generate a list of UUIDs.

word() → str

Generate a word.

words(nb: int = 5) → List[str]

Generate a list of words.

class fake.FileRegistry

Bases: object

Stores list StringValue instances.

from fake import FAKER, FILE_REGISTRY

txt_file_1 = FAKER.txt_file()
txt_file_2 = FAKER.txt_file()
...
txt_file_n = FAKER.txt_file()

# The FileRegistry._registry would then contain this:
{
    txt_file_1,
    txt_file_2,
    ...,
    txt_file_n,
}

# Clean up created files as follows:
FILE_REGISTRY.clean_up()

add(string_value: StringValue) → None

clean_up() → None

remove(string_value: Union[StringValue, str]) → bool

search(value: str) → Optional[StringValue]

class fake.FileSystemStorage(root_path: Optional[Union[str, Path]] = '/tmp', rel_path: Optional[str] = 'tmp', *args, **kwargs)

Bases: BaseStorage

File storage class using pathlib for path handling.

Usage example:

from fake import FAKER, FileSystemStorage

storage = FileSystemStorage()
docx_file = storage.generate_filename(prefix="zzz_", extension="docx")
storage.write_bytes(docx_file, FAKER.docx())

Initialization with params:

from fake import FAKER, FileSystemStorage

storage = FileSystemStorage()
docx_file = FAKER.docx_file(storage=storage)

abspath(filename: str) → str

Return absolute path.

exists(filename: str) → bool

Check if file exists.

generate_filename(extension: str, prefix: Optional[str] = None, basename: Optional[str] = None) → str

Generate filename.

relpath(filename: str) → str

Return relative path.

unlink(filename: str) → None

Delete the file.

write_bytes(filename: str, data: bytes) → int

Write bytes.

write_text(filename: str, data: str, encoding: Optional[str] = None) → int

Write text.

class fake.GraphicPdfGenerator(faker: Faker)

Bases: object

Graphic PDF generatr.

Usage example:

from pathlib import Path
from fake import FAKER, GraphicPdfGenerator

Path("/tmp/graphic_example.pdf").write_bytes(
    FAKER.pdf(nb_pages=100, generator=GraphicPdfGenerator)
)

create(nb_pages: int = 1, image_size: Tuple[int, int] = (100, 100), image_color: Tuple[int, int, int] = (255, 0, 0), **kwargs) → bytes

image_color: Tuple[int, int, int]

image_size: Tuple[int, int]

nb_pages: int

class fake.LazyAttribute(func)

Bases: object

class fake.LazyFunction(func)

Bases: object

class fake.MetaData

Bases: object

add_content(content: Union[str, List[str]]) → None

content: Optional[str]

class fake.ModelFactory(**kwargs)

Bases: object

ModelFactory.

class Meta

Bases: object

get_or_create = ('id',)

classmethod create(**kwargs)

classmethod create_batch(count, **kwargs)

classmethod save(instance)

Save the instance.

class fake.OdtGenerator(faker: Faker)

Bases: object

OdtGenerator - generates an ODT file with text.

Usage example:

from pathlib import Path
from fake import FAKER

Path("/tmp/example.odt").write_bytes(
    OdtGenerator(FAKER).create(nb_pages=100)
)

create(nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None) → bytes

class fake.PostSave(func, *args, **kwargs)

Bases: object

execute(instance)

class fake.PreInit(func, *args, **kwargs)

Bases: object

execute(data: Dict[str, Any]) → None

class fake.PreSave(func, *args, **kwargs)

Bases: object

execute(instance)

class fake.PydanticModelFactory(**kwargs)

Bases: ModelFactory

Pydantic ModelFactory.

class fake.SQLAlchemyModelFactory(**kwargs)

Bases: ModelFactory

SQLAlchemy ModelFactory.

classmethod create(**kwargs)

classmethod save(instance)

Save the instance.

class fake.StringValue(value, *args, **kwargs)

Bases: str

data: Dict[str, Any]

class fake.SubFactory(factory_class, **kwargs)

Bases: object

class fake.TextPdfGenerator(faker: Faker)

Bases: object

Text PDF generatr.

Usage example:

from pathlib import Path
from fake import FAKER, TextPdfGenerator

Path("/tmp/text_example.pdf").write_bytes(
    FAKER.pdf(nb_pages=100, generator=TextPdfGenerator)
)

create(nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, **kwargs) → bytes

nb_pages: int

texts: List[str]

class fake.TortoiseModelFactory(**kwargs)

Bases: ModelFactory

Tortoise ModelFactory.

classmethod create(**kwargs)

classmethod save(instance)

Save the instance.

fake.fill_dataclass(dataclass_type: Type) → Any

Fill dataclass with data.

fake.fill_pydantic_model(object_type: Type) → Any

fake.format_type_hint(type_hint) → str

Format the type hint for display.

fake.get_argparse_type(param_type) → Any

Get the corresponding argparse type for a given parameter type.

fake.get_provider_args(func: Callable) → Dict[str, Any]

Retrieve the argument list and types for a provider function by inspecting its signature.

fake.get_provider_defaults(func: Callable) → Dict[str, Any]

Retrieve the argument list and defaults for a provider function by inspecting its signature.

fake.is_optional_type(type_hint) → bool

Check if the type hint is an Optional.

fake.main() → None

fake.organize_providers(provider_tags) → Dict[str, Any]

Organize providers by category for easier navigation.

fake.post_save(func)

fake.pre_init(func)

fake.pre_save(func)

fake.provider(*args: Any, tags: Optional[Tuple[str, ...]] = None) → Callable

fake.run_async_in_thread(coroutine: Coroutine) → Awaitable

Run an asynchronous coroutine in a separate thread.

Parameters:

coroutine – An asyncio coroutine to be run.

Returns:

The result of the coroutine.

Return type:

Awaitable

fake.slugify(value: str) → str

Slugify.

fake.trait(func)

fake.xor_transform(val: str, key: int = 10) → str

Simple, deterministic string encoder/decoder.

Usage example:

val = "abcd"
encoded_val = xor_transform(val)
decoded_val = xor_transform(encoded_val)