fake-py 0.13

pip

pip install fake.py

Download and copy

fake.py is the sole, self-contained module of the package. It includes tests too. If it’s more convenient to you, you could simply download the fake.py module and include it in your repository.

Since tests are included, it won’t have a negative impact on your test coverage (you might need to apply test/coverage configuration tweaks).

Generate data

from fake import FAKER

FAKER.first_name()  # str
FAKER.first_names()  # list[str]
FAKER.last_name()  # str
FAKER.last_names()  # list[str]
FAKER.name()  # str
FAKER.names()  # list[str]
FAKER.username()  # str
FAKER.usernames()  # list[str]

from fake import FAKER

FAKER.password()  # str
FAKER.paragraph()  # str
FAKER.paragraphs()  # list[str]
FAKER.sentence()  # str
FAKER.sentences()  # list[str]
FAKER.slug()  # str
FAKER.slugs()  # list[str]
FAKER.text()  # str
FAKER.texts()  # list[str]
FAKER.word()  # str
FAKER.words()  # list[str]

from fake import FAKER

FAKER.company_email()  # str
FAKER.company_emails()  # list[str]
FAKER.domain_name()  # str
FAKER.email()  # str
FAKER.emails()  # list[str]
FAKER.free_email()  # str
FAKER.free_emails()  # list[str]
FAKER.free_email_domain()  # str
FAKER.image_url()  # str
FAKER.ipv4()  # str
FAKER.tld()  # str
FAKER.url()  # str

from fake import FAKER

FAKER.dir_path()  # str
FAKER.file_extension()  # str
FAKER.file_name()  # str
FAKER.file_path()  # str
FAKER.mime_type()  # str

from fake import FAKER

FAKER.pybool()  # bool
FAKER.pyfloat()  # float
FAKER.pyint()  # int
FAKER.pystr()  # str
FAKER.uuid()  # uuid.UUID

from fake import FAKER

FAKER.date()  # datetime.date
FAKER.date_time()  # datetime.datetime
FAKER.year()  # int
FAKER.time()  # str

from fake import FAKER

FAKER.city()  # str
FAKER.country()  # str
FAKER.geo_location()  # str
FAKER.country_code()  # str
FAKER.locale()  # str
FAKER.latitude()  # float
FAKER.longitude()  # float
FAKER.latitude_longitude()  # tuple[float, float]

from fake import FAKER

FAKER.isbn10()  # str
FAKER.isbn13()  # str

from fake import FAKER

FAKER.iban()  # str

Generate files

from fake import FAKER

FAKER.bmp()  # bytes
FAKER.docx()  # bytes
FAKER.eml()  # bytes
FAKER.epub()  # bytes
FAKER.gif()  # bytes
FAKER.jpg()  # bytes
FAKER.odt()  # bytes
FAKER.pdf()  # bytes
FAKER.png()  # bytes
FAKER.ppm()  # bytes
FAKER.rtf()  # bytes
FAKER.svg()  # bytes
FAKER.tar()  # bytes
FAKER.tif()  # bytes
FAKER.wav()  # bytes
FAKER.zip()  # bytes

from fake import FAKER

FAKER.bmp_file()  # str
FAKER.docx_file()  # str
FAKER.eml_file()  # str
FAKER.epub_file()  # str
FAKER.gif_file()  # str
FAKER.jpg_file()  # str
FAKER.odt_file()  # str
FAKER.pdf_file()  # str
FAKER.png_file()  # str
FAKER.ppm_file()  # str
FAKER.rtf_file()  # str
FAKER.svg_file()  # str
FAKER.tar_file()  # str
FAKER.tif_file()  # str
FAKER.txt_file()  # str
FAKER.wav_file()  # str
FAKER.zip_file()  # str

Factories/dynamic fixtures

This is how you could define factories for Django’s built-in Group and User models.

Filename: factories.py

from django.contrib.auth.models import Group, User
from fake import (
    DjangoModelFactory,
    FACTORY,
    PostSave,
    PreSave,
    trait,
)


class GroupFactory(DjangoModelFactory):
    """Group factory."""

    name = FACTORY.word()

    class Meta:
        model = Group
        get_or_create = ("name",)


def set_password(user: User, password: str) -> None:
    """Helper function for setting password for the User."""
    user.set_password(password)


def add_to_group(user: User, name: str) -> None:
    """Helper function for adding the User to a Group."""
    group = GroupFactory(name=name)
    user.groups.add(group)


class UserFactory(DjangoModelFactory):
    """User factory."""

    username = FACTORY.username()
    first_name = FACTORY.first_name()
    last_name = FACTORY.last_name()
    email = FACTORY.email()
    date_joined = FACTORY.date_time()
    last_login = FACTORY.date_time()
    is_superuser = False
    is_staff = False
    is_active = FACTORY.pybool()
    password = PreSave(set_password, password="test1234")
    group = PostSave(add_to_group, name="Test group")

    class Meta:
        model = User
        get_or_create = ("username",)

    @trait
    def is_admin_user(self, instance: User) -> None:
        """Trait."""
        instance.is_superuser = True
        instance.is_staff = True
        instance.is_active = True

And this is how you could use it:

# Create just one user
user = UserFactory()

# Create 5 users
users = UserFactory.create_batch(5)

# Create a user using `is_admin_user` trait
user = UserFactory(is_admin_user=True)

# Create a user with custom password
user = UserFactory(
    password=PreSave(set_password, password="another-password"),
)

# Add a user to another group
user = UserFactory(
    group=PostSave(add_to_group, name="Another group"),
)

# Or even add user to multiple groups at once
user = UserFactory(
    group_1=PostSave(add_to_group, name="Another group"),
    group_2=PostSave(add_to_group, name="Yet another group"),
)

Customise

Make your own custom providers and utilize factories with them.

Filename: custom_fake.py

import random
import string

from fake import Faker, Factory, provider


class CustomFaker(Faker):

    @provider
    def postal_code(self) -> str:
        number_part = "".join(random.choices(string.digits, k=4))
        letter_part = "".join(random.choices(string.ascii_uppercase, k=2))
        return f"{number_part} {letter_part}"


FAKER = CustomFaker()
FACTORY = Factory(FAKER)

Now you can use it as follows (make sure to import your custom instances of FAKER and FACTORY):

from custom_fake import FAKER  # Custom `FAKER` instance

FAKER.postal_code()

Or as follows:

from fake import ModelFactory

from custom_fake import FACTORY  # Custom `FACTORY` instance


class AddressFactory(ModelFactory):

    # ... other definitions
    postal_code = FACTORY.postal_code()
    # ... other definitions

    class Meta:
        model = Address

Section headings

Keep the following hierarchy.

=====
title
=====

header
======

sub-header
----------

sub-sub-header
~~~~~~~~~~~~~~

sub-sub-sub-header
^^^^^^^^^^^^^^^^^^

sub-sub-sub-sub-header
++++++++++++++++++++++

sub-sub-sub-sub-sub-header
**************************

Quality

Documentation is built using Sphinx and enhanced with the following specialised tools to ensure a clean, interactive, and fully tested developer experience:

• jsphinx: Provides interactive UI components, including expandable and collapsible code snippets, allowing for detailed examples without cluttering the page.

• sphinx-no-pragma: A focused extension that strips pragma comments (like # noqa or # type: ignore) from the generated documentation, keeping the focus entirely on the logic.

• pytest-codeblock: For testing the documentation code snippets (e.g. README.rst, AGENTS.md) .rst and .md files, ensuring that every example remains functional as the codebase evolves.