pax_global_header00006660000000000000000000000064151056613720014520gustar00rootroot0000000000000052 comment=595b36686377abc88eeabad01181c225efc72429 fake.py-0.11.9/000077500000000000000000000000001510566137200131455ustar00rootroot00000000000000fake.py-0.11.9/.coveralls.yml000066400000000000000000000000351510566137200157360ustar00rootroot00000000000000service_name: github-actions fake.py-0.11.9/.env000066400000000000000000000000421510566137200137320ustar00rootroot00000000000000GITHUB_TOKEN COVERALLS_REPO_TOKEN fake.py-0.11.9/.github/000077500000000000000000000000001510566137200145055ustar00rootroot00000000000000fake.py-0.11.9/.github/workflows/000077500000000000000000000000001510566137200165425ustar00rootroot00000000000000fake.py-0.11.9/.github/workflows/gh-pages.yml000066400000000000000000000014441510566137200207630ustar00rootroot00000000000000name: Deploy llms.txt permissions: contents: write # Required to push commits pages: write # If you’re deploying to GitHub Pages on: push: branches: [ dev ] jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Set up Python uses: actions/setup-python@v5 with: { python-version: '3.12' } - name: Install docs deps run: pip install -r docs/requirements.txt - name: Build llms.txt run: sphinx-build -n -D master_doc=llms -b text docs build/text llms.rst - name: Publish uses: peaceiris/actions-gh-pages@v4 with: github_token: ${{ secrets.GITHUB_TOKEN }} publish_branch: gh-pages publish_dir: build/text allow_empty_commit: true fake.py-0.11.9/.github/workflows/test.yml000066400000000000000000000326411510566137200202520ustar00rootroot00000000000000name: test on: push: pull_request: types: [review_requested, ready_for_review] workflow_dispatch: jobs: # ************************************* # ************* Pre-commit ************ # ************************************* pre-commit: name: pre-commit ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: true max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.11" # - "3.10" # - "3.9" # - "3.8" steps: - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install detect-secrets run: pip install --no-cache-dir detect-secrets doc8 - name: Run pre-commit uses: pre-commit/action@v3.0.1 # ************************************* # **************** Tests ************** # ************************************* test: needs: pre-commit name: test ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 # - Windows # - MacOs python-version: - "3.14.0-alpha.5" - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" # - "3.8" env: PYO3_USE_ABI3_FORWARD_COMPATIBILITY: "1" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip - name: Install package run: | pip install -e .[all] - name: Run test suite run: pytest -vrx env: PYTEST_ADDOPTS: "-vv --durations=10" - name: Coveralls id: coveralls-setup continue-on-error: true uses: AndreMiras/coveralls-python-action@develop with: parallel: true flag-name: Run Tests # ************************************* # ******** Customisation example ****** # ************************************* test_customisation_example: needs: pre-commit name: test customisation example ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/customisation/ && pytest # ************************************* # ******** Dataclasses example ******** # ************************************* test_dataclasses_example: needs: pre-commit name: test dataclasse example ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/dataclasses/ && pytest # ************************************* # ************ Django example ********* # ************************************* test_django_example: needs: pre-commit name: test django example ${{ matrix.django-version }} - ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" django-version: [ "5.2", "5.1", "5.0", "4.2" ] exclude: - python-version: "3.9" django-version: "5.0" # Exclude Python 3.9 with Django 5.0 - python-version: "3.9" django-version: "5.1" # Exclude Python 3.9 with Django 5.1 - python-version: "3.9" django-version: "5.2" # Exclude Python 3.9 with Django 5.2 steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip pip install django==${{ matrix.django-version }} pip install -r examples/django/requirements.in - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/django/ && pytest # ************************************* # ********** Hypothesis example ******* # ************************************* test_hypothesis_example: needs: pre-commit name: test hypothesis example ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip pip install -r examples/hypothesis/requirements.in - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/hypothesis/ && pytest # ************************************* # *********** Pydantic example ******** # ************************************* test_pydantic_example: needs: pre-commit name: test pydantic example ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip pip install -r examples/pydantic/requirements.in - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/pydantic/ && pytest # ************************************* # *********** SQLAlchemy example ******** # ************************************* test_sqlalchemy_example: needs: pre-commit name: test sqlalchemy example ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip pip install -r examples/sqlalchemy/requirements.in - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/sqlalchemy/ && pytest # ************************************* # *********** SQLModel example ******** # ************************************* test_sqlmodel_example: needs: pre-commit name: test sqlmodel example ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip pip install -r examples/sqlmodel/requirements.in - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/sqlmodel/ && pytest # ************************************* # ********* TortoiseORM example ******* # ************************************* test_tortoise_example: needs: pre-commit name: test tortoise example ${{ matrix.python-version }} - ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: fail-fast: false max-parallel: 5 matrix: os: - ubuntu-22.04 python-version: - "3.13" - "3.12" - "3.11" - "3.10" - "3.9" steps: - name: Clean-up run: sudo apt clean && sudo apt autoclean && sudo rm -rf /tmp/* && sudo rm -rf /usr/share/dotnet && sudo rm -rf /opt/ghc && sudo rm -rf "/usr/local/share/boost" && sudo rm -rf "$AGENT_TOOLSDIRECTORY" - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Install Dependencies run: | python -m pip install --upgrade pip pip install -r examples/tortoise/requirements.in - name: Install package run: | pip install -e .[all] - name: Run test suite run: cd examples/tortoise/ && pytest # ************************************* # ************** Coveralls ************ # ************************************* coveralls_finish: name: coveralls_finish needs: test runs-on: ubuntu-latest steps: - name: Install dependencies run: | python -m pip install pyyaml - name: Coveralls Finished id: coveralls-finish continue-on-error: true # if: steps.coveralls-setup.outcome == 'success' env: COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }} GITHUB_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }} uses: AndreMiras/coveralls-python-action@develop with: parallel-finished: true debug: true fake.py-0.11.9/.gitignore000077500000000000000000000012271510566137200151420ustar00rootroot00000000000000*.py[cod] .hgignore~ .gitignore~ .hg/ .hgtags .tox/ .cache/ .coverage* !.coveragerc /htmlcov/ *.py,cover .idea/ .vscode/ .pytest_cache/ /coverage.xml .eggs/ MANIFEST.in~ codebin/ /tmp/ .zip /examples/db/ /var/ /examples/tmp/ /examples/logs/ /builddocs/ /docs/_build/ /builddocs.zip /build/ /dist/ fake.py.egg-info matyan.log* db.sqlite3 sample_db.sqlite test_database.db local_settings.py /prof/ *.cast .ipynb_checkpoints/ .scannerwork/ *db.sqlite3* examples/pydantic/media/ examples/tortoise/media/ examples/django/media/ examples/dataclasses/media/ examples/sqlalchemy/media/ examples/sqlmodel/media/ examples/hypothesis/.hypothesis/ .mypy_cache/ benchmark.py fake.py-0.11.9/.pre-commit-config.yaml000066400000000000000000000027661510566137200174410ustar00rootroot00000000000000exclude: "^docs/|/migrations/" default_stages: [ pre-commit, pre-push ] default_language_version: python: python3 repos: - repo: https://github.com/PyCQA/doc8 rev: v1.1.2 hooks: - id: doc8 args: [] - repo: https://github.com/Yelp/detect-secrets rev: v1.5.0 hooks: - id: detect-secrets args: ['--baseline', '.secrets.baseline'] - repo: https://github.com/pre-commit/pre-commit-hooks rev: v5.0.0 hooks: - id: trailing-whitespace exclude: "data/" - id: end-of-file-fixer - id: check-yaml - id: check-toml - id: check-added-large-files - id: debug-statements - id: check-merge-conflict # - repo: https://github.com/psf/black # rev: 24.4.2 # hooks: # - id: black # name: black # files: . # args: [ "--config", "pyproject.toml" ] # - repo: https://github.com/pycqa/isort # rev: 5.13.2 # hooks: # - id: isort # name: isort # files: . # args: [ "--settings-path", "pyproject.toml", "--profile=black" ] - repo: https://github.com/charliermarsh/ruff-pre-commit rev: v0.11.0 hooks: - id: ruff name: lint files: . args: [ "--config", "pyproject.toml", "--fix" ] # - id: ruff-format - repo: https://github.com/jsh9/pydoclint rev: 0.4.2 hooks: - id: pydoclint # - repo: https://github.com/asottile/pyupgrade # rev: v3.2.0 # hooks: # - id: pyupgrade # args: [ --py310-plus ] fake.py-0.11.9/.readthedocs.yaml000066400000000000000000000024601510566137200163760ustar00rootroot00000000000000# Read the Docs configuration file for Sphinx projects # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details # Required version: 2 # Optionally build your docs in additional formats such as PDF and ePub formats: - pdf - epub - htmlzip # Build documentation in the "docs/" directory with Sphinx sphinx: configuration: docs/conf.py # You can configure Sphinx to use a different builder, for instance use the dirhtml builder for simpler URLs # builder: "dirhtml" # Fail on all warnings to avoid broken references # fail_on_warning: true # Optional but recommended, declare the Python requirements required # to build your documentation # See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html python: install: - requirements: docs/requirements.txt # Set the OS, Python version and other tools you might need build: os: ubuntu-22.04 tools: python: "3.12" # You can also specify other tool versions: # nodejs: "20" # rust: "1.70" # golang: "1.20" jobs: build: # The default commands for generating the HTML and pdf formats will still run. htmlzip: - echo "Override default build command for htmlzip format" - mkdir -p $READTHEDOCS_OUTPUT/html/ - sphinx-build -n -b text docs $READTHEDOCS_OUTPUT/html/ fake.py-0.11.9/.secrets.baseline000066400000000000000000000050341510566137200164010ustar00rootroot00000000000000{ "version": "1.5.0", "plugins_used": [ { "name": "ArtifactoryDetector" }, { "name": "AWSKeyDetector" }, { "name": "AzureStorageKeyDetector" }, { "name": "Base64HighEntropyString", "limit": 4.5 }, { "name": "BasicAuthDetector" }, { "name": "CloudantDetector" }, { "name": "DiscordBotTokenDetector" }, { "name": "GitHubTokenDetector" }, { "name": "HexHighEntropyString", "limit": 3.0 }, { "name": "IbmCloudIamDetector" }, { "name": "IbmCosHmacDetector" }, { "name": "JwtTokenDetector" }, { "name": "KeywordDetector", "keyword_exclude": "" }, { "name": "MailchimpDetector" }, { "name": "NpmDetector" }, { "name": "PrivateKeyDetector" }, { "name": "SendGridDetector" }, { "name": "SlackDetector" }, { "name": "SoftlayerDetector" }, { "name": "SquareOAuthDetector" }, { "name": "StripeDetector" }, { "name": "TwilioKeyDetector" } ], "filters_used": [ { "path": "detect_secrets.filters.allowlist.is_line_allowlisted" }, { "path": "detect_secrets.filters.common.is_baseline_file", "filename": ".secrets.baseline" }, { "path": "detect_secrets.filters.common.is_ignored_due_to_verification_policies", "min_level": 2 }, { "path": "detect_secrets.filters.heuristic.is_indirect_reference" }, { "path": "detect_secrets.filters.heuristic.is_likely_id_string" }, { "path": "detect_secrets.filters.heuristic.is_lock_file" }, { "path": "detect_secrets.filters.heuristic.is_not_alphanumeric_string" }, { "path": "detect_secrets.filters.heuristic.is_potential_uuid" }, { "path": "detect_secrets.filters.heuristic.is_prefixed_with_dollar_sign" }, { "path": "detect_secrets.filters.heuristic.is_sequential_string" }, { "path": "detect_secrets.filters.heuristic.is_swagger_file" }, { "path": "detect_secrets.filters.heuristic.is_templated_secret" } ], "results": { "examples/django/article/tests.py": [ { "type": "Secret Keyword", "filename": "examples/django/article/tests.py", "hashed_secret": "9bc34549d565d9505b287de0cd20ac77be1d3f2c", "is_verified": true, "line_number": 96 } ] }, "generated_at": "2024-05-06T22:16:59Z" } fake.py-0.11.9/CHANGELOG.rst000066400000000000000000000215241510566137200151720ustar00rootroot00000000000000Release history and notes ========================= .. External references .. _pytest-codeblock: https://github.com/barseghyanartur/pytest-codeblock/ `Sequence based identifiers `_ are used for versioning (schema follows below): .. code-block:: text major.minor[.revision] - It is always safe to upgrade within the same minor version (for example, from 0.3 to 0.3.4). - Minor version changes might be backwards incompatible. Read the release notes carefully before upgrading (for example, when upgrading from 0.3.4 to 0.4). - All backwards incompatible changes are mentioned in this document. 0.11.9 ------ 2025-11-14 .. note:: Release is dedicated to my beloved daughter Ani. Get well soon my dear! - Add doc-strings to some of the not well documented methods. 0.11.8 ------ 2025-06-01 .. note:: Release is dedicated to my beloved son Raffi. Get well soon my dear! - Narrow down the PyPI package size by introducing MANIFEST.in. 0.11.7 ------ 2025-05-31 - Minor documentation improvements. 0.11.6 ------ 2025-05-10 - Correct guessing of mimetypes in ``eml`` and ``eml_file`` providers. - Add ``cte_type`` and ``policy`` arguments to ``eml`` and ``eml_file`` providers. 0.11.5 ------ 2025-05-07 - Fully delegate documentation testing to `pytest-codeblock`_. - Add additional tags to binary providers, such as images or documents. 0.11.4 ------ 2025-05-03 - Add ``rtf`` and ``epub`` providers. 0.11.3 ------ 2025-04-22 - Add ``time`` provider. 0.11.2 ------ 2025-04-21 - Add ``string_template`` and ``lazy_string_template`` providers. 0.11.1 ------ 2025-04-11 - Add ``year`` provider. - Add cheat sheet docs. 0.11 ---- 2025-03-24 - Optimise ``file_name`` provider. Add ``prefix`` argument. - Add ``file_path`` and ``dir_path`` providers. 0.10.5 ------ 2024-11-23 - Add benchmarks section to the main README. - Improve docs. Add a dedicated section on files creation. - Test against Django 5.1. - Clean-up. 0.10.4 ------ 2024-10-17 - Add a ``separator`` argument to the ``slugify`` function. - Minor documentation improvements. 0.10.3 ------ 2024-10-16 - Add `JPG` file support through ``jpg`` and ``jpg_file`` providers. 0.10.2 ------ 2024-10-07 - Test against Python 3.13 and 3.14. - Upgrade GitHub Actions. 0.10.1 ------ 2024-10-05 - Added ``password`` provider. 0.10 ---- 2024-09-27 - For both ``StringTemplate`` and ``LazyStringTemplate`` the ``faker`` argument had become optional and positionally moved from first to the last place. - Improve string templates. - Minor documentation improvements. 0.9.9 ----- 2024-09-27 - Improve string templates. - Minor documentation improvements. 0.9.8 ----- 2024-09-26 - Implement string templates. - Minor documentation improvements. 0.9.7 ----- 2024-09-17 - Minor (documentation) fixes. 0.9.6 ----- 2024-09-16 - Add `ZIP` file support through ``zip`` and ``zip_file`` providers. - Add `TAR` file support through ``tar`` and ``tar_file`` providers. - Add `EML` file support through ``eml`` and ``eml_file`` providers. - Add inner file functions for creating archive files with unlimited depth. 0.9.5 ----- 2024-09-11 - Minor optimisations. 0.9.4 ----- 2024-08-18 - Add `WAV` audio file support through ``wav`` and ``wav_file`` providers. 0.9.3 ----- 2024-08-09 - Prepare for namespaced packages. ``fakepy`` is now an additional registered namespace, next to ``fake``. All integration packages can make use of the ``fakepy`` namespace. For instance: .. code-block:: python from fake import FAKER from fakepy.pathy_storage.aws_s3 import AWSS3Storage STORAGE = AWSS3Storage( bucket_name="bucket_name", root_path="tmp", # Optional rel_path="sub-tmp", # Optional ) txt_file = FAKER.txt_file(storage=STORAGE) STORAGE.exists(txt_file) 0.9.2 ----- 2024-08-05 - Implement ``randomise_string`` provider, that replaces placeholders in a given string with random letters and digits. Placeholders ``?`` are replaced by random uppercase letters, and placeholders ``#`` are replaced by random digits. 0.9.1 ----- 2024-08-04 - Minor fixes. 0.9 --- 2024-08-03 - Drop support for EOL Python 3.7 and almost EOL 3.8. - Add country support through ``country`` provider. - Add city support through ``city`` provider. - Add geo-location support through ``geo_location`` provider. - Add latitude/longitude support through ``latitude``, ``longitude`` and ``latitude_longitude`` providers. 0.8.4 ----- 2024-08-01 - Added ISBN support through ``isbn10`` and ``isbn13`` providers. - Added country code support through ``country_code`` provider. - Added locale support through ``locale`` provider. - Added IBAN support through ``iban`` provider. 0.8.3 ----- 2024-07-27 - Added ``mime_type`` provider. 0.8.2 ----- 2024-07-27 - Added ``file_extension`` provider. 0.8.1 ----- 2024-07-24 - Added `ODT` file support through ``odt`` and ``odt_file`` providers. 0.8 --- 2024-07-24 - The ``extension`` argument is renamed to ``image_format`` argument for ``png_file``, ``svg_file``, ``bmp_file`` and ``gif_file`` providers. The ``extension`` argument serves now solely a purpose of providing the actual file extension and it's optional (``None`` by default). If not given, the ``image_format`` value is used for file extension instead. - Minor fixes in generation of image files. - Added `TIF` support through ``tif`` and ``tif_file`` providers. 0.7.5 ----- 2024-07-04 - Improve text `PDF` generation according to 1.4 (most common) spec instead of 1.0. 0.7.4 ----- 2024-06-28 - Add CLI. 0.7.3 ----- 2024-06-21 .. note:: Release dedicated to my dear son Tigran, who turned 12 today. - Add ``text_pdf`` and ``text_pdf_file`` providers, which are shortcuts for ``pdf`` and ``pdf_file`` with ``generator`` set to ``TextPdfGenerator``. - Allow to optionally tag providers. - Tag all implemented providers. 0.7.2 ----- 2024-06-17 - Add basic ``slugify`` function. - Minor fixes in ``free_email`` and ``company_email`` providers. 0.7.1 ----- 2024-06-11 - Test against `SQLModel`. Also included SQLModel examples. - Improve docs. 0.7 --- 2024-06-09 .. note:: This release contains minor backwards incompatible changes. Namely, in the ``email`` provider. - The ``domain`` (type: ``str``, default value: ``example.com``) argument of the ``email`` provider has been dropped in favour of ``domain_names`` (type: ``Optional[Tuple[str]``, default value: ``None``). - Added a dedicated ``PydanticModelFactory`` (yet equal to ``ModelFactory``) for future improvements. - Added ``PreInit`` factory class and ``pre_init`` decorator. - Improved documentation of factories. - Added ``random_choice`` and ``random_sample`` providers. - Added ``tld``, ``domain_name``, ``free_email_domain``, ``company_email`` and ``free_email`` providers. 0.6.9 ----- 2024-05-10 - Minor fixes in ``pdf_file`` and ``docx_file`` providers. - Minor fixes in docs. 0.6.8 ----- 2024-05-06 - Minor fixes in docs. 0.6.7 ----- 2024-01-17 - Add ``uuids``, ``first_names``, ``last_names``, ``names``, ``usernames`` and ``slugs`` plural providers (return ``List``). 0.6.6 ----- 2024-01-15 - Add ``image_url`` provider. 0.6.5 ----- 2023-12-18 - Improve docs. - MyPy fixes. 0.6.4 ----- 2023-12-16 - Add ``PreSave`` and ``PostSave``. 0.6.3 ----- 2023-12-13 - Add ``LazyAttribute`` and ``LazyFunction``. - Improve package portability (tests). - Improve tests. 0.6.2 ----- 2023-12-11 - Add ``SQLAlchemyModelFactory``. 0.6.1 ----- 2023-12-10 - Allow to load registered ``Faker`` instance by ``uid`` or ``alias``. - Improve test coverage. 0.6 --- 2023-12-09 - Add optional argument ``alias`` to the ``Faker`` class. - Improve multiple ``Faker`` instances. - Add ``generic_file`` provider. 0.5 --- 2023-12-08 - Make ``fake.Faker`` and ``fake.Factory`` classes more customisable. - Introduce ``provider`` decorator to decorate provider methods. - Documentation improvements. 0.4.1 ----- 2023-12-07 - Added ``pydecimal``. - Make ``date_time`` timezone aware. - Added documentation on how to customise. 0.4 --- 2023-12-06 - Streamline on how to use traits, pre- and post-save hooks. 0.3.1 ----- 2023-12-04 - Improve `Tortoise ORM` factory. - Add traits. - Improve documentation. 0.3 --- 2023-12-03 - Added factories. - Added mechanism to clean-up (remove) the created test files. - Improved documentation. 0.2 --- 2023-12-01 - Add factories. - Improve docs. - Add ``uuid``, ``slug`` and ``username`` generators. - Change ``date_between`` to ``date``. - Change ``date_time_between`` to ``date_time``. 0.1.3 ----- 2023-11-28 - Added ``pdf_file``, ``docx_file``, ``png_file``, ``svg_file``, ``bmp_file``, ``gif_file`` support. - Added storages. 0.1.2 ----- 2023-11-26 - Adding ``texts`` support. - Improve tests and documentation. 0.1.1 ----- 2023-11-26 - Adding `DOCX` support. - Fixes in documentation. 0.1 --- 2023-11-25 - Initial beta release. fake.py-0.11.9/CODE_OF_CONDUCT.md000077700000000000000000000000001510566137200207462CODE_OF_CONDUCT.rstustar00rootroot00000000000000fake.py-0.11.9/CODE_OF_CONDUCT.rst000066400000000000000000000124251510566137200161600ustar00rootroot00000000000000Contributor Covenant Code of Conduct ==================================== Our Pledge ---------- We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation. We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community. Our Standards ------------- Examples of behavior that contributes to a positive environment for our community include: - Demonstrating empathy and kindness toward other people - Being respectful of differing opinions, viewpoints, and experiences - Giving and gracefully accepting constructive feedback - Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience - Focusing on what is best not just for us as individuals, but for the overall community Examples of unacceptable behavior include: - The use of sexualized language or imagery, and sexual attention or advances of any kind - Trolling, insulting or derogatory comments, and personal or political attacks - Public or private harassment - Publishing others’ private information, such as a physical or email address, without their explicit permission - Other conduct which could reasonably be considered inappropriate in a professional setting Enforcement Responsibilities ---------------------------- Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful. Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate. Scope ----- This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Enforcement ----------- Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at artur.barseghyan@gmail.com. All complaints will be reviewed and investigated promptly and fairly. All community leaders are obligated to respect the privacy and security of the reporter of any incident. Enforcement Guidelines ---------------------- Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct: 1. Correction ~~~~~~~~~~~~~ **Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community. **Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested. 2. Warning ~~~~~~~~~~ **Community Impact**: A violation through a single incident or series of actions. **Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban. 3. Temporary Ban ~~~~~~~~~~~~~~~~ **Community Impact**: A serious violation of community standards, including sustained inappropriate behavior. **Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban. 4. Permanent Ban ~~~~~~~~~~~~~~~~ **Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals. **Consequence**: A permanent ban from any sort of public interaction within the community. Attribution ----------- This Code of Conduct is adapted from the `Contributor Covenant `__, version 2.0, available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. Community Impact Guidelines were inspired by `Mozilla’s code of conduct enforcement ladder `__. For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations. fake.py-0.11.9/CONTRIBUTING.rst000066400000000000000000000124221510566137200156070ustar00rootroot00000000000000Contributor guidelines ====================== .. _fake.py: https://fakepy.readthedocs.io .. _documentation: https://fakepy.readthedocs.io/#writing-documentation .. _testing: https://fakepy.readthedocs.io/#testing .. _pre-commit: https://pre-commit.com/#installation .. _black: https://black.readthedocs.io/ .. _isort: https://pycqa.github.io/isort/ .. _doc8: https://doc8.readthedocs.io/ .. _ruff: https://beta.ruff.rs/docs/ .. _pip-tools: https://pip-tools.readthedocs.io/ .. _uv: https://docs.astral.sh/uv/ .. _tox: https://tox.wiki .. _issues: https://github.com/barseghyanartur/fake.py/issues .. _discussions: https://github.com/barseghyanartur/fake.py/discussions .. _pull request: https://github.com/barseghyanartur/fake.py/pulls .. _support: https://fakepy.readthedocs.io/#support .. _installation: https://fakepy.readthedocs.io/#installation .. _features: https://fakepy.readthedocs.io/#features .. _recipes: https://fakepy.readthedocs.io/en/latest/recipes.html .. _quick start: https://fakepy.readthedocs.io/en/latest/quick_start.html .. _prerequisites: https://fakepy.readthedocs.io/#prerequisites .. _versions manifest: https://github.com/actions/python-versions/blob/main/versions-manifest.json Developer prerequisites ----------------------- pre-commit ~~~~~~~~~~ Refer to `pre-commit`_ for installation instructions. TL;DR: .. code-block:: sh curl -LsSf https://astral.sh/uv/install.sh | sh # Install uv uv tool install pre-commit # Install pre-commit pre-commit install # Install pre-commit hooks Installing `pre-commit`_ will ensure you adhere to the project code quality standards. Code standards -------------- `ruff`_ and `doc8`_ will be automatically triggered by `pre-commit`_. `ruff`_ is configured to do the job of `black`_ and `isort`_ as well. Still, if you want to run checks manually: .. code-block:: sh make doc8 make ruff Requirements ------------ Requirements are compiled using `uv`_. .. code-block:: sh make compile-requirements Virtual environment ------------------- You are advised to work in virtual environment. TL;DR: .. code-block:: sh python -m venv env pip install -e .[all] Documentation ------------- Check the `documentation`_. Testing ------- Check `testing`_. If you introduce changes or fixes, make sure to test them locally using all supported environments. For that use `tox`_. .. code-block:: sh tox In any case, GitHub Actions will catch potential errors, but using tox speeds things up. For a quick test of the package and all examples, use the following `Makefile` command: .. code-block:: sh make test-all Releasing --------- **Sequence of steps:** #. Clean and build .. code-block:: sh make clean make build #. Check the build .. code-block:: sh make check-build #. Test release on test.pypi.org. Make sure to check it before moving forward. .. code-block:: sh make test-release #. Release .. code-block:: sh make release Pull requests ------------- You can contribute to the project by making a `pull request`_. For example: - To fix documentation typos. - To improve documentation (for instance, to add new recipe or fix an existing recipe that doesn't seem to work). - To introduce a new feature (for instance, add support for a non-supported file type). **Good to know:** - This library consists of a single ``fake.py`` module. That module is dependency free, self-contained (includes all tests) and portable. Do not submit pull requests splitting the ``fake.py`` module into small parts. Pull requests with external dependencies in ``fake.py`` module will not be accepted either. - Some tests contain simplified implementation of existing libraries (Django ORM, TortoiseORM, SQLAlchemy). If you need to add integration tests for existing functionality, you can add the relevant code and requirements to the examples, along with tests. Currently, all integration tests are running in the CI against the latest version of Python. **General list to go through:** - Does your change require documentation update? - Does your change require update to tests? - Does your change rely on third-party package or a cloud based service? If so, please consider turning it into a dedicated standalone package, since this library is dependency free (and will always stay so). **When fixing bugs (in addition to the general list):** - Make sure to add regression tests. **When adding a new feature (in addition to the general list):** - Make sure to update the documentation (check whether the `installation`_, `features`_, `recipes`_ and `quick start`_ require changes). GitHub Actions -------------- Only non-EOL versions of Python and software `fake.py`_ aims to integrate with are supported. On GitHub Actions includes tests for more than 40 different variations of Python versions and integration packages. Future, non-stable versions of Python are being tested too, so that new features/incompatibilities could be seen and adopted early. For the list of Python versions supported by GitHub, see GitHub Actions `versions manifest`_. Questions --------- Questions can be asked on GitHub `discussions`_. Issues ------ For reporting a bug or filing a feature request, use GitHub `issues`_. **Do not report security issues on GitHub**. Check the `support`_ section. fake.py-0.11.9/LICENSE000066400000000000000000000020611510566137200141510ustar00rootroot00000000000000MIT License Copyright (c) 2023 Artur Barseghyan Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. fake.py-0.11.9/MANIFEST.in000066400000000000000000000013301510566137200147000ustar00rootroot00000000000000# Include license and metadata files: include pyproject.toml include README.rst include LICENSE include CHANGELOG.rst # Include the package itself include fake.py graft fakepy # Exclude anything under docs/ and examples/: prune docs prune examples prune .github # Exclude specific files exclude __copy_fake.py exclude .env exclude .coveralls.yml exclude .gitignore exclude .pre-commit-config.yaml exclude .readthedocs.yaml exclude .secrets.baseline exclude CODE_OF_CONDUCT.rst exclude CODE_OF_CONDUCT.md exclude conftest.py exclude CONTRIBUTING.rst exclude Makefile exclude SECURITY.md exclude SECURITY.rst exclude tox.ini # Exclude any hidden directories: prune __pycache__ # Drop bytecode, etc. -global-exclude *.py[cod] fake.py-0.11.9/Makefile000066400000000000000000000127301510566137200146100ustar00rootroot00000000000000# Update version ONLY here VERSION := 0.11.9 SHELL := /bin/bash # Makefile for project VENV := ~/.virtualenvs/fake.py/bin/activate UNAME_S := $(shell uname -s) # Build documentation using Sphinx and zip it build_docs: source $(VENV) && sphinx-build -n -b text docs builddocs source $(VENV) && sphinx-build -n -a -b html docs builddocs cd builddocs && zip -r ../builddocs.zip . -x ".*" && cd .. rebuild_docs: source $(VENV) && sphinx-apidoc . --full -o docs -H 'fake.py' -A 'Artur Barseghyan ' -f -d 20 cp docs/conf.py.distrib docs/conf.py cp docs/index.rst.distrib docs/index.rst build_docs_epub: $(MAKE) -C docs/ epub build_docs_pdf: $(MAKE) -C docs/ latexpdf auto_build_docs: source $(VENV) && sphinx-autobuild docs docs/_build/html pre-commit: pre-commit run --all-files doc8: source $(VENV) && doc8 # Run ruff on the codebase ruff: source $(VENV) && ruff check . # Serve the built docs on port 5001 serve_docs: source $(VENV) && cd builddocs && python -m http.server 5001 # Install the project install: source $(VENV) && pip install -e .[all] test: clean source $(VENV) && pytest -vrx -s test-integration: customisation-test \ dataclasses-test \ django-test \ hypothesis-test \ lazyfuzzy-test \ pydantic-test \ sqlalchemy-test \ sqlmodel-test \ tortoise-test test-all: test \ customisation-test \ dataclasses-test \ django-test \ hypothesis-test \ lazyfuzzy-test \ pydantic-test \ sqlalchemy-test \ sqlmodel-test \ tortoise-test customisation-test: source $(VENV) && cd examples/customisation/ && pytest dataclasses-test: source $(VENV) && cd examples/dataclasses/ && pytest django-test: source $(VENV) && cd examples/django/ && pytest hypothesis-test: source $(VENV) && cd examples/hypothesis/ && pytest lazyfuzzy-test: source $(VENV) && cd examples/lazyfuzzy/ && pytest pydantic-test: source $(VENV) && cd examples/pydantic/ && pytest sqlalchemy-test: source $(VENV) && cd examples/sqlalchemy/ && pytest sqlmodel-test: source $(VENV) && cd examples/sqlmodel/ && pytest tortoise-test: source $(VENV) && cd examples/tortoise/ && pytest shell: source $(VENV) && ipython customisation-shell: source $(VENV) && cd examples/customisation/ && python manage.py shell customisation-address-cli: @echo Running Python script: $(filter-out $@,$(MAKECMDGOALS)) source $(VENV) && cd examples/customisation/ && python address_cli.py $(filter-out $@,$(MAKECMDGOALS)) customisation-band-cli: @echo Running Python script: $(filter-out $@,$(MAKECMDGOALS)) source $(VENV) && cd examples/customisation/ && python band_cli.py $(filter-out $@,$(MAKECMDGOALS)) customisation-custom-data-cli: @echo Running Python script: $(filter-out $@,$(MAKECMDGOALS)) source $(VENV) && cd examples/customisation/ && python custom_data_cli.py $(filter-out $@,$(MAKECMDGOALS)) dataclasses-shell: source $(VENV) && cd examples/dataclasses/ && python manage.py shell django-shell: source $(VENV) && python examples/django/manage.py shell django-runserver: source $(VENV) && python examples/django/manage.py runserver 0.0.0.0:8000 --traceback -v 3 django-makemigrations: source $(VENV) && python examples/django/manage.py makemigrations django-apply-migrations: source $(VENV) && python examples/django/manage.py migrate lazyfuzzy-shell: source $(VENV) && cd examples/lazyfuzzy/ && python manage.py shell pydantic-shell: source $(VENV) && cd examples/pydantic/ && python manage.py shell sqlalchemy-shell: source $(VENV) && cd examples/sqlalchemy/ && python manage.py shell sqlmodel-shell: source $(VENV) && cd examples/sqlmodel/ && python manage.py shell tortoise-shell: source $(VENV) && cd examples/tortoise/ && python manage.py shell create-secrets: source $(VENV) && detect-secrets scan > .secrets.baseline detect-secrets: source $(VENV) && detect-secrets scan --baseline .secrets.baseline # Clean up generated files clean: find . -type f -name "*.pyc" -exec rm -f {} \; find . -type f -name "builddocs.zip" -exec rm -f {} \; find . -type f -name "*.py,cover" -exec rm -f {} \; find . -type f -name "*.orig" -exec rm -f {} \; find . -type f -name "*.coverage" -exec rm -f {} \; find . -type f -name "*.db" -exec rm -f {} \; find . -type d -name "__pycache__" -exec rm -rf {} \; -prune rm -rf build/ rm -rf dist/ rm -rf .cache/ rm -rf htmlcov/ rm -rf builddocs/ rm -rf testdocs/ rm -rf .coverage rm -rf .pytest_cache/ rm -rf .mypy_cache/ rm -rf .ruff_cache/ rm -rf dist/ rm -rf fake.py.egg-info/ compile-requirements: source $(VENV) && uv pip compile --all-extras -o docs/requirements.txt pyproject.toml compile-requirements-upgrade: source $(VENV) && uv pip compile --all-extras -o docs/requirements.txt pyproject.toml --upgrade update-version: #sed -i 's/version = "[0-9.]\+"/version = "$(VERSION)"/' pyproject.toml #sed -i 's/__version__ = "[0-9.]\+"/__version__ = "$(VERSION)"/' fake.py @echo "Updating version in pyproject.toml and fake.py" @if [ "$(UNAME_S)" = "Darwin" ]; then \ gsed -i 's/version = "[0-9.]\+"/version = "$(VERSION)"/' pyproject.toml; \ gsed -i 's/__version__ = "[0-9.]\+"/__version__ = "$(VERSION)"/' fake.py; \ else \ sed -i 's/version = "[0-9.]\+"/version = "$(VERSION)"/' pyproject.toml; \ sed -i 's/__version__ = "[0-9.]\+"/__version__ = "$(VERSION)"/' fake.py; \ fi build: source $(VENV) && python -m build . check-build: source $(VENV) && twine check dist/* release: source $(VENV) && twine upload dist/* --verbose test-release: source $(VENV) && twine upload --repository testpypi dist/* mypy: source $(VENV) && mypy fake.py %: @: fake.py-0.11.9/README.rst000066400000000000000000000374711510566137200146500ustar00rootroot00000000000000======= fake.py ======= .. External references .. _Faker: https://faker.readthedocs.io/ .. _factory_boy: https://factoryboy.readthedocs.io/ .. _faker-file: https://faker-file.readthedocs.io/ .. _Pillow: https://python-pillow.org/ .. _dateutil: https://dateutil.readthedocs.io/ .. _Django: https://www.djangoproject.com/ .. _TortoiseORM: https://tortoise.github.io/ .. _Pydantic: https://docs.pydantic.dev/ .. _SQLAlchemy: https://www.sqlalchemy.org/ .. _SQLModel: https://sqlmodel.tiangolo.com/ .. _Pathy: https://github.com/justindujardin/pathy .. _django-storages: https://django-storages.readthedocs.io .. Internal references .. _fake.py: https://github.com/barseghyanartur/fake.py/ .. _Read the Docs: http://fakepy.readthedocs.io/ .. _Quick start: https://fakepy.readthedocs.io/en/latest/quick_start.html .. _Recipes: https://fakepy.readthedocs.io/en/latest/recipes.html .. _Factories: https://fakepy.readthedocs.io/en/latest/factories.html .. _Customisation: https://fakepy.readthedocs.io/en/latest/customisation.html .. _Creating files: https://fakepy.readthedocs.io/en/latest/creating_files.html .. _Creating PDF: https://fakepy.readthedocs.io/en/latest/creating_pdf.html .. _Creating DOCX: https://fakepy.readthedocs.io/en/latest/creating_docx.html .. _Creating ODT: https://fakepy.readthedocs.io/en/latest/creating_odt.html .. _Creating images: https://fakepy.readthedocs.io/en/latest/creating_images.html .. _Creating archives: https://fakepy.readthedocs.io/en/latest/creating_archives.html .. _Cheat sheet: https://fakepy.readthedocs.io/en/latest/cheatsheet.html .. _Examples: https://github.com/barseghyanartur/fake.py/tree/main/examples .. _CLI: https://fakepy.readthedocs.io/en/latest/cli.html .. _Contributor guidelines: https://fakepy.readthedocs.io/en/latest/contributor_guidelines.html .. _llms.txt: https://barseghyanartur.github.io/fake.py/llms.txt .. _Test/coverage configuration tweaks: https://fakepy.readthedocs.io/en/latest/test_configuration_tweaks.html .. Related projects .. _fake-py-pathy-storage: https://github.com/barseghyanartur/fake-py-pathy-storage .. _fake-py-django-storage: https://github.com/barseghyanartur/fake-py-django-storage .. _fake-py-qt: https://github.com/barseghyanartur/fake-py-qt .. _fake-py-wasm: https://github.com/barseghyanartur/fake-py-wasm .. _fake-py-benchmarks: https://github.com/barseghyanartur/fake-py-benchmarks Minimalistic, standalone alternative fake data generator with no dependencies. .. image:: https://img.shields.io/pypi/v/fake.py.svg :target: https://pypi.python.org/pypi/fake.py :alt: PyPI Version .. image:: https://img.shields.io/pypi/pyversions/fake.py.svg :target: https://pypi.python.org/pypi/fake.py/ :alt: Supported Python versions .. image:: https://github.com/barseghyanartur/fake.py/actions/workflows/test.yml/badge.svg?branch=main :target: https://github.com/barseghyanartur/fake.py/actions :alt: Build Status .. image:: https://readthedocs.org/projects/fakepy/badge/?version=latest :target: http://fakepy.readthedocs.io :alt: Documentation Status .. image:: https://img.shields.io/badge/docs-llms.txt-blue :target: https://fakepy.readthedocs.io/en/latest/llms.txt :alt: llms.txt - documentation for LLMs .. image:: https://img.shields.io/badge/license-MIT-blue.svg :target: https://github.com/barseghyanartur/fake.py/#License :alt: MIT .. image:: https://coveralls.io/repos/github/barseghyanartur/fake.py/badge.svg?branch=main&service=github :target: https://coveralls.io/github/barseghyanartur/fake.py?branch=main :alt: Coverage `fake.py`_ is a standalone, portable library designed for generating various random data types for testing. It offers a simplified, dependency-free alternative for creating random texts, (person) names, URLs, dates, file names, IPs, primitive Python data types (such as `uuid`, `str`, `int`, `float`, `bool`), GEO data such as city, country, geo-location, country code, latitude, longitude and locales, IBANs and ISBNs, as well as byte content for multiple file formats including `PDF`, `DOCX`, `ODT`, `RTF`, `EPUB`, `PNG`, `SVG`, `BMP`, `GIF`, `TIF`, `PPM`, `JPG`, `WAV`, `ZIP`, `TAR` and `EML`. The package also supports file creation on the filesystem and includes factories (dynamic fixtures) compatible with `Django`_, `TortoiseORM`_, `Pydantic`_ and `SQLAlchemy`_ (which means it works with `SQLModel`_ too). Features ======== - Generation of random texts, (person) names, emails, URLs, dates, IPs, and primitive Python data types. - Support for various file formats (`PDF`, `DOCX`, `ODT`, `RTF`, `EPUB`, `TXT`, `PNG`, `SVG`, `BMP`, `GIF`, `TIF`, `PPM`, `JPG`, `WAV`, `ZIP`, `TAR`, `EML`) and file creation on the filesystem. - Basic factories for integration with `Django`_, `Pydantic`_, `TortoiseORM`_ and `SQLAlchemy`_. - `CLI`_ for generating data from command line. Prerequisites ============= Python 3.9+ Installation ============ pip --- .. code-block:: sh 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`_). Documentation ============= - Documentation is available on `Read the Docs`_. - For various ready to use code examples see the `Recipes`_. - For tips on how to use the factories see the `Factories`_. - For customisation tips see the `Customisation`_. - For generic information on how to create files see `Creating files`_. - For tips on ``PDF`` creation see `Creating PDF`_. - For tips on ``DOCX`` creation see `Creating DOCX`_. - For tips on ``ODT`` creation see `Creating ODT`_. - For tips on images creation see `Creating images`_. - For tips on archives creation see `Creating archives`_. - For various implementation examples, see the `Examples`_. - For tricks on specific content creation see the `Cheat sheet`_. - For CLI documentation, see the `CLI`_. - For guidelines on contributing check the `Contributor guidelines`_. Usage ===== Generate data ------------- Person names ~~~~~~~~~~~~ .. code-block:: python :name: test_person_names 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] Random texts ~~~~~~~~~~~~ .. code-block:: python :name: test_random_texts 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] Internet ~~~~~~~~ .. code-block:: python :name: test_internet from fake import FAKER FAKER.company_email() # str FAKER.domain_name() # str FAKER.email() # str FAKER.free_email() # str FAKER.free_email_domain() # str FAKER.image_url() # str FAKER.ipv4() # str FAKER.tld() # str FAKER.url() # str Filenames ~~~~~~~~~ .. code-block:: python :name: test_filenames from fake import FAKER FAKER.dir_path() # str FAKER.file_extension() # str FAKER.file_name() # str FAKER.file_path() # str FAKER.mime_type() # str Primitive data types ~~~~~~~~~~~~~~~~~~~~ .. code-block:: python :name: test_primitive_data_types from fake import FAKER FAKER.pybool() # bool FAKER.pyfloat() # float FAKER.pyint() # int FAKER.pystr() # str FAKER.uuid() # uuid.UUID Dates ~~~~~ .. code-block:: python :name: test_dates from fake import FAKER FAKER.date() # datetime.date FAKER.date_time() # datetime.datetime FAKER.year() # int FAKER.time() # str Geographic data ~~~~~~~~~~~~~~~ .. code-block:: python :name: test_geographic_data 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] Books ~~~~~ .. code-block:: python :name: test_books from fake import FAKER FAKER.isbn10() # str FAKER.isbn13() # str Banking ~~~~~~~ .. code-block:: python :name: test_banking from fake import FAKER FAKER.iban() # str Generate files -------------- As bytes ~~~~~~~~ .. code-block:: python :name: test_generate_files_as_bytes 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 As files on the file system ~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. code-block:: python :name: test_generate_files_as_files_on_file_system 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* .. pytestmark: django_db .. code-block:: python :name: test_factories 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: .. continue: test_factories .. pytestmark: django_db .. code-block:: python :name: test_factories_usage # 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* .. code-block:: python :name: test_customise 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``): .. code-block:: python from custom_fake import FAKER # Custom `FAKER` instance FAKER.postal_code() Or as follows: .. code-block:: python 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 Tests ===== Run the tests with unittest: .. code-block:: sh python -m unittest fake.py Or pytest: .. code-block:: sh pytest Differences with alternatives ============================= `fake.py`_ is `Faker`_ + `factory_boy`_ + `faker-file`_ in one package, radically simplified and reduced in features, but without any external dependencies (not even `Pillow`_ or `dateutil`_). `fake.py`_ is modelled after the famous `Faker`_ package. Its API is highly compatible, although drastically reduced. It's not multilingual and does not support postal codes or that many raw file formats. However, you could easily include it in your production setup without worrying about yet another dependency. On the other hand, `fake.py`_ factories look quite similar to `factory_boy`_ factories, although again - drastically simplified and reduced in features. The file generation part of `fake.py`_ is modelled after the `faker-file`_. You don't get a large variety of file types supported and you don't have that much control over the content of the files generated, but you get dependency-free valid files and if that's all you need, you don't need to look further. However, at any point, if you discover that you "need more", go for `Faker`_, `factory_boy`_ and `faker-file`_ combination. Benchmarks ========== See `fake-py-benchmarks`_ for the details. Related projects ================ - `fake-py-pathy-storage`_: `Pathy`_ backed cloud storages for `fake.py`_. Supports `AWS S3`, `Google Cloud Storage` and `Azure Cloud Storage`. - `fake-py-django-storage`_: `Django`_ and `django-storages`_ backed storages for `fake.py`_. Among others, supports `AWS S3`, `Google Cloud Storage` and `Azure Cloud Storage`. - `fake-py-qt`_: Graphical user interface to `fake.py`_. - `fake-py-wasm`_: `fake.py`_ on WASM (web assembly). Writing documentation ===================== Keep the following hierarchy. .. code-block:: text ===== title ===== header ====== sub-header ---------- sub-sub-header ~~~~~~~~~~~~~~ sub-sub-sub-header ^^^^^^^^^^^^^^^^^^ sub-sub-sub-sub-header ++++++++++++++++++++++ sub-sub-sub-sub-sub-header ************************** License ======= MIT Support ======= For security issues contact me at the e-mail given in the `Author`_ section. For overall issues, go to `GitHub `_. Author ====== Artur Barseghyan fake.py-0.11.9/SECURITY.md000077700000000000000000000000001510566137200167322SECURITY.rstustar00rootroot00000000000000fake.py-0.11.9/SECURITY.rst000066400000000000000000000026061510566137200151520ustar00rootroot00000000000000Security Policy =============== Reporting a Vulnerability ------------------------- **Do not report security issues on GitHub!** Please report security issues by emailing Artur Barseghyan . Supported Versions ------------------ The two most recent ``fake.py`` minor release series receive security support. It is recommended to use the latest version. .. code-block:: text ┌─────────────────┬────────────────┐ │ Version │ Supported │ ├─────────────────┼────────────────┤ │ 0.11.x │ Yes │ ├─────────────────┼────────────────┤ │ 0.10.x │ Yes │ ├─────────────────┼────────────────┤ │ < 0.10 │ No │ └─────────────────┴────────────────┘ .. note:: For example, during the development cycle leading to the release of ``fake.py`` 0.17.x, support will be provided for ``fake.py`` 0.16.x. Upon the release of ``fake.py`` 0.18.x, security support for ``fake.py`` 0.16.x will end. fake.py-0.11.9/__copy_fake.py000077700000000000000000000000001510566137200172302fake.pyustar00rootroot00000000000000fake.py-0.11.9/conftest.py000066400000000000000000000012711510566137200153450ustar00rootroot00000000000000""" Configuration hooks for `pytest`. Normally this wouldn't be necessary, but since `pytest-codeblock` is used, we want to clean-up files generated by running documentation tests. Therefore, this hook, which simply calls the `clean_up` method of the `FILE_REGISTRY` instance. """ from fake import FILE_REGISTRY from pytest_codeblock.constants import CODEBLOCK_MARK __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("pytest_runtest_teardown",) def pytest_runtest_teardown(item, nextitem): """Clean up after test ends.""" if item.get_closest_marker(CODEBLOCK_MARK): FILE_REGISTRY.clean_up() fake.py-0.11.9/docs/000077500000000000000000000000001510566137200140755ustar00rootroot00000000000000fake.py-0.11.9/docs/Makefile000066400000000000000000000011721510566137200155360ustar00rootroot00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= SPHINXBUILD ?= sphinx-build SOURCEDIR = . BUILDDIR = _build # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) fake.py-0.11.9/docs/_static/000077500000000000000000000000001510566137200155235ustar00rootroot00000000000000fake.py-0.11.9/docs/_static/examples/000077500000000000000000000000001510566137200173415ustar00rootroot00000000000000fake.py-0.11.9/docs/_static/examples/creating_docx/000077500000000000000000000000001510566137200221525ustar00rootroot00000000000000fake.py-0.11.9/docs/_static/examples/creating_docx/docx_bytes_1.py000066400000000000000000000001301510566137200251010ustar00rootroot00000000000000from fake import FAKER docx_bytes = FAKER.docx() assert isinstance(docx_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_docx/docx_bytes_2.py000066400000000000000000000001751510566137200251130ustar00rootroot00000000000000from fake import FAKER texts = FAKER.sentences() docx_bytes = FAKER.docx(texts=texts) assert isinstance(docx_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_docx/docx_bytes_3.py000066400000000000000000000001441510566137200251100ustar00rootroot00000000000000from fake import FAKER docx_bytes = FAKER.docx(nb_pages=100) assert isinstance(docx_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_docx/docx_file_1.py000066400000000000000000000002141510566137200246750ustar00rootroot00000000000000from fake import FAKER docx_file = FAKER.docx_file() assert isinstance(docx_file, str) assert docx_file.data["storage"].exists(docx_file) fake.py-0.11.9/docs/_static/examples/creating_docx/docx_file_2.py000066400000000000000000000002611510566137200247000ustar00rootroot00000000000000from fake import FAKER texts = FAKER.sentences() docx_file = FAKER.docx_file(texts=texts) assert isinstance(docx_file, str) assert docx_file.data["storage"].exists(docx_file) fake.py-0.11.9/docs/_static/examples/creating_docx/docx_file_3.py000066400000000000000000000002301510566137200246750ustar00rootroot00000000000000from fake import FAKER docx_file = FAKER.docx_file(nb_pages=100) assert isinstance(docx_file, str) assert docx_file.data["storage"].exists(docx_file) fake.py-0.11.9/docs/_static/examples/creating_images/000077500000000000000000000000001510566137200224625ustar00rootroot00000000000000fake.py-0.11.9/docs/_static/examples/creating_images/png_bytes_1.py000066400000000000000000000001251510566137200252440ustar00rootroot00000000000000from fake import FAKER png_bytes = FAKER.png() assert isinstance(png_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_images/png_bytes_2.py000066400000000000000000000001261510566137200252460ustar00rootroot00000000000000from fake import FAKER png_bytes = FAKER.png(size=(500, 500), color=(127, 127, 127)) fake.py-0.11.9/docs/_static/examples/creating_images/png_file_1.py000066400000000000000000000000641510566137200250370ustar00rootroot00000000000000from fake import FAKER png_file = FAKER.png_file() fake.py-0.11.9/docs/_static/examples/creating_images/png_file_2.py000066400000000000000000000001321510566137200250340ustar00rootroot00000000000000from fake import FAKER png_file = FAKER.png_file(size=(500, 500), color=(127, 127, 127)) fake.py-0.11.9/docs/_static/examples/creating_odt/000077500000000000000000000000001510566137200220035ustar00rootroot00000000000000fake.py-0.11.9/docs/_static/examples/creating_odt/odt_bytes_1.py000066400000000000000000000001251510566137200245670ustar00rootroot00000000000000from fake import FAKER odt_bytes = FAKER.odt() assert isinstance(odt_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_odt/odt_bytes_2.py000066400000000000000000000001721510566137200245720ustar00rootroot00000000000000from fake import FAKER texts = FAKER.sentences() odt_bytes = FAKER.odt(texts=texts) assert isinstance(odt_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_odt/odt_bytes_3.py000066400000000000000000000001401510566137200245660ustar00rootroot00000000000000from fake import FAKER odt_bytes = FAKER.odt(nb_pages=100) assert isinstance(odt_bytes, bytes)fake.py-0.11.9/docs/_static/examples/creating_odt/odt_file_1.py000066400000000000000000000002071510566137200243610ustar00rootroot00000000000000from fake import FAKER odt_file = FAKER.odt_file() assert isinstance(odt_file, str) assert odt_file.data["storage"].exists(odt_file) fake.py-0.11.9/docs/_static/examples/creating_odt/odt_file_2.py000066400000000000000000000002541510566137200243640ustar00rootroot00000000000000from fake import FAKER texts = FAKER.sentences() odt_file = FAKER.odt_file(texts=texts) assert isinstance(odt_file, str) assert odt_file.data["storage"].exists(odt_file) fake.py-0.11.9/docs/_static/examples/creating_odt/odt_file_3.py000066400000000000000000000002231510566137200243610ustar00rootroot00000000000000from fake import FAKER odt_file = FAKER.odt_file(nb_pages=100) assert isinstance(odt_file, str) assert odt_file.data["storage"].exists(odt_file) fake.py-0.11.9/docs/_static/examples/creating_pdf/000077500000000000000000000000001510566137200217665ustar00rootroot00000000000000fake.py-0.11.9/docs/_static/examples/creating_pdf/graphic_pdf_bytes_1.py000066400000000000000000000002071510566137200262330ustar00rootroot00000000000000from fake import FAKER, GraphicPdfGenerator pdf_bytes = FAKER.pdf(generator=GraphicPdfGenerator) assert isinstance(pdf_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_pdf/graphic_pdf_bytes_2.py000066400000000000000000000002251510566137200262340ustar00rootroot00000000000000from fake import FAKER, GraphicPdfGenerator pdf_bytes = FAKER.pdf(nb_pages=100, generator=GraphicPdfGenerator) assert isinstance(pdf_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_pdf/graphic_pdf_file_1.py000066400000000000000000000002711510566137200260250ustar00rootroot00000000000000from fake import FAKER, GraphicPdfGenerator pdf_file = FAKER.pdf_file(generator=GraphicPdfGenerator) assert isinstance(pdf_file, str) assert pdf_file.data["storage"].exists(pdf_file) fake.py-0.11.9/docs/_static/examples/creating_pdf/graphic_pdf_file_2.py000066400000000000000000000003071510566137200260260ustar00rootroot00000000000000from fake import FAKER, GraphicPdfGenerator pdf_file = FAKER.pdf_file(nb_pages=100, generator=GraphicPdfGenerator) assert isinstance(pdf_file, str) assert pdf_file.data["storage"].exists(pdf_file) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_bytes_1.py000066400000000000000000000002011510566137200255740ustar00rootroot00000000000000from fake import FAKER, TextPdfGenerator pdf_bytes = FAKER.pdf(generator=TextPdfGenerator) assert isinstance(pdf_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_bytes_2.py000066400000000000000000000002501510566137200256010ustar00rootroot00000000000000from fake import FAKER, TextPdfGenerator texts = FAKER.sentences() pdf_bytes = FAKER.pdf(texts=texts, generator=TextPdfGenerator) assert isinstance(pdf_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_bytes_2b.py000066400000000000000000000003151510566137200257450ustar00rootroot00000000000000from fake import FAKER, TextPdfGenerator texts = ["Page 1 content", "Page 2 content", "Page 3 content"] pdf_bytes = FAKER.pdf(texts=texts, generator=TextPdfGenerator) assert isinstance(pdf_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_bytes_3.py000066400000000000000000000002171510566137200256050ustar00rootroot00000000000000from fake import FAKER, TextPdfGenerator pdf_bytes = FAKER.pdf(nb_pages=100, generator=TextPdfGenerator) assert isinstance(pdf_bytes, bytes) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_file_1.py000066400000000000000000000002631510566137200253750ustar00rootroot00000000000000from fake import FAKER, TextPdfGenerator pdf_file = FAKER.pdf_file(generator=TextPdfGenerator) assert isinstance(pdf_file, str) assert pdf_file.data["storage"].exists(pdf_file) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_file_2.py000066400000000000000000000003321510566137200253730ustar00rootroot00000000000000from fake import FAKER, TextPdfGenerator texts = FAKER.sentences() pdf_file = FAKER.pdf_file(texts=texts, generator=TextPdfGenerator) assert isinstance(pdf_file, str) assert pdf_file.data["storage"].exists(pdf_file) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_file_3.py000066400000000000000000000003011510566137200253700ustar00rootroot00000000000000from fake import FAKER, TextPdfGenerator pdf_file = FAKER.pdf_file(nb_pages=100, generator=TextPdfGenerator) assert isinstance(pdf_file, str) assert pdf_file.data["storage"].exists(pdf_file) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_file_django_1.py000066400000000000000000000005041510566137200267150ustar00rootroot00000000000000from django.conf import settings from fake import FAKER, FileSystemStorage, TextPdfGenerator STORAGE = FileSystemStorage(root_path=settings.MEDIA_ROOT, rel_path="tmp") pdf_file = FAKER.pdf_file(generator=TextPdfGenerator, storage=STORAGE) assert isinstance(pdf_file, str) assert pdf_file.data["storage"].exists(pdf_file) fake.py-0.11.9/docs/_static/examples/creating_pdf/text_pdf_file_pydantic_1.py000066400000000000000000000006721510566137200272740ustar00rootroot00000000000000from pathlib import Path from fake import FAKER, FileSystemStorage, TextPdfGenerator BASE_DIR = Path(__file__).resolve().parent.parent if "__file__" in globals() else Path.cwd() # noqa MEDIA_ROOT = BASE_DIR / "media" STORAGE = FileSystemStorage(root_path=MEDIA_ROOT, rel_path="tmp") pdf_file = FAKER.pdf_file(generator=TextPdfGenerator, storage=STORAGE) assert isinstance(pdf_file, str) assert pdf_file.data["storage"].exists(pdf_file) fake.py-0.11.9/docs/changelog.rst000066400000000000000000000000361510566137200165550ustar00rootroot00000000000000.. include:: ../CHANGELOG.rst fake.py-0.11.9/docs/cheatsheet.rst000066400000000000000000000113111510566137200167410ustar00rootroot00000000000000Cheat sheet =========== Scientific content ------------------ Quick tricks for generating scientific content. DOI (Digital Object Identifier) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Generate a fake DOI - a string formatted as ``10.####/####-####``: .. code-block:: python :name: test_doi from fake import FAKER FAKER.randomise_string(value="10.####/####-####") # '10.4613/4636-8596' ---- ISSN/EISSN (International/Electronic Serial Number) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Generate a fake ISSN/EISSN - a string of eight digits with a hyphen between the groups of four digits: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_issn_eissn :emphasize-lines: 3- from fake import FAKER FAKER.randomise_string(value="####-####") # '6160-6320' ---- ORCID (Open Researcher and Contributor ID) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Generate a fake ORCID ID - four groups of four digits separated by hyphens: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_orchid_id :emphasize-lines: 3- from fake import FAKER FAKER.randomise_string(value="####-####-####-####") # '6827-5849-5672-2984' ---- arXiv Identifier ~~~~~~~~~~~~~~~~ Generate a fake arXiv ID in the modern format (e.g., ``2101.12345``): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_arxiv_id :emphasize-lines: 3- from fake import FAKER FAKER.randomise_string(value="####.#####") # '0206.74568' ---- Scientific article metadata ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Generate fake metadata for a scientific article, including a title, a list of authors, journal name, publication year, and keywords: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_article_metadata :emphasize-lines: 3- from fake import FAKER article_title = FAKER.sentence(suffix="") # 'Preferably youre than is now' authors = [FAKER.name() for _ in range(3)] # ['Thomas Sajip', 'Ben Gust', 'Christian Dragon De Monsyne'] journal = FAKER.string_template("Journal of {word} Studies") # 'Journal of Better Studies' publication_year = FAKER.year(start_year=1970, end_year=2024) # 2001 keywords = FAKER.words() # ['Youre', 'Guess', 'Is', 'Lets', 'Of'] ---- Generate a fake short abstract: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_article_abstract :emphasize-lines: 3- from fake import FAKER abstract = FAKER.string_template( """ {date(start_date="-7d")} # Title: {sentence(nb_words=6, suffix="")} ## Authors: {name}, {name}, {name} ## Abstract ### Introduction {text(nb_chars=200, allow_overflow=True)} ### Objective {text(nb_chars=200, allow_overflow=True)} ### Methods {text(nb_chars=200, allow_overflow=True)} ### Results {text(nb_chars=200, allow_overflow=True)} ### Conclusion {text(nb_chars=200, allow_overflow=True)} Keywords: {word}, {word}, {word} """ ) Sample output: .. code-block:: text 2025-04-08 # Title: Of dutch a cases silenced never ## Authors: Michael Dalke, Barry Dragon De Monsyne, Victor Diederich ## Abstract ### Introduction Implicit idea of better idea. And special errors implicit is. Is are explicit better complicated. More nested cases honking lets. Never of beautiful than be. Explicit way namespaces better explicitly. ### Objective Better implementation it complex by. Way bad preferably do a. Is than temptation good although. The guess if ambiguity the. Better its sparse and special. Is than is preferably than. Of although do to practicality. ### Methods Should its than flat to. There than explicit obvious at. Idea readability idea is ugly. Only refuse now the now. Complex its one complicated of. The flat obvious temptation dutch. Flat is python tim simple. ### Results Way there guess than to. Pass is and are beautiful. It nested that although obvious. Better better simple idea than. Is not better great simple. The complex although explain of. Than special than than obvious. ### Conclusion Explicitly explain more enough honking. To counts dense should pass. Obvious unless is if be. Be implementation good implementation now. Better if than now face. At complex to although than. Than may of better. Keywords: Do, Lets, Unlessd, Purity, Complex fake.py-0.11.9/docs/cli.rst000066400000000000000000000213501510566137200153770ustar00rootroot00000000000000CLI ============= All current providers are supported through the CLI. The CLI entry point is the ``fake-py`` command. ---- Help ---- All commands overview ~~~~~~~~~~~~~~~~~~~~~ *Command* .. code-block:: sh fake-py --help *Output* .. code-block:: sh usage: fake-py [-h] {bmp,bmp_file,company_email,date,date_time,docx,docx_file, domain_name,email,file_name,first_name,first_names, free_email,free_email_domain,generic_file,gif,gif_file, image,image_url,ipv4,last_name,last_names,name,names, paragraph,paragraphs,pdf,pdf_file,png,png_file,pybool, pydecimal,pyfloat,pyint,pystr,random_choice,random_sample, sentence,sentences,slug,slugs,svg,svg_file,text,text_pdf, text_pdf_file,texts,tld,txt_file,url,username,usernames, uuid,uuids,word,words} ... CLI for fake.py positional arguments: {bmp,bmp_file,company_email,date,date_time,docx,docx_file,domain_name, email,file_name,first_name,first_names,free_email,free_email_domain, generic_file,gif,gif_file,image,image_url,ipv4,last_name,last_names, name,names,paragraph,paragraphs,pdf,pdf_file,png,png_file,pybool, pydecimal,pyfloat,pyint,pystr,random_choice,random_sample,sentence, sentences,slug,slugs,svg,svg_file,text,text_pdf,text_pdf_file,texts, tld,txt_file,url,username,usernames,uuid,uuids,word,words} Available commands bmp Create a BMP image of a specified size and colour. bmp_file Create a BMP image file of a specified size and colour. company_email Generate a random company email. date Generate random date between `start_date` and `end_date`. date_time Generate a random datetime between `start_date` and `end_date`. docx Create a DOCX document. docx_file Create a DOCX document file. domain_name Generate a random domain name. email Generate a random email. file_name Generate a random filename. first_name Generate a first name. first_names Generate a list of first names. free_email Generate a random free email. free_email_domain Generate a random free email domain. generic_file Create a generic file. gif Create a GIF image of a specified size and colour. gif_file Create a GIF image file of a specified size and colour. image Create an image of a specified format, size and colour. image_url Generate a random image URL. ipv4 Generate a random IP v4. last_name Generate a last name. last_names Generate a list of last names. name Generate a name. names Generate a list of names. paragraph Generate a paragraph. paragraphs Generate a list of paragraphs. pdf Create a PDF document of a given size. pdf_file Create a PDF file. png Create a PNG image of a specified size and colour. png_file Create a PNG image file of a specified size and colour. pybool Generate a random boolean. pydecimal Generate a random Decimal number. pyfloat Generate a random float number. pyint Generate a random integer. pystr Generate a random string. random_choice random_sample sentence Generate a sentence. sentences Generate a list of sentences. slug Generate a slug. slugs Generate a list of slugs. svg Create an SVG image of a specified size and colour. svg_file Create an SVG image file of a specified size and colour. text Generate a text. text_pdf Create a PDF document of a given size. text_pdf_file Create a text PDF file. texts Generate a list of texts. tld Generate a random TLD. txt_file Create a text document file. url Generate a random URL. username Generate a username. usernames Generate a list of usernames. uuid Generate a UUID. uuids Generate a list of UUIDs. word Generate a word. words Generate a list of words. options: -h, --help show this help message and exit ---- Specific command help ~~~~~~~~~~~~~~~~~~~~~ Each command has help too. *Command* .. code-block:: fake-py url --help *Output* .. code-block:: sh usage: fake-py url [-h] [--protocols PROTOCOLS] [--tlds TLDS] [--suffixes SUFFIXES] options: -h, --help show this help message and exit --protocols PROTOCOLS protocols (type: Optional[tuple[str, ...]]) --tlds TLDS tlds (type: Optional[tuple[str, ...]]) --suffixes SUFFIXES suffixes (type: Optional[tuple[str, ...]]) ---- Common commands --------------- company_email ~~~~~~~~~~~~~ **With defaults** *Command* .. code-block:: sh fake-py company_email *Output* .. code-block:: text michaelfrechet@right.com **With customisations** *Command* .. code-block:: sh fake-py company_email --domain_names="github.com,microsoft.com" *Output* .. code-block:: text barrybaxter@github.com ---- date ~~~~ **With defaults** *Command* .. code-block:: sh fake-py date *Output* .. code-block:: text 2024-06-21 ---- **With customisations** *Command* .. code-block:: sh fake-py date --start_date="-7d" --end_date="7d" *Output* .. code-block:: text 2024-07-04 ---- docx_file ~~~~~~~~~ **With defaults** *Command* .. code-block:: sh fake-py docx_file *Output* .. code-block:: text tmp/tmp_0tnpurz.docx ---- **With customisations** *Command* .. code-block:: sh fake-py docx_file --nb_pages=100 --basename="my_docx_file" *Output* .. code-block:: text tmp/my_docx_file.docx ---- email ~~~~~ **With defaults** *Command* .. code-block:: sh fake-py email *Output* .. code-block:: text bad@not.org **With customisations** *Command* .. code-block:: sh fake-py email --domain_names="github.com,microsoft.com" *Output* .. code-block:: text guess@github.com ---- url ~~~ **With defaults** *Command* .. code-block:: sh fake-py url *Output* .. code-block:: text http://one.com/lets.php ---- **With customisations** *Command* .. code-block:: sh fake-py url --tlds="am,nl,ie" *Output* .. code-block:: text https://readability.ie/face.go ---- slug ~~~~ *Command* .. code-block:: sh fake-py slug *Output* .. code-block:: text unless-ambiguity-to-taaxihkoywxbolrienhq ---- text ~~~~ **With defaults** *Command* .. code-block:: sh fake-py text *Output* .. code-block:: text Should sparse and of idea. Is is is it than. Idea should is should explicitly. Are often practicality refuse than. Of the of in do. Is errors namespaces the better. Never to is do idea. The complicate. ---- **With customisations** *Command* .. code-block:: sh fake-py text --nb_chars=75 *Output* .. code-block:: text Complicated is than explain right. Be silently better idea hard. Break than ---- username ~~~~~~~~ *Command* .. code-block:: sh fake-py username *Output* .. code-block:: text better_if_great_ldffdumuptmqtzssjbgv ---- Customisation ------------- By default, only standard (built-in) providers are available through CLI. However, you can easily expose your custom providers via the CLI as well. See the implementation below as an example. *Filename: data.py* .. literalinclude:: ../examples/customisation/data.py :language: python :lines: 173-175, 222-229, 275-281, 290- *Filename: fake_address.py* .. literalinclude:: ../examples/customisation/fake_address.py :language: python :lines: 1-6, 15- *Filename: address_cli.py* .. literalinclude:: ../examples/customisation/address_cli.py :language: python :lines: 1- After that, you can use it as follows: .. code-block:: sh python address_cli.py --help ---- .. raw:: html   fake.py-0.11.9/docs/code_of_conduct.rst000066400000000000000000000000441510566137200177420ustar00rootroot00000000000000.. include:: ../CODE_OF_CONDUCT.rst fake.py-0.11.9/docs/conf.py000077500000000000000000000055371510566137200154110ustar00rootroot00000000000000# Configuration file for the Sphinx documentation builder. # # For the full list of built-in configuration values, see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html import os import sys sys.path.insert(0, os.path.abspath("..")) # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information try: import fake version = fake.__version__ project = fake.__title__ copyright = fake.__copyright__ author = fake.__author__ except ImportError: version = "0.1" project = "fake.py" copyright = "2023-2025, Artur Barseghyan " author = "Artur Barseghyan " # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration extensions = [ "sphinx.ext.autodoc", "sphinx.ext.viewcode", "sphinx.ext.todo", "sphinx_no_pragma", ] templates_path = ["_templates"] exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] language = "en" release = version # The suffix of source filenames. source_suffix = { ".rst": "restructuredtext", } pygments_style = "sphinx" # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output html_theme = "sphinx_rtd_theme" html_static_path = ["_static"] # html_extra_path = ["examples"] prismjs_base = "//cdnjs.cloudflare.com/ajax/libs/prism/1.29.0" html_css_files = [ f"{prismjs_base}/themes/prism.min.css", f"{prismjs_base}/plugins/toolbar/prism-toolbar.min.css", # "https://cdn.jsdelivr.net/gh/barseghyanartur/jsphinx@1.3.4/src/css/sphinx_rtd_theme.css", "https://cdn.jsdelivr.net/gh/barseghyanartur/jsphinx/src/css/sphinx_rtd_theme.css", ] html_js_files = [ f"{prismjs_base}/prism.min.js", f"{prismjs_base}/plugins/autoloader/prism-autoloader.min.js", f"{prismjs_base}/plugins/toolbar/prism-toolbar.min.js", f"{prismjs_base}/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js", # "https://cdn.jsdelivr.net/gh/barseghyanartur/jsphinx@1.3.4/src/js/download_adapter.js", "https://cdn.jsdelivr.net/gh/barseghyanartur/jsphinx/src/js/download_adapter.js", ] # -- Options for todo extension ---------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/extensions/todo.html#configuration todo_include_todos = True # -- Options for Epub output ---------------------------------------------- epub_title = project epub_author = author epub_publisher = "GitHub" epub_copyright = copyright epub_identifier = "https://github.com/barseghyanartur/fake.py" # URL or ISBN epub_scheme = "URL" # or "ISBN" epub_uid = "https://github.com/barseghyanartur/fake.py" fake.py-0.11.9/docs/conf.py.distrib000077500000000000000000000214541510566137200170440ustar00rootroot00000000000000import os import sys # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.insert(0, os.path.abspath("..")) try: import fake version = fake.__version__ project = fake.__title__ copyright = fake.__copyright__ except ImportError: version = "0.1" project = "fake" copyright = "2023, Artur Barseghyan " # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = [ "sphinx.ext.autodoc", "sphinx.ext.viewcode", ] # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] # The suffix of source filenames. source_suffix = { ".rst": "restructuredtext", } # The master toctree document. master_doc = "index" release = version # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ["_build"] # The name of the Pygments (syntax highlighting) style to use. pygments_style = "sphinx" # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = "default" html_theme = "sphinx_rtd_theme" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. # html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". # html_title = None # A shorter title for the navigation bar. Default is the same as html_title. # html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. # html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. # html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. # html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. # html_use_smartypants = True # Custom sidebar templates, maps document names to template names. # html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. # html_additional_pages = {} # If false, no module index is generated. # html_domain_indices = True # If false, no index is generated. # html_use_index = True # If true, the index is split into individual pages for each letter. # html_split_index = False # If true, links to the reST sources are added to the pages. # html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. # html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. # html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. # html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). # html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = "fake.pydoc" prismjs_base = "//cdnjs.cloudflare.com/ajax/libs/prism/1.29.0" html_css_files = [ f"{prismjs_base}/themes/prism.min.css", f"{prismjs_base}/plugins/toolbar/prism-toolbar.min.css", "https://cdn.jsdelivr.net/gh/barseghyanartur/jsphinx@1.3.4/src/css/sphinx_rtd_theme.css", ] html_js_files = [ f"{prismjs_base}/prism.min.js", f"{prismjs_base}/plugins/autoloader/prism-autoloader.min.js", f"{prismjs_base}/plugins/toolbar/prism-toolbar.min.js", f"{prismjs_base}/plugins/copy-to-clipboard/prism-copy-to-clipboard.min.js", "https://cdn.jsdelivr.net/gh/barseghyanartur/jsphinx@1.3.4/src/js/download_adapter.js", ] # -- Options for LaTeX output -------------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). "papersize": "letterpaper", # The font size ('10pt', '11pt' or '12pt'). "pointsize": "10pt", # Additional stuff for the LaTeX preamble. "preamble": "", } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass # [howto/manual]). latex_documents = [ ( "index", "fake.py.tex", "fake.py Documentation", "Artur Barseghyan \\textless{}artur.barseghyan@gmail.com" "\\textgreater{}", "manual", ), ] # The name of an image file (relative to this directory) to place at the top # of the title page. # latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. # latex_use_parts = False # If true, show page references after internal links. # latex_show_pagerefs = False # If true, show URL addresses after external links. # latex_show_urls = False # Documents to append as an appendix to all manuals. # latex_appendices = [] # If false, no module index is generated. # latex_domain_indices = True # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ( "index", "fake.py", "fake.py Documentation", ["Artur Barseghyan "], 1, ) ] # If true, show URL addresses after external links. # man_show_urls = False # -- Options for Texinfo output ------------------------------------------------ # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ( "index", "fake.py", "fake.py Documentation", "Artur Barseghyan ", "fake.py", "Minimalistic, standalone alternative fake data generator with no " "dependencies.", "Miscellaneous", ), ] # Documents to append as an appendix to all manuals. # texinfo_appendices = [] # If false, no module index is generated. # texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. # texinfo_show_urls = 'footnote' # -- Options for Epub output --------------------------------------------------- # Bibliographic Dublin Core info. epub_title = "fake.py" epub_author = "Artur Barseghyan " epub_publisher = "Artur Barseghyan " epub_copyright = "2023, Artur Barseghyan " # The language of the text. It defaults to the language option # or en if the language is not set. # epub_language = '' # The scheme of the identifier. Typical schemes are ISBN or URL. # epub_scheme = '' # The unique identifier of the text. This can be a ISBN number # or the project homepage. # epub_identifier = '' # A unique identification for the text. # epub_uid = '' # A tuple containing the cover image and cover page html template filenames. # epub_cover = () # HTML files that should be inserted before the pages created by sphinx. # The format is a list of tuples containing the path and title. # epub_pre_files = [] # HTML files shat should be inserted after the pages created by sphinx. # The format is a list of tuples containing the path and title. # epub_post_files = [] # A list of files that should not be packed into the epub file. # epub_exclude_files = [] # The depth of the table of contents in toc.ncx. # epub_tocdepth = 3 # Allow duplicate toc entries. # epub_tocdup = True # -- Options for PDF output --------------------------------------------------- sys.setrecursionlimit(3000) rinoh_documents = [ ( "index", "fake.py Documentation", "fake.py", "Artur Barseghyan ", ) ] # latex_paper_size = 'a4' fake.py-0.11.9/docs/contributor_guidelines.rst000066400000000000000000000000411510566137200214040ustar00rootroot00000000000000.. include:: ../CONTRIBUTING.rst fake.py-0.11.9/docs/creating_archives.rst000066400000000000000000000215661510566137200203210ustar00rootroot00000000000000Creating archives ================= .. External references .. _faker-file: https://pypi.org/project/faker-file/ Creating archives for testing can be a challenging task. The goal of this library is to help you out with basic tasks. You can easily generate ZIP and TAR archives containing, for example, 100 files supported by this package. You can even generate EML files (which are considered archives here since they hold attachments). If you don't like the quality of the generated files and want to have more control over the content of the files, check the `faker-file`_ package, which offers similar functionality but can produce complex archives with almost no limitation on their content. Supported archive formats ------------------------- Currently, 3 formats are supported: - ``ZIP`` - ``TAR`` - ``EML`` ZIP --- Creating a simple ZIP archive as bytes is as simple as follows: .. code-block:: python :name: test_simple_zip_archive from fake import FAKER FAKER.zip() The generated ZIP archive will consist of a single ``TXT`` with little text. All customisation options are passed through the ``options`` optional argument, which is a (nested) dictionary with the following keys: - ``count`` (``int``): - ``create_inner_file_func`` (``callable``): - ``create_inner_file_args`` (``dict[str, Any]``): - ``directory`` (``str``): ---- To customise the number of files in the archive, use the ``count`` key of the ``options`` argument: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_zip_archive_nb_files_5 :emphasize-lines: 3 from fake import FAKER FAKER.zip(options={"count": 5}) This will create a ``ZIP`` archive with 5 ``TXT`` files. ---- To customise the type of files in the archive, use the ``create_inner_file_func`` key of the ``options`` argument: .. code-block:: python :name: test_zip_archive_3_docx_file from fake import FAKER, create_inner_docx_file FAKER.zip( options={ "create_inner_file_func": create_inner_docx_file, } ) This will create a ``ZIP`` archive with a single ``DOCX`` file. ---- All arguments of the ``create_inner_file_func`` are passed in the ``create_inner_file_args`` argument: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_zip_archive_1_docx_file_with_given_texts :emphasize-lines: 3- from fake import FAKER, create_inner_docx_file FAKER.zip( options={ "create_inner_file_func": create_inner_docx_file, "create_inner_file_args": { "texts": ["There", "are", "no", "limits"], } } ) This will create a ``ZIP`` archive with single ``DOCX`` file of 4 pages, where each of the given words ("There", "are", "no", "limits") would occupy a single page. ---- There's no limit to the nesting depth: .. code-block:: python :name: test_zip_archive_nested_zip from fake import ( FAKER, create_inner_zip_file, create_inner_docx_file, ) FAKER.zip( options={ "count": 3, "create_inner_file_func": create_inner_zip_file, "create_inner_file_args": { "options": { "count": 5, "create_inner_file_func": create_inner_docx_file, "create_inner_file_args": { "nb_pages": 100, } } } } ) This will create a nested ``ZIP`` archive with 3 ``ZIP`` archives in it, each having 5 ``DOCX`` files of 100 pages each. ---- If you need a consistent structure of mixed file types, you can use a list of functions as shown below: .. code-block:: python :name: test_zip_archive_structured_using_list_create from fake import ( FAKER, create_inner_docx_file, create_inner_txt_file, list_create_inner_file, ) FAKER.zip( options={ "create_inner_file_func": list_create_inner_file, "create_inner_file_args": { "func_list": [ ( create_inner_docx_file, {"basename": "doc"}, ), ( create_inner_txt_file, {"basename": "doc_metadata"}, ), ( create_inner_txt_file, {"basename": "doc_isbn"}, ), ], }, } ) This will create a ``ZIP`` archive with 1 ``DOCX`` file named `doc.docx` and 2 ``TXT`` files named `doc_metadata.txt` and `doc_isbn.txt`. ---- If you need a file on a disk, instead of bytes, use ``FAKER.zip_file`` instead. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_zip_archive_file :emphasize-lines: 3- from fake import FAKER FAKER.zip_file() ---- All customisation options of ``zip`` are also applicable to ``zip_file``. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_zip_archive_file_structured_using_list_create :emphasize-lines: 8- from fake import ( FAKER, create_inner_docx_file, create_inner_txt_file, list_create_inner_file, ) FAKER.zip_file( options={ "create_inner_file_func": list_create_inner_file, "create_inner_file_args": { "func_list": [ ( create_inner_docx_file, {"basename": "doc"}, ), ( create_inner_txt_file, {"basename": "doc_metadata"}, ), ( create_inner_txt_file, {"basename": "doc_isbn"}, ), ], }, } ) ---- TAR --- Works very similarly to `ZIP`_. Use ``FAKER.tar`` and ``FAKER.tar_file`` instead of ``FAKER.zip`` and ``FAKER.zip_file``. EML --- Works very similarly to `ZIP`_. Use ``FAKER.eml`` and ``FAKER.eml_file`` instead of ``FAKER.zip`` and ``FAKER.zip_file``. - ``options``: (Optional) options. Similar to ``ZIP`` options. - ``content``: (Optional) Email message content. - ``subject``: (Optional) Email message subject. - ``cte_type``: (Optional) Email message Content-Transfer-Encoding (CTE). - ``policy``: (Optional) Email message policy. Creating a simple EML archive as bytes is as simple as follows: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_simple_eml_archive :emphasize-lines: 3 from fake import FAKER FAKER.eml() ---- Create an EML archive with ``Content-Transfer-Encoding`` set to ``7bit``: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_eml_archive_cte_7bit :emphasize-lines: 3 from fake import FAKER FAKER.eml(cte_type="7bit") ---- This will create an ``EML`` archive with 1 ``DOCX`` file named `doc.docx` and 2 ``TXT`` files named `doc_metadata.txt` and `doc_isbn.txt`. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_eml_archive_structured_using_list_create :emphasize-lines: 8- from fake import ( FAKER, create_inner_docx_file, create_inner_txt_file, list_create_inner_file, ) FAKER.eml( options={ "create_inner_file_func": list_create_inner_file, "create_inner_file_args": { "func_list": [ ( create_inner_docx_file, {"basename": "doc"}, ), ( create_inner_txt_file, {"basename": "doc_metadata"}, ), ( create_inner_txt_file, {"basename": "doc_isbn"}, ), ], }, } ) ---- Using text templates: .. code-block:: python :name: test_text_templates from fake import FAKER, StringTemplate template = """ {date(start_date='-7d')} {name} {sentence(nb_words=2, suffix='')} {pyint(min_value=1, max_value=99)} {randomise_string(value='#### ??', digits='123456789')} {city} Dear friend, {text(nb_chars=1000, allow_overflow=True)} Sincerely yours, {name} {email} {domain_name} """ # EML file eml_file = FAKER.eml_file(content=StringTemplate(template)) ---- .. raw:: html   fake.py-0.11.9/docs/creating_docx.rst000066400000000000000000000073331510566137200174460ustar00rootroot00000000000000Creating DOCX ============= .. External references .. _faker-file: https://pypi.org/project/faker-file/ The goal of this library is to help you out with basic tasks. You can easily generate DOCX files with 100 pages (paper size is A4), having a little text on each. If you don't like how DOCX files are generated by this library, you can check the `faker-file`_ package, which can produce complex DOCX documents. If you need bytes ----------------- .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_docx/docx_bytes_1.py :name: test_creating_docx_docx_bytes_1 :language: python :lines: 1-3 *See the full example* :download:`here <_static/examples/creating_docx/docx_bytes_1.py>` The generated DOCX will consist of a single page with little text on it. If you want to control the number of pages created, you could: - Pass a list of texts to the ``texts`` argument. - Pass the number of pages to the ``nb_pages`` argument. ---- See the example below for ``texts`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_docx/docx_bytes_2.py :name: test_creating_docx_docx_bytes_2 :language: python :lines: 3-4 *See the full example* :download:`here <_static/examples/creating_docx/docx_bytes_2.py>` ---- See the example below for ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_docx/docx_bytes_3.py :name: test_creating_docx_docx_bytes_3 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_docx/docx_bytes_3.py>` If you need files ----------------- .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_docx/docx_file_1.py :name: test_creating_docx_docx_file_1 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_docx/docx_file_1.py>` ---- With ``texts`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_docx/docx_file_2.py :name: test_creating_docx_docx_file_2 :language: python :lines: 3-4 *See the full example* :download:`here <_static/examples/creating_docx/docx_file_2.py>` ---- With ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_docx/docx_file_3.py :name: test_creating_docx_docx_file_3 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_docx/docx_file_3.py>` ---- Using text templates: .. container:: jsphinx-toggle-emphasis-replace .. code-block:: python :name: test_text_templates :emphasize-lines: 1-26 from fake import FAKER, StringTemplate template = """ {date(start_date='-7d')} {name} {sentence(nb_words=2, suffix='')} {pyint(min_value=1, max_value=99)} {randomise_string(value='#### ??', digits='123456789')} {city} Dear friend, {text(nb_chars=1000, allow_overflow=True)} Sincerely yours, {name} {email} {domain_name} """ # DOCX file of 1 page docx_file_1 = FAKER.docx_file( texts=[StringTemplate(template)], ) # DOCX file of 10 pages docx_file_10 = FAKER.docx_file( texts=[StringTemplate(template) for _ in range(10)], ) # Tests assert isinstance(docx_file_1, str) assert docx_file_1.data["storage"].exists(docx_file_1) assert isinstance(docx_file_10, str) assert docx_file_10.data["storage"].exists(docx_file_10) ---- .. raw:: html   fake.py-0.11.9/docs/creating_files.rst000066400000000000000000000142001510566137200176020ustar00rootroot00000000000000Creating files ============== .. Internal references .. _fake.py: https://github.com/barseghyanartur/fake.py/ .. _Creating archives: https://fakepy.readthedocs.io/en/latest/creating_archives.html .. _Creating DOCX: https://fakepy.readthedocs.io/en/latest/creating_docx.html .. _Creating images: https://fakepy.readthedocs.io/en/latest/creating_images.html .. _Creating ODT: https://fakepy.readthedocs.io/en/latest/creating_odt.html .. _Creating PDF: https://fakepy.readthedocs.io/en/latest/creating_pdf.html Creation of specific file formats is extensively covered in dedicated sections: - `Creating archives`_ - `Creating DOCX`_ - `Creating images`_ - `Creating ODT`_ - `Creating PDF`_ This section covers basic concepts of file generation within `fake.py`_. Basics ------ It's possible to generate either in-memory byte content or actual files on the file system. - When generating bytes, the returned value is ``BytesValue``. - When generating files on the file system, the returned value is ``StringValue``. Both ``BytesValue`` and ``StringValue`` behave like ``bytes`` and ``str`` respectively, but have a ``data`` (``dict``) property, which contains useful meta-data about the specific kind of file. For generated files, it will always have the following: - ``storage``: Storage class that was used to generate the file. - ``filename``: Absolute file path. It's important to know that string representation of the file contains a relative file path. ---- See the example below for a **graphic** PDF generation: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf_file :emphasize-lines: 3 from fake import FAKER pdf_file = FAKER.pdf_file() print(pdf_file) # Relative path # tmp/tmpnvwoa2ap.pdf print(pdf_file.data["filename"]) # Absolute path # /tmp/tmp/tmpnvwoa2ap.pdf print(pdf_file.data) # Meta-data # {'storage': , # 'filename': '/tmp/tmp/tmpragc8wyr.pdf', # 'content': None} ---- See the example below for a **text** PDF generation: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_text_pdf_file :emphasize-lines: 3 from fake import FAKER pdf_file = FAKER.text_pdf_file() print(pdf_file) # tmp/tmpragc8wyr.pdf print(pdf_file.data["filename"]) # /tmp/tmp/tmpragc8wyr.pdf print(pdf_file.data) # {'storage': , # 'filename': '/tmp/tmp/tmpragc8wyr.pdf', # 'content': 'If dutch beats although complex.'} Note, that text PDF does contain full text of the entire document in the ``content`` key. ---- Clean up files -------------- ``FileSystemStorage`` is the default storage and by default files are stored inside a ``tmp`` directory within the system's temporary directory, which is commonly cleaned up after system restart. However, there's a mechanism of cleaning up files after the tests run. At any time, to clean up all files created by that moment, call ``clean_up`` method of the ``FileRegistry`` class instance, as shown below: .. code-block:: python :name: test_file_registry from fake import FAKER, FILE_REGISTRY # Import the file registry # Create a file txt_file = FAKER.txt_file() # type: ``StringValue`` filename = str(txt_file) # Relative path to the file storage = txt_file.data["storage"] # Storage instance # File should exist assert storage.exists(filename) # Trigger the clean-up FILE_REGISTRY.clean_up() # File no longer exists assert storage.exists(filename) is False Typically you would call the ``clean_up`` method in the ``tearDown``. ---- To remove a single file, use the ``remove`` method of ``FileRegistry`` instance. In the example below, the file is removed by providing the ``StringValue`` instance: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_registry_remove_by_string_value :emphasize-lines: 11-12 from fake import FAKER, FILE_REGISTRY # Create a file txt_file = FAKER.txt_file() # type: StringValue filename = str(txt_file) # Relative path to the file storage = txt_file.data["storage"] # Storage instance # File should exist assert storage.exists(filename) # Remove the file by providing the ``StringValue`` instance FILE_REGISTRY.remove(txt_file) # File no longer exists assert storage.exists(filename) is False ---- You can also remove by path. In the exampl below, the file is removed by providing the ``str`` instance: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_registry_remove_by_str :emphasize-lines: 11-12 from fake import FAKER, FILE_REGISTRY # Create a file txt_file = FAKER.txt_file() # type: StringValue filename = str(txt_file) # Relative path to the file storage = txt_file.data["storage"] # Storage instance # File should exist assert storage.exists(filename) # Remove the file by providing the ``filename`` FILE_REGISTRY.remove(filename) # File no longer exist assert storage.exists(filename) is False ---- If you only have a path to the file as ``str`` instance, you can find the correspondent ``StringValue`` instance by searching, using the ``search`` method: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_registry_search :emphasize-lines: 11-12 from fake import FAKER, FILE_REGISTRY # Create a file txt_file = FAKER.txt_file() # type: ``StringValue`` filename = str(txt_file) # Relative path to the file storage = txt_file.data["storage"] # Storage instance # File should exist assert storage.exists(filename) # Find the file by providing the ``str`` instance found_file = FILE_REGISTRY.search(filename) # type: StringValue # They should be the same assert txt_file == found_file ---- .. raw:: html   fake.py-0.11.9/docs/creating_images.rst000066400000000000000000000073041510566137200177540ustar00rootroot00000000000000Creating images =============== .. Internal references .. _faker-file: https://pypi.org/project/faker-file/ Creating images for testing can be a challenging task. The goal of this library is to help you out with basic tasks. You can easily generate very basic graphic images (no custom shapes). If you don't like how image files are generated by this library, you can check the `faker-file`_ package, which can produce complex images. Supported image formats ----------------------- Currently, 7 image formats are supported: - ``PNG`` - ``SVG`` - ``BMP`` - ``GIF`` - ``TIF`` - ``PPM`` - ``JPG`` Generating images as bytes -------------------------- See the following fully functional snippet for generating a ``PNG`` image. .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_images/png_bytes_1.py :name: test_creating_images_png_bytes_1 :language: python :lines: 1-3 *See the full example* :download:`here <_static/examples/creating_images/png_bytes_1.py>` The generated ``PNG`` image will be an image filled with a given colour of a size 100x100 px. ---- If you want an image of a different size or colour, provide ``size`` (width, height: ``Tuple[int, int]``) or ``color`` (RGB tuple: ``Tuple[int, int, int]``) arguments. See the example below: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_images/png_bytes_2.py :name: test_creating_images_png_bytes_2 :language: python :lines: 3- *See the full example* :download:`here <_static/examples/creating_images/png_bytes_2.py>` Generating files ---------------- Generate a ``PNG`` image. .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_images/png_file_1.py :name: test_creating_images_png_file_1 :language: python :lines: 3- *See the full example* :download:`here <_static/examples/creating_images/png_file_1.py>` ---- With ``size`` and ``color`` tweaks: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_images/png_file_2.py :name: test_creating_images_png_file_2 :language: python :lines: 3- *See the full example* :download:`here <_static/examples/creating_images/png_file_2.py>` ---- All other image formats (``SVG``, ``BMP``, ``GIF``, ``TIF``, ``PPM`` and ``JPG``) work in exactly the same way. The only format that slightly deviates from others is ``JPG``. Produced ``JPG`` images are still rectangles, but unlike all others, instead of being filled with a single solid colour, they are filled with a mixture of colours, based on a chosen base colour. Also, colours on the ``JPG`` image are not precise, but a closest match to the colour given. The following code will generate a 10x10 px square filled with a solid yellow colour. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_jpg_file_10x10_yellow :emphasize-lines: 3 from fake import FAKER FAKER.jpg_file(size=(10, 10), color=(182, 232, 90)) While the following code will generate a 640x480 px square filled with yellow and other colours. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_jpg_file_640x480_yellow_mix :emphasize-lines: 3 from fake import FAKER FAKER.jpg_file(size=(640, 480), color=(18, 52, 185)) The only colour that always stays solid is the default colour - gray ``(128, 128, 128)``. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_jpg_file_300x200_solid_gray :emphasize-lines: 3 from fake import FAKER FAKER.jpg_file(size=(720, 540)) ---- .. raw:: html   fake.py-0.11.9/docs/creating_odt.rst000066400000000000000000000072461510566137200173020ustar00rootroot00000000000000Creating ODT ============ .. External references .. _faker-file: https://pypi.org/project/faker-file/ The goal of this library is to help you out with basic tasks. You can easily generate ODT files with 100 pages (paper size is A4), having a little text on each. If you don't like how ODT files are generated by this library, you can check the `faker-file`_ package, which can produce complex ODT documents. If you need bytes ----------------- .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_odt/odt_bytes_1.py :name: test_creating_odt_odt_bytes_1 :language: python :lines: 1-3 *See the full example* :download:`here <_static/examples/creating_odt/odt_bytes_1.py>` The generated ODT will consist of a single page with little text on it. If you want to control the number of pages created, you could: - Pass a list of texts to the ``texts`` argument. - Pass the number of pages to the ``nb_pages`` argument. ---- See the example below for ``texts`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_odt/odt_bytes_2.py :name: test_creating_odt_odt_bytes_2 :language: python :lines: 3-4 *See the full example* :download:`here <_static/examples/creating_odt/odt_bytes_2.py>` ---- See the example below for ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_odt/odt_bytes_3.py :name: test_creating_odt_odt_bytes_3 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_odt/odt_bytes_3.py>` If you need files ----------------- .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_odt/odt_file_1.py :name: test_creating_odt_odt_file_1 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_odt/odt_file_1.py>` ---- With ``texts`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_odt/odt_file_2.py :name: test_creating_odt_odt_file_2 :language: python :lines: 3-4 *See the full example* :download:`here <_static/examples/creating_odt/odt_file_2.py>` ---- With ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_odt/odt_file_3.py :name: test_creating_odt_odt_file_3 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_odt/odt_file_3.py>` ---- Using text templates: .. container:: jsphinx-toggle-emphasis-replace .. code-block:: python :name: test_text_templates :emphasize-lines: 1-26 from fake import FAKER, StringTemplate template = """ {date(start_date='-7d')} {name} {sentence(nb_words=2, suffix='')} {pyint(min_value=1, max_value=99)} {randomise_string(value='#### ??', digits='123456789')} {city} Dear friend, {text(nb_chars=1000, allow_overflow=True)} Sincerely yours, {name} {email} {domain_name} """ # ODT file of 1 page odt_file_1 = FAKER.odt_file( texts=[StringTemplate(template)], ) # ODT file of 10 pages odt_file_10 = FAKER.odt_file( texts=[StringTemplate(template) for _ in range(10)], ) # Tests assert isinstance(odt_file_1, str) assert odt_file_1.data["storage"].exists(odt_file_1) assert isinstance(odt_file_10, str) assert odt_file_10.data["storage"].exists(odt_file_10) ---- .. raw:: html   fake.py-0.11.9/docs/creating_pdf.rst000066400000000000000000000121451510566137200172570ustar00rootroot00000000000000Creating PDF ============ .. External references .. _faker-file: https://pypi.org/project/faker-file/ PDF is certainly one of the most complicated formats out there. And certainly one of the formats most of the developers will be having trouble with, as there are many versions and dialects. The goal of this library is to help you out with basic tasks. You can easily generate PDFs with 100 pages (paper size is A4), having a little text on each. Or you can generate PDFs with images. Currently, you can't have both at the same time. If you don't like how PDF files are generated by this library, you can check the `faker-file`_ package, which can produce complex PDF documents. Building PDF with text ---------------------- If you need bytes ~~~~~~~~~~~~~~~~~ .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/text_pdf_bytes_1.py :name: test_creating_pdf_text_pdf_bytes_1 :language: python :lines: 1-3 *See the full example* :download:`here <_static/examples/creating_pdf/text_pdf_bytes_1.py>` The generated PDF will consist of a single page with little text on it. If you want to control the number of pages created, you could: - Pass a list of texts to the ``texts`` argument. - Pass the number of pages to the ``nb_pages`` argument. ---- See the example below for ``texts`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/text_pdf_bytes_2.py :name: test_creating_pdf_text_pdf_bytes_2 :language: python :lines: 3-4 *See the full example* :download:`here <_static/examples/creating_pdf/text_pdf_bytes_2.py>` ---- For full clarity, see another example below for ``texts`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/text_pdf_bytes_2b.py :name: test_creating_pdf_text_pdf_bytes_2b :language: python :lines: 3-4 *See the full example* :download:`here <_static/examples/creating_pdf/text_pdf_bytes_2b.py>` The produced PDF will have 3 pages: - The first will show: ``Page 1 content`` - The second page will show: ``Page 2 content`` - The third page will show: ``Page 3 content`` ---- See the example below for ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/text_pdf_bytes_3.py :name: test_creating_pdf_text_pdf_bytes_3 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_pdf/text_pdf_bytes_3.py>` If you need files ~~~~~~~~~~~~~~~~~ .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/text_pdf_file_1.py :name: test_creating_pdf_text_pdf_file_1 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_pdf/text_pdf_file_1.py>` ---- With ``texts`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/text_pdf_file_2.py :name: test_creating_pdf_text_pdf_file_2 :language: python :lines: 3-4 *See the full example* :download:`here <_static/examples/creating_pdf/text_pdf_file_2.py>` ---- With ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/text_pdf_file_3.py :name: test_creating_pdf_text_pdf_file_3 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_pdf/text_pdf_file_3.py>` Building PDF with graphics -------------------------- If you need bytes ~~~~~~~~~~~~~~~~~ .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/graphic_pdf_bytes_1.py :name: test_creating_pdf_graphic_pdf_bytes_1 :language: python :lines: 1-3 *See the full example* :download:`here <_static/examples/creating_pdf/graphic_pdf_bytes_1.py>` The generated PDF will consist of a single page with a coloured square on it. If you want a PDF with more pages, provide the ``nb_pages`` argument. ---- See the example below for ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/graphic_pdf_bytes_2.py :name: test_creating_pdf_graphic_pdf_bytes_2 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_pdf/graphic_pdf_bytes_2.py>` If you need files ~~~~~~~~~~~~~~~~~ .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/graphic_pdf_file_1.py :name: test_creating_pdf_graphic_pdf_file_1 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_pdf/graphic_pdf_file_1.py>` ---- With ``nb_pages`` tweak: .. container:: jsphinx-download .. literalinclude:: _static/examples/creating_pdf/graphic_pdf_file_2.py :name: test_creating_pdf_graphic_pdf_file_2 :language: python :lines: 3 *See the full example* :download:`here <_static/examples/creating_pdf/graphic_pdf_file_2.py>` ---- .. raw:: html   fake.py-0.11.9/docs/customisation.rst000066400000000000000000000157441510566137200175430ustar00rootroot00000000000000Customisation ============= - The ``fake.FAKER`` is an instance of the ``fake.Faker`` class. - The ``fake.FACTORY`` is an instance of the ``fake.Factory`` class, initialised with the ``fake.FAKER`` instance. The ``Faker`` class is easy to customise. See the following example: *Filename: custom_fake.py* .. code-block:: python :name: test_customisation_custom_fake import random import string from fake import Faker, Factory, provider # Custom first names dictionary FIRST_NAMES = [ "Anahit", "Ani", "Aram", "Areg", "Artur", "Astghik", "Atom", "Barsegh", "Gaiane", "Gor", "Hakob", "Hasmik", "Levon", "Lilit", "Mariam", "Nare", "Narek", "Nune", "Raffi", "Shant", "Tatev", "Tigran", "Vahan", "Vardan", ] # Custom last names dictionary LAST_NAMES = [ "Amatouni", "Avagyan", "Danielyan", "Egoyan", "Gevorgyan", "Gnouni", "Grigoryan", "Hakobyan", "Harutyunyan", "Hovhannisyan", "Karapetyan", "Khachatryan", "Manukyan", "Melikyan", "Mkrtchyan", "Petrosyan", "Sahakyants", "Sargsyan", "Saroyan", "Sedrakyan", "Simonyan", "Stepanyan", "Ter-Martirosyan", "Vardanyan", ] # Custom words dictionary WORDS = [ "time", "person", "year", "way", "day", "thing", "man", "world", "life", "hand", "part", "child", "eye", "woman", "place", "work", "week", "case", "point", "government", "company", "number", "group", "problem", "fact", "be", "have", "do", "say", "get", "make", "go", "know", "take", "see", "come", "think", "look", "want", "give", "use", "find", "tell", "ask", "work", "seem", "feel", "try", "leave", "call", "good", "new", "first", "last", "long", "great", "little", "own", "other", "old", "right", "big", "high", "different", "small", "large", "next", "early", "young", "important", "few", "public", "bad", "same", "able", "to", "of", "in", "for", "on", "with", "as", "at", "by", "from", "up", "about", "into", "over", "after", "beneath", "under", "above", "the", "and", "a", "that", "I", "it", "not", ] STREET_NAMES = [ "Bosweg", "Groningerweg", "Jasmijnstraat", "Noordstraat", "Ooststraat", "Oranjestraat", "Prinsengracht", "Ringweg", "Weststraat", "Zonnelaan", "Zuidstraat", ] CITIES = [ "Amsterdam", "Delft", "Den Haag", "Groningen", "Leiden", "Nijmegen", ] REGIONS = [ "Friesland", "Groningen", "Limburg", "Utrecht", ] class CustomFaker(Faker): """Custom Faker class.""" def load_names(self) -> None: """Override default first- and last-names dictionaries.""" self._first_names = FIRST_NAMES self._last_names = LAST_NAMES def load_words(self) -> None: """Override default words dictionary.""" self._words = WORDS @provider def address_line(self) -> str: """Generate a random Dutch address line like 'Oranjestraat 1'. :return: A randomly generated Dutch address line as a string. """ # Generate components of the address street = random.choice(STREET_NAMES) house_number = random.randint(1, 200) suffixes = [""] * 10 + ["A", "B", "C"] # Optional suffixes suffix = random.choice(suffixes) # Combine components into a Dutch address format return f"{street} {house_number}{suffix}" @provider def city(self) -> str: return random.choice(CITIES) @provider def region(self) -> str: return random.choice(REGIONS) @provider def postal_code(self) -> str: """Generate a random Dutch postal code in the format '1234 AB'. :return: A randomly generated Dutch postal code as a string. """ 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) The ``postal_code`` is the provider method and shall be decorated with ``@provider`` decorator. You can now use both ``FAKER`` and ``FACTORY`` as you would normally do. ---- *Filename: models.py* .. continue: test_customisation_custom_fake .. code-block:: python :name: test_customisation_models from dataclasses import dataclass from datetime import date @dataclass class Address: id: int address_line: str postal_code: str city: str region: str def __str__(self) -> str: return self.address_line @dataclass class Person: id: int first_name: str last_name: str email: str dob: date address: Address def __str__(self) -> str: return self.username ---- *Filename: factories.py* .. container:: jsphinx-toggle-emphasis .. continue: test_customisation_custom_fake .. code-block:: python :name: test_customisation_factories :emphasize-lines: 1, 6- from fake import ModelFactory, SubFactory, post_save, pre_save # Import defined ORM models and customised FACTORY instance: # from models import Address, Person # from custom_fake import FACTORY class AddressFactory(ModelFactory): id = FACTORY.pyint() address_line = FACTORY.address_line() postal_code = FACTORY.postal_code() city = FACTORY.city() region = FACTORY.region() class Meta: model = Address class PersonFactory(ModelFactory): id = FACTORY.pyint() first_name = FACTORY.first_name() last_name = FACTORY.last_name() email = FACTORY.email() dob = FACTORY.date() address = SubFactory(AddressFactory) class Meta: model = Person ---- And this is how you could use it: .. container:: jsphinx-toggle-emphasis .. continue: test_customisation_custom_fake .. code-block:: python :name: test_customisation_use_factories :emphasize-lines: 1, 5-6 address = AddressFactory() assert isinstance(address, Address) assert address.city in CITIES assert address.region in REGIONS person = PersonFactory() assert isinstance(person, Person) assert person.first_name in FIRST_NAMES assert person.last_name in LAST_NAMES ---- .. raw:: html   fake.py-0.11.9/docs/customization.rst000066400000000000000000000000371510566137200175370ustar00rootroot00000000000000.. include:: customisation.rst fake.py-0.11.9/docs/documentation.rst000077500000000000000000000006271510566137200175100ustar00rootroot00000000000000 Project documentation ===================== Contents: .. contents:: Table of Contents .. toctree:: :maxdepth: 2 index recipes cheatsheet creating_files creating_images creating_pdf creating_docx creating_odt creating_archives factories customisation test_configuration_tweaks cli security contributor_guidelines code_of_conduct changelog package fake.py-0.11.9/docs/factories.rst000066400000000000000000000271471510566137200166210ustar00rootroot00000000000000Factories ========= - ``pre_init`` is a method decorator that will always run before the instance is initialised. - ``pre_save`` is a method decorator that will always run before the instance is saved. - ``post_save`` is a method decorator that will always run after the instance is saved. - ``trait`` decorator runs the code if set to True in factory constructor. - ``PreInit`` is like the ``pre_init`` decorator of the ``ModelFactory``, but you can pass arguments to it and have a lot of flexibility. See a working example (below) of how set a user password in Django. - ``PreSave`` is like the ``pre_save`` decorator of the ``ModelFactory``, but you can pass arguments to it and have a lot of flexibility. See a working example (below) of how set a user password in Django. - ``PostSave`` is like the ``post_save`` decorator of the ``ModelFactory``, but you can pass arguments to it and have a lot of flexibility. See a working example (below) of how to assign a User to a Group after User creation. - ``LazyAttribute`` expects a callable, will take the instance as a first argument, runs it with extra arguments specified and sets the value as an attribute name. - ``LazyFunction`` expects a callable, runs it (without any arguments) and sets the value as an attribute name. - ``SubFactory`` is for specifying relations (typically - ForeignKeys or nested objects). Django example -------------- Models ~~~~~~ In the ``Django`` example, we will be using ``User`` and ``Group`` models from ``django.contrib.auth`` sub-package. The ``Article`` would be the only application specific custom model. *Filename: article/models.py* .. container:: jsphinx-download .. literalinclude:: ../examples/django/article/models.py :language: python :lines: 1-3, 9-26 *See the full example* :download:`here <../examples/django/article/models.py>` ---- Factories ~~~~~~~~~ Factory for the Django's built-in ``Group`` model could look as simple as this: *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/django/article/factories.py :language: python :lines: 4-5, 7, 10-11, 13, 23, 56-58, 68-72 *See the full example* :download:`here <../examples/django/article/factories.py>` ---- Factory for the Django's built-in ``User`` model could look as this: *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/django/article/factories.py :language: python :lines: 1-2, 4, 6-10, 12, 15-17, 23, 73-90, 121-135, 141-146 *See the full example* :download:`here <../examples/django/article/factories.py>` Breakdown: - ``username`` is a required field. We shouldn't be using ``PreSave`` or ``PostSave`` methods here, because we need it to be available and resolved before calling the class constructor (missing required fields would fail on Pydantic and other frameworks that enforce strong type checking). That's why ``PreInit``, which operates on the ``dict`` level, from which the model instance is constructed, is used here to construct the ``username`` value from ``first_name`` and the ``last_name``. The ``set_username`` helper function, which is used by ``PreInit``, accepts a dictionary with model data as argument and all changes to that dictionary are passed further to the class constructor. It's important to mention that functions passed to the ``PreInit``, do not have to return anything. - ``password`` is a non-required field and since Django provides a built-in way to handle passwords, use of ``PreSave`` is the best option here. It's important to mention that functions passed to the ``PreSave``, do not have to return anything. - ``group`` is a non-required many-to-many relationship. We need a User instance to be created before we can add User to a Group. That's why ``PostSave`` is the best option here. It's important to mention that functions passed to the ``PostSave``, do not have to return anything. ---- A factory for the ``Article`` model could look like this: *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/django/article/factories.py :language: python :lines: 3, 10, 14, 18, 20, 23-25, 35-55, 157-163, 180-198 *See the full example* :download:`here <../examples/django/article/factories.py>` Breakdown: - ``headline`` is a required field that should be available and resolved before the class constructor is called. We already know that ``PreInit`` should be used for such cases. The ``headline`` value is constructed from ``content``. - ``author`` is a foreign key relation field to the ``User`` model. For foreign key relations ``SubFactory`` is our best choice. - ``image`` is a file field. Files created shall be placed in the path specified in ``MEDIA_ROOT`` Django setting. That's why we create and configure the ``STORAGE`` instance to pass it to ``FACTORY.png_file`` in a ``storage`` argument. - ``auto_minutes_to_read`` is a required field of the ``Article`` model. It needs to be resolved and available before the constructor class is called. That's the ``@pre_init`` decorator is used on the ``set_auto_minutes_read`` helper method. ---- All together it would look as follows: *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/django/article/factories.py :language: python :lines: 1-25, 35-58, 68-90, 121-135, 141-146, 157-163, 180-199 *See the full example* :download:`here <../examples/django/article/factories.py>` ---- **Usage example** .. code-block:: python # Create one article article = ArticleFactory() # Create 5 articles articles = ArticleFactory.create_batch(5) # Create one article with authors username set to admin. article = ArticleFactory(author__username="admin") # Using trait user = UserFactory(is_admin_user=True) # Using trait in SubFactory article = ArticleFactory(author__is_admin_user=True) # Create a user. Created user will automatically have his password # set to "test1234" and will be added to the group "Test group". user = UserFactory() # Create a user with custom password user = UserFactory( password=PreSave(set_password, password="another-pass"), ) # 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"), ) ---- Pydantic example ---------------- Models ~~~~~~ Example Pydantic models closely resemble the earlier shown Django models. *Filename: article/models.py* .. container:: jsphinx-download .. literalinclude:: ../examples/pydantic/article/models.py :language: python :lines: 1-5, 15-25, 31- *See the full example* :download:`here <../examples/pydantic/article/models.py>` ---- Factories ~~~~~~~~~ Example Pydantic factories are almost identical to the earlier shown Django factories. *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/pydantic/article/factories.py :language: python :lines: 1-20, 30-98, 114-140 *See the full example* :download:`here <../examples/pydantic/article/factories.py>` *Used just like in previous example.* ---- TortoiseORM example ------------------- .. note:: TortoiseORM introduces deadlocks from version to version. Currently, last version that worked smoothly with factories of this package was 0.22.2. 0.22.x, 0.20.x and 0.21.x branches worked, while 0.23.x and 0.24.x fail. Models ~~~~~~ Example TortoiseORM models closely resemble the earlier shown Django models. *Filename: article/models.py* .. container:: jsphinx-download .. literalinclude:: ../examples/tortoise/article/models.py :language: python :lines: 1-5, 15-21, 25-41, 45-61 *See the full example* :download:`here <../examples/tortoise/article/models.py>` ---- Factories ~~~~~~~~~ Example TortoiseORM factories are almost identical to the earlier shown Django factories. *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/tortoise/article/factories.py :language: python :lines: 1-21, 31-106, 116-143 *See the full example* :download:`here <../examples/tortoise/article/factories.py>` *Used just like in previous example.* ---- Dataclasses example ------------------- Models ~~~~~~ Example dataclass models closely resemble the earlier shown Django models. *Filename: article/models.py* .. container:: jsphinx-download .. literalinclude:: ../examples/dataclasses/article/models.py :language: python :lines: 1-5, 15- *See the full example* :download:`here <../examples/dataclasses/article/models.py>` ---- Factories ~~~~~~~~~ Example dataclass factories are almost identical to the earlier shown Django factories. *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/dataclasses/article/factories.py :language: python :lines: 1-20, 30-98, 109-135 *See the full example* :download:`here <../examples/dataclasses/article/factories.py>` *Used just like in previous example.* ---- SQLAlchemy example ------------------ Configuration ~~~~~~~~~~~~~ *Filename: config.py* .. container:: jsphinx-download .. literalinclude:: ../examples/sqlalchemy/config.py :language: python :lines: 1-2, 12- *See the full example* :download:`here <../examples/sqlalchemy/config.py>` ---- Models ~~~~~~ Example SQLAlchemy models closely resemble the earlier shown Django models. *Filename: article/models.py* .. container:: jsphinx-download .. literalinclude:: ../examples/sqlalchemy/article/models.py :language: python :lines: 1-16, 26-46, 50-75, 79-105 *See the full example* :download:`here <../examples/sqlalchemy/article/models.py>` ---- Factories ~~~~~~~~~ Example SQLAlchemy factories are almost identical to the earlier shown Django factories. *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/sqlalchemy/article/factories.py :language: python :lines: 1-21, 30-122, 133-163 *See the full example* :download:`here <../examples/sqlalchemy/article/factories.py>` *Used just like in previous example.* ---- SQLModel example ---------------- Configuration ~~~~~~~~~~~~~ *Filename: config.py* .. container:: jsphinx-download .. literalinclude:: ../examples/sqlmodel/config.py :language: python :lines: 1-2, 12- *See the full example* :download:`here <../examples/sqlmodel/config.py>` ---- Models ~~~~~~ Example SQLModel models closely resemble the earlier shown Django models. *Filename: article/models.py* .. container:: jsphinx-download .. literalinclude:: ../examples/sqlmodel/article/models.py :language: python :lines: 1-5, 15- *See the full example* :download:`here <../examples/sqlmodel/article/models.py>` ---- Factories ~~~~~~~~~ Example SQLModel factories are identical to the earlier shown SQLAlchemy factories. *Filename: article/factories.py* .. container:: jsphinx-download .. literalinclude:: ../examples/sqlmodel/article/factories.py :language: python :lines: 1-21, 31- *See the full example* :download:`here <../examples/sqlmodel/article/factories.py>` *Used just like in previous example.* ---- .. raw:: html   fake.py-0.11.9/docs/fake.rst000066400000000000000000000001441510566137200155340ustar00rootroot00000000000000fake module =========== .. automodule:: fake :members: :undoc-members: :show-inheritance: fake.py-0.11.9/docs/index.rst000066400000000000000000000000721510566137200157350ustar00rootroot00000000000000.. include:: ../README.rst .. include:: documentation.rst fake.py-0.11.9/docs/index.rst.distrib000066400000000000000000000000721510566137200173740ustar00rootroot00000000000000.. include:: ../README.rst .. include:: documentation.rst fake.py-0.11.9/docs/llms.rst000066400000000000000000000010141510566137200155720ustar00rootroot00000000000000.. include:: ../README.rst ---- .. include:: recipes.rst ---- .. include:: cheatsheet.rst ---- .. include:: creating_files.rst ---- .. include:: creating_images.rst ---- .. include:: creating_pdf.rst ---- .. include:: creating_docx.rst ---- .. include:: creating_odt.rst ---- .. include:: creating_archives.rst ---- .. include:: factories.rst ---- .. include:: customisation.rst ---- .. include:: test_configuration_tweaks.rst ---- .. include:: cli.rst ---- .. include:: contributor_guidelines.rst fake.py-0.11.9/docs/make.bat000066400000000000000000000014401510566137200155010ustar00rootroot00000000000000@ECHO OFF pushd %~dp0 REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set SOURCEDIR=. set BUILDDIR=_build %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.https://www.sphinx-doc.org/ exit /b 1 ) if "%1" == "" goto help %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% goto end :help %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% :end popd fake.py-0.11.9/docs/package.rst000066400000000000000000000002251510566137200162210ustar00rootroot00000000000000 Package ======= .. toctree:: :maxdepth: 20 fake Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` fake.py-0.11.9/docs/recipes.rst000066400000000000000000001067631510566137200162760ustar00rootroot00000000000000Recipes ======= .. _isbn-checker: https://isbn-checker.netlify.app/ .. _iban-calculator: https://www.ibancalculator.com/iban_validieren.html Imports and initialization -------------------------- .. code-block:: python :name: test_init from fake import FAKER ---- Providers --------- first_name ~~~~~~~~~~ Returns a random first name. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_first_name :emphasize-lines: 3 from fake import FAKER FAKER.first_name() ---- last_name ~~~~~~~~~ Returns a random last name. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_last_name :emphasize-lines: 3 from fake import FAKER FAKER.last_name() ---- name ~~~~ Returns a random full name. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_name :emphasize-lines: 3 from fake import FAKER FAKER.name() ---- word ~~~~ Returns a random word. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_word :emphasize-lines: 3 from fake import FAKER FAKER.word() ---- words ~~~~~ Returns a list of ``nb`` (number) random words. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_words :emphasize-lines: 3 from fake import FAKER FAKER.words() Arguments: - ``nb`` (type: ``int``, default value: ``5``) is an optional argument. Example with arguments (returns a list of 10 words): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_words_nb_10 :emphasize-lines: 3 from fake import FAKER FAKER.words(nb=10) ---- sentence ~~~~~~~~ Returns a random sentence with ``nb_words`` number of words. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_sentence :emphasize-lines: 3 from fake import FAKER FAKER.sentence() Arguments: - ``nb_words`` (type: ``int``, default value: ``5``) is an optional argument. Example with arguments (returns a sentence of 10 words): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_sentence_nb_words_10 :emphasize-lines: 3 from fake import FAKER FAKER.sentence(nb_words=10) ---- sentences ~~~~~~~~~ Returns a list of ``nb`` (number) random sentences. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_sentences :emphasize-lines: 3 from fake import FAKER FAKER.sentences() Arguments: - ``nb`` (type: ``int``, default value: ``3``) is an optional argument. Example with arguments (returns a list of 10 sentences): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_sentences_nb_10 :emphasize-lines: 3 from fake import FAKER FAKER.sentences(nb=10) ---- paragraph ~~~~~~~~~ Returns a random paragraph with ``nb_sentences`` number of sentences. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_paragraph :emphasize-lines: 3 from fake import FAKER FAKER.paragraph() Arguments: - ``nb_sentences`` (type: ``int``, default value: ``5``) is an optional argument. Example with arguments (returns a paragraph of 10 sentences): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_paragraph_nb_sentences_10 :emphasize-lines: 3 from fake import FAKER FAKER.paragraph(nb_sentences=10) ---- paragraphs ~~~~~~~~~~ Returns a list of ``nb`` (number) random paragraphs. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_paragraphs :emphasize-lines: 3 from fake import FAKER FAKER.paragraphs() Arguments: - ``nb`` (type: ``int``, default value: ``3``) is an optional argument. Example with arguments (returns a list of 10 paragraphs): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_paragraphs_nb_10 :emphasize-lines: 3 from fake import FAKER FAKER.paragraphs(nb=10) ---- text ~~~~ Returns random text with up to ``nb_chars`` characters. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_text :emphasize-lines: 3 from fake import FAKER FAKER.text() Arguments: - ``nb_chars`` (type: ``int``, default value: ``200``) is an optional argument. Example with arguments (returns a 1000 character long text): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_text_nb_chars_1000 :emphasize-lines: 3 from fake import FAKER FAKER.text(nb_chars=1_000) ---- texts ~~~~~ Returns a list of ``nb`` (number) random texts. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_texts :emphasize-lines: 3 from fake import FAKER FAKER.texts() Arguments: - ``nb`` (type: ``int``, default value: ``3``) is an optional argument. Example with arguments (returns a list of 10 texts): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_texts_nb_10 :emphasize-lines: 3 from fake import FAKER FAKER.texts(nb=10) ---- file_name ~~~~~~~~~ Returns a random file name with the given extension. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_name :emphasize-lines: 3 from fake import FAKER FAKER.file_name() Arguments: - ``extension`` (type: ``str``, default value: ``txt``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``""``) is an optional argument. Example with arguments (returns a filename with "png" extension): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_name_extension_png :emphasize-lines: 3 from fake import FAKER FAKER.file_name(extension="png") ---- file_path ~~~~~~~~~ Returns a random file path with the given extension. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_path :emphasize-lines: 3 from fake import FAKER FAKER.file_path() Arguments: - ``extension`` (type: ``str``, default value: ``txt``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``""``) is an optional argument. Example with arguments (returns a file path with "png" extension): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_path_extension_png :emphasize-lines: 3 from fake import FAKER FAKER.file_path(extension="png") ---- dir_path ~~~~~~~~ Returns a random directory path. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_dir_path :emphasize-lines: 3 from fake import FAKER FAKER.dir_path() Arguments: - ``depth`` (type: ``int``, default value: ``1``) is an optional argument. Example with arguments (returns a directory path): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_dir_path_depth_3 :emphasize-lines: 3 from fake import FAKER FAKER.dir_path(depth=3) ---- file_extension ~~~~~~~~~~~~~~ Returns a random file extension. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_file_extension :emphasize-lines: 3 from fake import FAKER FAKER.file_extension() ---- tld ~~~~~ Returns a TLD (top-level domain name). .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_tld :emphasize-lines: 3 from fake import FAKER FAKER.tld() Arguments: - ``tlds`` (type: ``Optional[Tuple[str, ...]]``, default value: ``None``) is an optional argument. Example with arguments (returns either "com", "net" or "org" TLD): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_tld_tlds_com_net_org :emphasize-lines: 3 from fake import FAKER FAKER.tld(tlds=("com", "net", "org")) ---- domain_name ~~~~~~~~~~~ Returns a domain name. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_domain_name :emphasize-lines: 3 from fake import FAKER FAKER.domain_name() Arguments: - ``tlds`` (type: ``Optional[Tuple[str, ...]]``, default value: ``None``) is an optional argument. Example with arguments (returns an domain name with either "com", "net" or "org" TLD): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_domain_name_tlds_com_net_org :emphasize-lines: 3 from fake import FAKER FAKER.domain_name(tlds=("com", "net", "org")) ---- free_email_domain ~~~~~~~~~~~~~~~~~ Returns a free e-mail domain name. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_free_email_domain :emphasize-lines: 3 from fake import FAKER FAKER.free_email_domain() ---- email ~~~~~ Returns a random e-mail address. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_email :emphasize-lines: 3 from fake import FAKER FAKER.email() Arguments: - ``domain_names`` (type: ``Optional[Tuple[str, ...]]``, default value: ``None``) is an optional argument. Example with arguments (returns an e-mail address with either "gmail.com" or "proton.me" domain): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_email_domain_gmail_proton :emphasize-lines: 3 from fake import FAKER FAKER.email(domain_names=("gmail.com", "proton.me")) ---- company_email ~~~~~~~~~~~~~ Returns a random company e-mail address. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_company_email :emphasize-lines: 3 from fake import FAKER FAKER.company_email() Arguments: - ``domain_names`` (type: ``Optional[Tuple[str, ...]]``, default value: ``None``) is an optional argument. Example with arguments (returns an e-mail address with either "microsoft.com" or "google.com" domain): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_company_email_domain_microsoft_google :emphasize-lines: 3 from fake import FAKER FAKER.email(domain_names=("microsoft.com", "google.com")) ---- free_email ~~~~~~~~~~ Returns a random free e-mail address. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_free_email :emphasize-lines: 3 from fake import FAKER FAKER.free_email() Arguments: - ``domain_names`` (type: ``Optional[Tuple[str, ...]]``, default value: ``None``) is an optional argument. Example with arguments (returns an e-mail with either "gmail.com" or "proton.me" domain): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_free_email_domain_gmail_proton :emphasize-lines: 3 from fake import FAKER FAKER.email(domain_names=("gmail.com", "proton.me")) ---- url ~~~ Returns a random URL. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_url :emphasize-lines: 3 from fake import FAKER FAKER.url() Arguments: - ``protocols`` (type: ``Optional[Tuple[str]]``, default value: ``None``) is an optional argument. - ``tlds`` (type: ``Optional[Tuple[str]]``, default value: ``None``) is an optional argument. - ``suffixes`` (type: ``Optional[Tuple[str]]``, default value: ``None``) is an optional argument. ---- image_url ~~~~~~~~~ Returns a valid random image URL. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_image_url :emphasize-lines: 3 from fake import FAKER FAKER.image_url() Arguments: - ``width`` (type: ``int``, default value: ``800``) is a required argument. - ``height`` (type: ``int``, default value: ``600``) is an required argument. - ``service_url`` (type: ``Optional[str]``, default value: ``None``) is an optional argument. Example with arguments (alternative dimensions): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_image_url_width_640_height_480 :emphasize-lines: 3 from fake import FAKER FAKER.image_url(width=640, height=480) ---- pyint ~~~~~ Returns a random integer between ``min_value`` and ``max_value``. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pyint :emphasize-lines: 3 from fake import FAKER FAKER.pyint() Arguments: - ``min_value`` (type: ``int``, default value: ``0``) is an optional argument. - ``max_value`` (type: ``int``, default value: ``9999``) is an optional argument. Example with arguments (returns an integer between 0 and 100): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pyint_min_value_0_max_value_100 :emphasize-lines: 3 from fake import FAKER FAKER.pyint(min_value=0, max_value=100) ---- pybool ~~~~~~ Returns a random boolean value. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pybool :emphasize-lines: 3 from fake import FAKER FAKER.pybool() ---- pystr ~~~~~ Returns a random string of ``nb_chars`` length. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pystr :emphasize-lines: 3 from fake import FAKER FAKER.pystr() Arguments: - ``nb_chars`` (type: ``int``, default value: ``20``) is an optional argument. Example with arguments (returns a string of 64 characters): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pystr_nb_chars_64 :emphasize-lines: 3 from fake import FAKER FAKER.pystr(nb_chars=64) ---- pyfloat ~~~~~~~ Returns a random float between ``min_value`` and ``max_value``. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pyfloat :emphasize-lines: 3 from fake import FAKER FAKER.pyfloat() Arguments: - ``min_value`` (type: ``float``, default value: ``0.0``) is an optional argument. - ``max_value`` (type: ``float``, default value: ``10.00``) is an optional argument. Example with arguments (returns a float between 0 and 100): .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pyfloat_min_value_0_max_value_100 :emphasize-lines: 3 from fake import FAKER FAKER.pyfloat(min_value=0.0, max_value=100.0) ---- pydecimal ~~~~~~~~~ Returns a random decimal, according to given ``left_digits`` and ``right_digits``. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pydecimal :emphasize-lines: 3 from fake import FAKER FAKER.pydecimal() Arguments: - ``left_digits`` (type: ``int``, default value: ``5``) is an optional argument. - ``right_digits`` (type: ``int``, default value: ``2``) is an optional argument. - ``positive`` (type: ``bool``, default value: ``True``) is an optional argument. Example with arguments: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pydecimal_left_digits_1_right_digits_4_positive_false :emphasize-lines: 3 from fake import FAKER FAKER.pydecimal(left_digits=1, right_digits=4, positive=False) ---- ipv4 ~~~~ Returns a random IPv4 address. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_ipv4 :emphasize-lines: 3 from fake import FAKER FAKER.ipv4() ---- date ~~~~ Generates a random date. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_date :emphasize-lines: 3 from fake import FAKER FAKER.date() Arguments: - ``start_date`` (type: ``str``, default value: ``-7d``) is a optional argument. - ``end_date`` (type: ``str``, default value: ``+0d``) is an optional argument. Example with arguments, generate a random date between given ``start_date`` and ``end_date``: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_date_start_date_end_date :emphasize-lines: 3 from fake import FAKER FAKER.date(start_date="-1d", end_date="+1d") ---- date_time ~~~~~~~~~ Generates a random datetime. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_date_time :emphasize-lines: 3 from fake import FAKER FAKER.date_time() Arguments: - ``start_date`` (type: ``str``, default value: ``-7d``) is an optional argument. - ``end_date`` (type: ``str``, default value: ``+0d``) is an optional argument. Example with arguments, generate a random date between given ``start_date`` and ``end_date``: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_date_time_start_date_end_date :emphasize-lines: 3 from fake import FAKER FAKER.date_time(start_date="-1d", end_date="+1d") ---- pdf ~~~ Generates a content (``bytes``) of a PDF document. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf :emphasize-lines: 3 from fake import FAKER FAKER.pdf() Arguments: - ``nb_pages`` (type: ``int``, default value: ``1``) is an optional argument. - ``texts`` (type: ``list[str]``, default value: ``None``) is an optional argument. - ``generator`` (type: ``Union[Type[TextPdfGenerator], Type[GraphicPdfGenerator]]``, default value: ``GraphicPdfGenerator``) is an optional argument. - ``metadata`` (type: ``MetaData``, default value: ``None``) is an optional argument. .. note:: ``texts`` is valid only in case ``TextPdfGenerator`` is used. .. note:: Either ``nb_pages`` or ``texts`` shall be provided. ``nb_pages`` is by default set to ``1``, but if ``texts`` is given, the value of ``nb_pages`` is adjusted accordingly. Examples with arguments. Generate a content (``bytes``) of a PDF document of 100 pages with random graphics: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf_nb_pages_100 :emphasize-lines: 3 from fake import FAKER FAKER.pdf(nb_pages=100) Generate a content (``bytes``) of a PDF document of 100 pages with random texts: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf_nb_pages_100_generator_text :emphasize-lines: 2- from fake import FAKER from fake import TextPdfGenerator FAKER.pdf(nb_pages=100, generator=TextPdfGenerator) If you want to get insights of the content used to generate the PDF (texts), pass the ``metadata`` argument. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_nb_pages_100_generator_text_metadata :emphasize-lines: 2- from fake import FAKER from fake import MetaData, TextPdfGenerator metadata = MetaData() FAKER.pdf(nb_pages=100, generator=TextPdfGenerator, metadata=metadata) print(metadata.content) # Inspect ``metadata`` ---- image ~~~~~ Generates a content (``bytes``) of an image of the specified format and colour. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_image :emphasize-lines: 3 from fake import FAKER FAKER.image() # Supported formats are `png`, `svg`, `bmp` and `gif` Arguments: - ``image_format`` (type: ``str``, default value: ``png``) is an optional argument. - ``size`` (type: ``Tuple[int, int]``, default value: ``(100, 100)``) is an optional argument. - ``color`` (type: ``Tuple[int, int, int]``, default value: ``(0, 0, 255)``) is an optional argument. Example with arguments. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_image_image_format_svg :emphasize-lines: 3- from fake import FAKER FAKER.image( image_format="svg", # SVG format size=(640, 480), # 640px width, 480px height color=(0, 0, 0), # Fill rectangle with black ) ---- docx ~~~~ Generates a content (``bytes``) of a DOCX document. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_docx :emphasize-lines: 3 from fake import FAKER FAKER.docx() Arguments: - ``nb_pages`` (type: ``int``, default value: ``1``) is an optional argument. - ``texts`` (type: ``list[str]``, default value: ``None``) is an optional argument. .. note:: Either ``nb_pages`` or ``texts`` shall be provided. ``nb_pages`` is by default set to ``1``, but if ``texts`` is given, the value of ``nb_pages`` is adjusted accordingly. Examples with arguments. Generate a content (``bytes``) of a DOCX document of 100 pages with random texts: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_docx_nb_pages_100 :emphasize-lines: 3 from fake import FAKER FAKER.docx(nb_pages=100) If you want to get insights of the content used to generate the DOCX (texts), pass the ``metadata`` argument. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_docx_nb_pages_100_metadata :emphasize-lines: 2- from fake import FAKER from fake import MetaData metadata = MetaData() FAKER.docx(nb_pages=100, metadata=metadata) print(metadata.content) # Inspect ``metadata`` ---- odt ~~~ Generates a content (``bytes``) of a ODT document. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_odt :emphasize-lines: 3 from fake import FAKER FAKER.odt() Arguments: - ``nb_pages`` (type: ``int``, default value: ``1``) is an optional argument. - ``texts`` (type: ``list[str]``, default value: ``None``) is an optional argument. .. note:: Either ``nb_pages`` or ``texts`` shall be provided. ``nb_pages`` is by default set to ``1``, but if ``texts`` is given, the value of ``nb_pages`` is adjusted accordingly. Examples with arguments. Generate a content (``bytes``) of a ODT document of 100 pages with random texts: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_odt_nb_pages_100 :emphasize-lines: 3 from fake import FAKER FAKER.odt(nb_pages=100) If you want to get insights of the content used to generate the ODT (texts), pass the ``metadata`` argument. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_odt_nb_pages_100_metadata :emphasize-lines: 2- from fake import FAKER from fake import MetaData metadata = MetaData() FAKER.odt(nb_pages=100, metadata=metadata) print(metadata.content) # Inspect ``metadata`` ---- bin ~~~ Generates a content (``bytes``) of a BIN document. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_bin :emphasize-lines: 3 from fake import FAKER FAKER.bin() Arguments: - ``length`` (type: ``int``, default value: ``16``) is a required argument. Examples with arguments. Generate a content (``bytes``) of a BIN document of length 100: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_bin_length_100 :emphasize-lines: 3 from fake import FAKER FAKER.bin(length=100) ---- zip ~~~ Generates a content (``bytes``) of a ZIP document. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_zip :emphasize-lines: 3 from fake import FAKER FAKER.zip() Arguments: - ``options`` (type: ``Dict``, default value: ``None``) is an optional argument. ---- eml ~~~ Generates a content (``bytes``) of a EML document. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_eml :emphasize-lines: 3 from fake import FAKER FAKER.eml() Arguments: - ``options`` (type: ``Dict``, default value: ``None``) is an optional argument. - ``content`` (type: ``str``, default value: ``None``) is an optional argument. - ``subject`` (type: ``str``, default value: ``None``) is an optional argument. ---- tar ~~~ Generates a content (``bytes``) of a TAR document. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_tar :emphasize-lines: 3 from fake import FAKER FAKER.tar() Arguments: - ``options`` (type: ``Dict``, default value: ``None``) is an optional argument. ---- pdf_file ~~~~~~~~ Generates a ``PDF`` file. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf_file :emphasize-lines: 3 from fake import FAKER FAKER.pdf_file() Arguments: .. note:: Accepts all arguments of ``pdf`` + the following: - ``storage`` (type: ``BaseStorage``, default value: ``None``) is an optional argument. - ``basename`` (type: ``str``, default value: ``None``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``None``) is an optional argument. Examples with arguments. Generate a PDF document of 100 pages with random graphics: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf_file_nb_pages_100 :emphasize-lines: 3 from fake import FAKER FAKER.pdf_file(nb_pages=100) Generate a PDF document of 100 pages with random texts: .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf_file_nb_pages_100_generator_text :emphasize-lines: 2- from fake import FAKER from fake import TextPdfGenerator FAKER.pdf_file(nb_pages=100, generator=TextPdfGenerator) If you want to get insights of the content used to generate the PDF (texts), pass the ``metadata`` argument. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_pdf_file_nb_pages_100_generator_text_metadata :emphasize-lines: 2- from fake import FAKER from fake import MetaData, TextPdfGenerator metadata = MetaData() FAKER.pdf_file(nb_pages=100, generator=TextPdfGenerator, metadata=metadata) print(metadata.content) # Inspect ``metadata`` ---- png_file ~~~~~~~~ Generates a ``PNG`` file. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_png_file :emphasize-lines: 3 from fake import FAKER FAKER.png_file() Arguments: .. note:: Accepts all arguments of ``png`` + the following: - ``storage`` (type: ``BaseStorage``, default value: ``None``) is an optional argument. - ``basename`` (type: ``str``, default value: ``None``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``None``) is an optional argument. Example with arguments. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_png_file_basename_size_color :emphasize-lines: 3- from fake import FAKER FAKER.png_file( basename="png_file", # Basename size=(640, 480), # 640px width, 480px height color=(0, 0, 0), # Fill rectangle with black ) ---- svg_file ~~~~~~~~ Generates an ``SVG`` file. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_svg_file :emphasize-lines: 3 from fake import FAKER FAKER.svg_file() Arguments: .. note:: Accepts all arguments of ``svg`` + the following: - ``storage`` (type: ``BaseStorage``, default value: ``None``) is an optional argument. - ``basename`` (type: ``str``, default value: ``None``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``None``) is an optional argument. Example with arguments. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_svg_file_basename_size_color :emphasize-lines: 3- from fake import FAKER FAKER.svg_file( basename="svg_file", # Basename size=(640, 480), # 640px width, 480px height color=(0, 0, 0), # Fill rectangle with black ) ---- bmp_file ~~~~~~~~ Generates a ``BMP`` file. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_bmp_file :emphasize-lines: 3 from fake import FAKER FAKER.bmp_file() Arguments: .. note:: Accepts all arguments of ``bmp`` + the following: - ``storage`` (type: ``BaseStorage``, default value: ``None``) is an optional argument. - ``basename`` (type: ``str``, default value: ``None``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``None``) is an optional argument. Example with arguments. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_bmp_file_basename_size_color :emphasize-lines: 3- from fake import FAKER FAKER.bmp_file( basename="bmp_file", # Basename size=(640, 480), # 640px width, 480px height color=(0, 0, 0), # Fill rectangle with black ) ---- gif_file ~~~~~~~~ Generates a ``GIF`` file. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_gif_file :emphasize-lines: 3 from fake import FAKER FAKER.gif_file() Arguments: .. note:: Accepts all arguments of ``gif`` + the following: - ``storage`` (type: ``BaseStorage``, default value: ``None``) is an optional argument. - ``basename`` (type: ``str``, default value: ``None``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``None``) is an optional argument. Example with arguments. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_gif_file_basename_size_color :emphasize-lines: 3- from fake import FAKER FAKER.gif_file( basename="gif_file", # Basename size=(640, 480), # 640px width, 480px height color=(0, 0, 0), # Fill rectangle with black ) ---- txt_file ~~~~~~~~ Generates a ``TXT`` file. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_txt_file :emphasize-lines: 3 from fake import FAKER FAKER.txt_file() Arguments: .. note:: Accepts all arguments of ``text`` + the following: - ``storage`` (type: ``BaseStorage``, default value: ``None``) is an optional argument. - ``basename`` (type: ``str``, default value: ``None``) is an optional argument. - ``prefix`` (type: ``str``, default value: ``None``) is an optional argument. Example with arguments. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_txt_file_basename_nb_chars :emphasize-lines: 3- from fake import FAKER FAKER.txt_file( basename="txt_file", # Basename nb_chars=10_000, # 10_000 characters long ) ---- city ~~~~ Get a random city. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_city :emphasize-lines: 3 from fake import FAKER FAKER.city() ---- country ~~~~~~~ Get a random country. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_country :emphasize-lines: 3 from fake import FAKER FAKER.country() ---- geo_location ~~~~~~~~~~~~ Get a random geo-location. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_geo_location :emphasize-lines: 3 from fake import FAKER FAKER.geo_location() ---- country_code ~~~~~~~~~~~~ Get a random country code. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_country_code :emphasize-lines: 3 from fake import FAKER FAKER.country_code() ---- locale ~~~~~~ Generate a random locale. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_locale :emphasize-lines: 3 from fake import FAKER FAKER.locale() ---- latitude ~~~~~~~~ Generate a random latitude. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_latitude :emphasize-lines: 3 from fake import FAKER FAKER.latitude() ---- longitude ~~~~~~~~~ Generate a random longitude. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_longitude :emphasize-lines: 3 from fake import FAKER FAKER.longitude() ---- latitude_longitude ~~~~~~~~~~~~~~~~~~ Generate a random (latitude, longitude) pair. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_latitude_longitude :emphasize-lines: 3 from fake import FAKER FAKER.latitude_longitude() ---- isbn10 ~~~~~~ Generate a random ISBN10. Can be validated using `isbn-checker`_. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_isbn10 :emphasize-lines: 3 from fake import FAKER FAKER.isbn10() ---- isbn13 ~~~~~~ Generate a random ISBN13. Can be validated using `isbn-checker`_. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_isbn13 :emphasize-lines: 3 from fake import FAKER FAKER.isbn13() ---- iban ~~~~ Generate a random IBAN. Can be validated using `iban-calculator`_. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_iban :emphasize-lines: 3 from fake import FAKER FAKER.iban() ---- random_choice ~~~~~~~~~~~~~ Picks a random element from the sequence given. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_random_choice :emphasize-lines: 3 from fake import FAKER FAKER.random_choice(("Art", "Photography", "Generative AI")) ---- random_sample ~~~~~~~~~~~~~ Picks a given number of random elements from the sequence given. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_random_sample :emphasize-lines: 3 from fake import FAKER FAKER.random_sample(("Art", "Photography", "Generative AI"), 2) ---- randomise_string ~~~~~~~~~~~~~~~~ Replaces placeholders in a given string with random letters and digits. - Placeholders ``?`` are replaced by random uppercase letters. - Placeholders ``#`` are replaced by random digits. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_randomise_string :emphasize-lines: 3 from fake import FAKER FAKER.randomise_string("???? ##") ---- Optional arguments: - ``letters`` (type: ``str``, default value: ``string.ascii_uppercase``). - ``digits`` (type: ``str``, default value: ``string.digits``). Example with arguments. .. container:: jsphinx-toggle-emphasis .. code-block:: python :name: test_randomise_string_custom_args :emphasize-lines: 1, 3- import string from fake import FAKER FAKER.randomise_string( "???? ##", letters=string.ascii_letters, # Use both upper- and lower-case digits="123456789", # Exclude 0 ) Sample output: .. code-block:: text 1234 Aa ---- .. raw:: html   fake.py-0.11.9/docs/requirements.txt000066400000000000000000000113261510566137200173640ustar00rootroot00000000000000# This file was autogenerated by uv via the following command: # uv pip compile --all-extras -o docs/requirements.txt pyproject.toml alabaster==0.7.16 # via sphinx anyio==4.9.0 # via # starlette # watchfiles asgiref==3.8.1 # via django asttokens==3.0.0 # via stack-data babel==2.17.0 # via sphinx build==1.2.2.post1 # via fake-py (pyproject.toml) certifi==2025.4.26 # via requests cffi==1.17.1 # via cryptography charset-normalizer==3.4.2 # via requests click==8.1.8 # via # pydoclint # uvicorn colorama==0.4.6 # via sphinx-autobuild coverage==7.8.0 # via pytest-cov cryptography==44.0.3 # via secretstorage decorator==5.2.1 # via ipython detect-secrets==1.5.0 # via fake-py (pyproject.toml) django==5.2.1 # via fake-py (pyproject.toml) doc8==1.1.2 # via fake-py (pyproject.toml) docstring-parser-fork==0.0.12 # via pydoclint docutils==0.19 # via # doc8 # readme-renderer # restructuredtext-lint # sphinx # sphinx-no-pragma # sphinx-rtd-theme executing==2.2.0 # via stack-data h11==0.16.0 # via uvicorn id==1.5.0 # via twine idna==3.10 # via # anyio # requests imagesize==1.4.1 # via sphinx iniconfig==2.1.0 # via pytest ipython==9.2.0 # via fake-py (pyproject.toml) ipython-pygments-lexers==1.1.1 # via ipython jaraco-classes==3.4.0 # via keyring jaraco-context==6.0.1 # via keyring jaraco-functools==4.1.0 # via keyring jedi==0.19.2 # via ipython jeepney==0.9.0 # via # keyring # secretstorage jinja2==3.1.6 # via sphinx keyring==25.6.0 # via twine markdown-it-py==3.0.0 # via rich markupsafe==3.0.2 # via jinja2 matplotlib-inline==0.1.7 # via ipython mdurl==0.1.2 # via markdown-it-py more-itertools==10.7.0 # via # jaraco-classes # jaraco-functools mypy==1.15.0 # via fake-py (pyproject.toml) mypy-extensions==1.1.0 # via mypy nh3==0.2.21 # via readme-renderer packaging==25.0 # via # build # pytest # sphinx # twine parso==0.8.4 # via jedi pbr==6.1.1 # via stevedore pexpect==4.9.0 # via ipython pkginfo==1.12.1.2 # via fake-py (pyproject.toml) pluggy==1.5.0 # via pytest prompt-toolkit==3.0.51 # via ipython ptyprocess==0.7.0 # via pexpect pure-eval==0.2.3 # via stack-data pycparser==2.22 # via cffi pydoclint==0.6.6 # via fake-py (pyproject.toml) pygments==2.19.1 # via # doc8 # ipython # ipython-pygments-lexers # readme-renderer # rich # sphinx pyproject-hooks==1.2.0 # via build pytest==8.3.5 # via # fake-py (pyproject.toml) # pytest-codeblock # pytest-cov # pytest-django pytest-codeblock==0.1.7 # via fake-py (pyproject.toml) pytest-cov==6.1.1 # via fake-py (pyproject.toml) pytest-django==4.11.1 # via fake-py (pyproject.toml) pyyaml==6.0.2 # via detect-secrets readme-renderer==43.0 # via twine requests==2.32.3 # via # detect-secrets # id # requests-toolbelt # sphinx # twine requests-toolbelt==1.0.0 # via twine restructuredtext-lint==1.4.0 # via doc8 rfc3986==2.0.0 # via twine rich==14.0.0 # via twine ruff==0.11.9 # via fake-py (pyproject.toml) secretstorage==3.3.3 # via keyring setuptools==80.4.0 # via pbr sniffio==1.3.1 # via anyio snowballstemmer==3.0.1 # via sphinx sphinx==5.3.0 # via # fake-py (pyproject.toml) # sphinx-autobuild # sphinx-no-pragma # sphinx-rtd-theme # sphinxcontrib-jquery sphinx-autobuild==2024.10.3 # via fake-py (pyproject.toml) sphinx-no-pragma==0.1.2 # via fake-py (pyproject.toml) sphinx-rtd-theme==2.0.0 # via fake-py (pyproject.toml) sphinxcontrib-applehelp==2.0.0 # via sphinx sphinxcontrib-devhelp==2.0.0 # via sphinx sphinxcontrib-htmlhelp==2.1.0 # via sphinx sphinxcontrib-jquery==4.1 # via sphinx-rtd-theme sphinxcontrib-jsmath==1.0.1 # via sphinx sphinxcontrib-qthelp==2.0.0 # via sphinx sphinxcontrib-serializinghtml==2.0.0 # via sphinx sqlparse==0.5.3 # via django stack-data==0.6.3 # via ipython starlette==0.46.2 # via sphinx-autobuild stevedore==5.4.1 # via doc8 traitlets==5.14.3 # via # ipython # matplotlib-inline twine==6.1.0 # via fake-py (pyproject.toml) typing-extensions==4.13.2 # via # anyio # mypy urllib3==2.4.0 # via # requests # twine uv==0.7.3 # via fake-py (pyproject.toml) uvicorn==0.34.2 # via sphinx-autobuild watchfiles==1.0.5 # via sphinx-autobuild wcwidth==0.2.13 # via prompt-toolkit websockets==15.0.1 # via sphinx-autobuild wheel==0.45.1 # via fake-py (pyproject.toml) fake.py-0.11.9/docs/security.rst000066400000000000000000000000351510566137200164740ustar00rootroot00000000000000.. include:: ../SECURITY.rst fake.py-0.11.9/docs/test_configuration_tweaks.rst000066400000000000000000000006431510566137200221160ustar00rootroot00000000000000Test/coverage configuration tweaks ================================== If you decide to include ``fake.py`` into your code/package, the easiest way to get the ``fake.py`` tests running is to create a sibling module named ``test_fake.py`` in the same directory where the ``fake.py`` is, with the following content: *Filename: test_fake.py* .. code-block:: python :name: test_fakepy from fake import * # noqa fake.py-0.11.9/examples/000077500000000000000000000000001510566137200147635ustar00rootroot00000000000000fake.py-0.11.9/examples/README.rst000066400000000000000000000005451510566137200164560ustar00rootroot00000000000000fake.py examples ================ - `Customisation `_. - `Dataclasses `_. - `Django `_. - `Hypothesis `_. - `Lazy/Fuzzy `_. - `Pydantic `_. - `SQLAlchemy `_. - `TortoiseORM `_. fake.py-0.11.9/examples/_pyproject.toml000066400000000000000000000020131510566137200200320ustar00rootroot00000000000000[tool.pytest.ini_options] addopts = [ "-ra", "-vvv", "-q", "--cov=.", "--ignore=.tox", "--ignore=requirements", "--ignore=release", "--ignore=tmp", "--cov-report=html", "--cov-report=term", "--cov-report=annotate", "--cov-append", "--capture=no", ] testpaths = [ "**/test*.py", # matches test*.py in root, band/, address/, or any subdir # "**/*.rst", # matches *.rst (and test*.rst) everywhere ] pythonpath = [ ".", ] [tool.coverage.run] relative_files = true omit = [ ".tox/*", "**/manage.py", "**/test*.py", "**/conftest.py", ] [tool.coverage.report] show_missing = true exclude_lines = [ "pragma: no cover", "@overload", ] [tool.mypy] check_untyped_defs = true warn_unused_ignores = true warn_redundant_casts = true warn_unused_configs = true [tool.pydoclint] style = 'sphinx' exclude = '\.git|\.tox|tests/data|__copy_fake\.py' require-return-section-when-returning-nothing = false allow-init-docstring = true arg-type-hints-in-docstring = false fake.py-0.11.9/examples/customisation/000077500000000000000000000000001510566137200176645ustar00rootroot00000000000000fake.py-0.11.9/examples/customisation/README.rst000066400000000000000000000004761510566137200213620ustar00rootroot00000000000000Customisation ============= Various customisation examples: - Address provider implementation. - Band provider implementation. - Replace built-in fake data corpus/vocabulary with a custom one. - Override default data. Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/customisation/__init__.py000066400000000000000000000000001510566137200217630ustar00rootroot00000000000000fake.py-0.11.9/examples/customisation/address/000077500000000000000000000000001510566137200213115ustar00rootroot00000000000000fake.py-0.11.9/examples/customisation/address/__init__.py000066400000000000000000000000001510566137200234100ustar00rootroot00000000000000fake.py-0.11.9/examples/customisation/address/factories.py000066400000000000000000000027061510566137200236470ustar00rootroot00000000000000from fake import ModelFactory, SubFactory, post_save, pre_save from address.models import Address, Person from fake_address import FACTORY as ADDRESS_FACTORY from override_default_data import FACTORY as OVERRIDE_DEFAULT_DATA_FACTORY __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "AddressFactory", "PersonFactory", ) class AddressFactory(ModelFactory): id = ADDRESS_FACTORY.pyint() address_line = ADDRESS_FACTORY.address_line() postal_code = ADDRESS_FACTORY.postal_code() city = ADDRESS_FACTORY.city() region = ADDRESS_FACTORY.region() class Meta: model = Address @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True class PersonFactory(ModelFactory): id = OVERRIDE_DEFAULT_DATA_FACTORY.pyint() first_name = OVERRIDE_DEFAULT_DATA_FACTORY.first_name() last_name = OVERRIDE_DEFAULT_DATA_FACTORY.last_name() email = OVERRIDE_DEFAULT_DATA_FACTORY.email() dob = OVERRIDE_DEFAULT_DATA_FACTORY.date() address = SubFactory(AddressFactory) class Meta: model = Person @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True fake.py-0.11.9/examples/customisation/address/models.py000066400000000000000000000011231510566137200231430ustar00rootroot00000000000000from dataclasses import dataclass from datetime import date __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "Address", "Person", ) @dataclass class Address: id: int address_line: str postal_code: str city: str region: str def __str__(self) -> str: return self.address_line @dataclass class Person: id: int first_name: str last_name: str email: str dob: date address: Address def __str__(self) -> str: return self.username fake.py-0.11.9/examples/customisation/address/tests.py000066400000000000000000000031051510566137200230240ustar00rootroot00000000000000import unittest from fake import FILE_REGISTRY from address.factories import AddressFactory, PersonFactory from address.models import Address, Person from data import CITIES, REGIONS __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("AddressFakerTestCase",) class AddressFakerTestCase(unittest.TestCase): def tearDown(self): FILE_REGISTRY.clean_up() def test_sub_factory(self) -> None: person = PersonFactory() # Testing SubFactory self.assertIsInstance(person.address, Address) self.assertIsInstance(person.address.id, int) # Testing Factory self.assertIsInstance(person.id, int) # Testing hooks self.assertTrue( hasattr(person, "_pre_save_called") and person._pre_save_called ) self.assertTrue( hasattr(person, "_post_save_called") and person._post_save_called ) self.assertTrue( hasattr(person.address, "_pre_save_called") and person.address._pre_save_called ) self.assertTrue( hasattr(person.address, "_post_save_called") and person.address._post_save_called ) # Testing batch creation persons = PersonFactory.create_batch(5) self.assertEqual(len(persons), 5) self.assertIsInstance(persons[0], Person) # Testing custom addresses address = AddressFactory() self.assertIn(address.city, CITIES) self.assertIn(address.region, REGIONS) fake.py-0.11.9/examples/customisation/address_cli.py000066400000000000000000000002401510566137200225060ustar00rootroot00000000000000from fake import CLI from fake_address import FAKER def main(): cli = CLI(faker=FAKER) cli.execute_command() if __name__ == "__main__": main() fake.py-0.11.9/examples/customisation/band/000077500000000000000000000000001510566137200205705ustar00rootroot00000000000000fake.py-0.11.9/examples/customisation/band/__init__.py000066400000000000000000000000001510566137200226670ustar00rootroot00000000000000fake.py-0.11.9/examples/customisation/band/factories.py000066400000000000000000000006271510566137200231260ustar00rootroot00000000000000from fake import ModelFactory from band.models import Band from fake_band import FACTORY __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("BandFactory",) class BandFactory(ModelFactory): id = FACTORY.pyint() name = FACTORY.band_name() class Meta: model = Band get_or_create = ("name",) fake.py-0.11.9/examples/customisation/band/models.py000066400000000000000000000004501510566137200224240ustar00rootroot00000000000000from dataclasses import dataclass __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("Band",) @dataclass class Band: id: int name: str def __str__(self) -> str: return self.address_line fake.py-0.11.9/examples/customisation/band/tests.py000066400000000000000000000013331510566137200223040ustar00rootroot00000000000000import unittest from fake import FILE_REGISTRY from band.factories import BandFactory from band.models import Band __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("BandFakerTestCase",) class BandFakerTestCase(unittest.TestCase): def tearDown(self): FILE_REGISTRY.clean_up() def test_sub_factory(self) -> None: band = BandFactory() # Testing Factory self.assertIsInstance(band.id, int) self.assertIsInstance(band.name, str) # Testing batch creation bands = BandFactory.create_batch(5) self.assertEqual(len(bands), 5) self.assertIsInstance(bands[0], Band) fake.py-0.11.9/examples/customisation/band_cli.py000066400000000000000000000002351510566137200217710ustar00rootroot00000000000000from fake import CLI from fake_band import FAKER def main(): cli = CLI(faker=FAKER) cli.execute_command() if __name__ == "__main__": main() fake.py-0.11.9/examples/customisation/custom_data_cli.py000066400000000000000000000002511510566137200233660ustar00rootroot00000000000000from fake import CLI from override_default_data import FAKER def main(): cli = CLI(faker=FAKER) cli.execute_command() if __name__ == "__main__": main() fake.py-0.11.9/examples/customisation/data.py000066400000000000000000000103101510566137200211420ustar00rootroot00000000000000__author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "FIRST_NAMES", "LAST_NAMES", "WORDS", "STREET_NAMES", "CITIES", "REGIONS", ) # Custom first names dictionary FIRST_NAMES = [ "Anahit", "Ani", "Aram", "Areg", "Artur", "Astghik", "Atom", "Barsegh", "Gaiane", "Gor", "Hakob", "Hasmik", "Levon", "Lilit", "Mariam", "Nare", "Narek", "Nune", "Raffi", "Shant", "Tatev", "Tigran", "Vahan", "Vardan", ] # Custom last names dictionary LAST_NAMES = [ "Amatouni", "Avagyan", "Danielyan", "Egoyan", "Gevorgyan", "Gnouni", "Grigoryan", "Hakobyan", "Harutyunyan", "Hovhannisyan", "Karapetyan", "Khachatryan", "Manukyan", "Ter-Martirosyan", "Melikyan", "Mkrtchyan", "Petrosyan", "Saroyan", "Sahakyants", "Sargsyan", "Sedrakyan", "Simonyan", "Stepanyan", "Vardanyan", ] # Custom words dictionary WORDS = [ "time", "person", "year", "way", "day", "thing", "man", "world", "life", "hand", "part", "child", "eye", "woman", "place", "work", "week", "case", "point", "government", "company", "number", "group", "problem", "fact", "be", "have", "do", "say", "get", "make", "go", "know", "take", "see", "come", "think", "look", "want", "give", "use", "find", "tell", "ask", "work", "seem", "feel", "try", "leave", "call", "good", "new", "first", "last", "long", "great", "little", "own", "other", "old", "right", "big", "high", "different", "small", "large", "next", "early", "young", "important", "few", "public", "bad", "same", "able", "to", "of", "in", "for", "on", "with", "as", "at", "by", "from", "up", "about", "into", "over", "after", "beneath", "under", "above", "the", "and", "a", "that", "I", "it", "not", ] STREET_NAMES = [ "Oranjestraat", "Groningerweg", "Prinsengracht", "Keizersgracht", "Herengracht", "Singel", "Zuidstraat", "Noordstraat", "Ooststraat", "Weststraat", "Nieuweweg", "Oudeweg", "Parklaan", "Beukenweg", "Dorpsstraat", "Kerkstraat", "Molenstraat", "Schoolstraat", "Stationsstraat", "Bloemenstraat", "Bosweg", "Duinweg", "Gracht", "Havenstraat", "Hoogstraat", "Kanaalstraat", "Kastanjelaan", "Lindelaan", "Marktstraat", "Meidoornstraat", "Plataanstraat", "Populierenlaan", "Ringweg", "Rivierenlaan", "Sparrenlaan", "Sportlaan", "Tuinstraat", "Vijverlaan", "Wilgenweg", "Zonnelaan", "Acacialaan", "Berkenweg", "Cederstraat", "Dennenlaan", "Esdoornstraat", "Hazelaarstraat", "Iepenlaan", "Jasmijnstraat", "Kamperfoeliestraat", "Larixlaan", ] CITIES = [ "Amsterdam", "Rotterdam", "Den Haag", "Utrecht", "Eindhoven", "Tilburg", "Groningen", "Almere", "Breda", "Nijmegen", "Enschede", "Haarlem", "Arnhem", "Zaanstad", "Amersfoort", "Apeldoorn", "Hoofddorp", "Maastricht", "Leiden", "Dordrecht", "Zoetermeer", "Zwolle", "Deventer", "Born", "Delft", "Alkmaar", "Heerlen", "Venlo", "Leeuwarden", "Hilversum", "Hengelo", "Amstelveen", "Roosendaal", "Purmerend", "Oss", "Schiedam", "Spijkenisse", "Helmond", "Vlaardingen", "Almelo", "Gouda", "Zaandam", "Lelystad", "Alphen aan den Rijn", "Hoorn", "Velsen", "Ede", "Bergen op Zoom", "Capelle aan den IJssel", "Assen", ] REGIONS = [ "Drenthe", "Flevoland", "Friesland", "Gelderland", "Groningen", "Limburg", "Noord-Brabant", "Noord-Holland", "Overijssel", "Utrecht", "Zeeland", "Zuid-Holland", ] fake.py-0.11.9/examples/customisation/fake_address.py000066400000000000000000000030461510566137200226540ustar00rootroot00000000000000import random import string from fake import Factory, Faker, provider from data import CITIES, REGIONS, STREET_NAMES __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "FACTORY", "FAKER", ) class FakerAddress(Faker): """Custom Faker class for addresses.""" @provider def address_line(self) -> str: """Generate a random Dutch address line like 'Oranjestraat 1'. :return: A randomly generated Dutch address line as a string. :rtype: str """ # Generate components of the address street = random.choice(STREET_NAMES) house_number = random.randint(1, 200) suffixes = [""] * 10 + ["A", "B", "C"] # Optional suffixes suffix = random.choice(suffixes) # Combine components into a Dutch address format return f"{street} {house_number}{suffix}" @provider def city(self) -> str: return random.choice(CITIES) @provider def region(self) -> str: return random.choice(REGIONS) @provider def postal_code(self) -> str: """Generate a random Dutch postal code in the format '1234 AB'. :return: A randomly generated Dutch postal code as a string. :rtype: 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 = FakerAddress(alias="address") FACTORY = Factory(FAKER) fake.py-0.11.9/examples/customisation/fake_band.py000066400000000000000000000021761510566137200221360ustar00rootroot00000000000000import random from fake import Factory, Faker, provider __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "FACTORY", "FAKER", ) BANDS = [ "Aerosmith", "Agata Kristi", "Anathema", "Bjork", "Black Sabbath", "Blonde Redhead", "Cocteau Twins", "Comus", "Dead Can Dance", "Depeche Mode", "Focus", "Kalinov Most", "Kate Bush", "King Crimson", "Kolibri", "Lais", "Led Zeppelin", "Linda", "Nirvana", "Nor Dar", "Oasis", "Opeth", "Pink Floyd", "Portishead", "Radiohead", "Red Hot Chili Peppers", "Sinead O'Connor", "Siouxsie and the Banshees", "System of a Down", "The Beatles", "The Cranberries", "The Cure", "The Rolling Stones", "The Velvet Underground", "Tiamat", "Van der Graaf Generator", "Yes", ] class FakerBand(Faker): """Custom Faker class for bands.""" @provider def band_name(self) -> str: return random.choice(BANDS) FAKER = FakerBand(alias="band") FACTORY = Factory(FAKER) fake.py-0.11.9/examples/customisation/manage.py000066400000000000000000000016731510566137200214750ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython def run_tests(): """Function to run tests in the customisation directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir="./", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) def main(): """Run administrative tasks based on command line arguments.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/customisation/override_default_data.py000066400000000000000000000013241510566137200245520ustar00rootroot00000000000000from fake import Factory, Faker from data import FIRST_NAMES, LAST_NAMES, WORDS __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "FACTORY", "FAKER", ) class FakerOverrideDefaultData(Faker): """Faker class for custom names and words.""" def load_names(self) -> None: """Override default first- and last-names dictionaries.""" self._first_names = FIRST_NAMES self._last_names = LAST_NAMES def load_words(self) -> None: """Override default words dictionary.""" self._words = WORDS FAKER = FakerOverrideDefaultData(alias="override_default_data") FACTORY = Factory(FAKER) fake.py-0.11.9/examples/customisation/pyproject.toml000077700000000000000000000000001510566137200260612../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/dataclasses/000077500000000000000000000000001510566137200172525ustar00rootroot00000000000000fake.py-0.11.9/examples/dataclasses/README.rst000066400000000000000000000003461510566137200207440ustar00rootroot00000000000000Dataclasses =========== Example factories for models based on `dataclasses `_. Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/dataclasses/article/000077500000000000000000000000001510566137200206755ustar00rootroot00000000000000fake.py-0.11.9/examples/dataclasses/article/__init__.py000066400000000000000000000000001510566137200227740ustar00rootroot00000000000000fake.py-0.11.9/examples/dataclasses/article/factories.py000066400000000000000000000074171510566137200232370ustar00rootroot00000000000000from pathlib import Path from typing import Any, Dict from fake import ( FACTORY, FAKER, FileSystemStorage, ModelFactory, PostSave, PreInit, PreSave, SubFactory, post_save, pre_init, pre_save, slugify, trait, ) from article.models import Article, Group, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "ArticleFactory", "GroupFactory", "UserFactory", ) # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent MEDIA_ROOT = BASE_DIR / "media" STORAGE = FileSystemStorage(root_path=MEDIA_ROOT, rel_path="tmp") CATEGORIES = ( "art", "technology", "literature", ) TAGS = ( "painting", "photography", "ai", "data-engineering", "fiction", "poetry", "manual", ) class GroupFactory(ModelFactory): id = FACTORY.pyint() name = FACTORY.word() class Meta: model = Group get_or_create = ("name",) def set_password(user: User, password: str) -> None: user.set_password(password) def add_to_group(user: User, name: str) -> None: group = GroupFactory(name=name) user.groups.add(group) def set_username(data: Dict[str, Any]) -> None: first_name = slugify(data["first_name"]) last_name = slugify(data["last_name"]) data["username"] = f"{first_name}_{last_name}_{FAKER.pystr().lower()}" class UserFactory(ModelFactory): id = FACTORY.pyint() # type: ignore username = PreInit(set_username) # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = FACTORY.email() # type: ignore date_joined = FACTORY.date_time() # type: ignore last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore password = PreSave(set_password, password="test1234") # type: ignore group = PostSave(add_to_group, name="TestGroup1234") # type: ignore class Meta: model = User @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True def set_headline(data: Dict[str, Any]) -> None: data["headline"] = data["content"][:25] class ArticleFactory(ModelFactory): id = FACTORY.pyint() # type: ignore title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = PreInit(set_headline) category = FACTORY.random_choice(elements=CATEGORIES) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore image = FACTORY.png_file(storage=STORAGE) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint(min_value=1, max_value=10) # type: ignore author = SubFactory(UserFactory) tags = FACTORY.random_sample(elements=TAGS, length=3) class Meta: model = Article @pre_init def set_auto_minutes_to_read(self, data: Dict[str, Any]) -> None: data["auto_minutes_to_read"] = data["pages"] @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True fake.py-0.11.9/examples/dataclasses/article/models.py000066400000000000000000000026071510566137200225370ustar00rootroot00000000000000from dataclasses import dataclass, field from datetime import date, datetime from typing import List, Optional, Set from fake import xor_transform __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "Article", "Group", "User", ) @dataclass(frozen=True) class Group: id: int name: str @dataclass class User: id: int username: str first_name: str last_name: str email: str date_joined: datetime = field(default_factory=datetime.utcnow) last_login: Optional[datetime] = None password: Optional[str] = None is_superuser: bool = False is_staff: bool = False is_active: bool = True groups: Set[Group] = field(default_factory=set) def __str__(self): return self.username def set_password(self, password: str) -> None: self.password = xor_transform(password) @dataclass class Article: id: int title: str slug: str content: str headline: str category: str pages: int auto_minutes_to_read: int author: User image: Optional[str] = None # Use str to represent the image path or URL pub_date: date = field(default_factory=date.today) safe_for_work: bool = False minutes_to_read: int = 5 tags: List[str] = field(default_factory=list) def __str__(self): return self.title fake.py-0.11.9/examples/dataclasses/article/tests.py000066400000000000000000000042641510566137200224170ustar00rootroot00000000000000import unittest from datetime import datetime from fake import FILE_REGISTRY, xor_transform from article.factories import ArticleFactory, GroupFactory, UserFactory from article.models import Article, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("FactoriesTestCase",) class FactoriesTestCase(unittest.TestCase): def tearDown(self): FILE_REGISTRY.clean_up() def test_sub_factory(self) -> None: article = ArticleFactory() # Testing SubFactory self.assertIsInstance(article.author, User) self.assertIsInstance(article.author.id, int) self.assertIsInstance(article.author.is_staff, bool) self.assertIsInstance(article.author.date_joined, datetime) # Testing Factory self.assertIsInstance(article.id, int) self.assertIsInstance(article.slug, str) # Testing hooks self.assertTrue( hasattr(article, "_pre_save_called") and article._pre_save_called ) self.assertTrue( hasattr(article, "_post_save_called") and article._post_save_called ) self.assertTrue( hasattr(article.author, "_pre_save_called") and article.author._pre_save_called ) self.assertTrue( hasattr(article.author, "_post_save_called") and article.author._post_save_called ) # Testing batch creation articles = ArticleFactory.create_batch(5) self.assertEqual(len(articles), 5) self.assertIsInstance(articles[0], Article) def test_pre_save_and_post_save(self) -> None: """Test PreSave and PostSave.""" user = UserFactory(is_staff=True) self.assertEqual( xor_transform(user.password), "test1234", ) self.assertEqual(list(user.groups)[0].name, "TestGroup1234") def test_group_factory(self): group = GroupFactory() assert group.name def test_user_factory(self): user = UserFactory() assert user.id def test_article_factory(self): article = ArticleFactory() assert article.id fake.py-0.11.9/examples/dataclasses/manage.py000077500000000000000000000016741510566137200210670ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython def run_tests(): """Function to run tests in the article directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir="./article", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) def main(): """Run administrative tasks based on command line arguments.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/dataclasses/pyproject.toml000077700000000000000000000000001510566137200254472../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/django/000077500000000000000000000000001510566137200162255ustar00rootroot00000000000000fake.py-0.11.9/examples/django/README.rst000066400000000000000000000004141510566137200177130ustar00rootroot00000000000000Django ====== Example factories for `Django `_ models. Installation ------------ .. code-block:: sh pip install -r requirements.in Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/django/article/000077500000000000000000000000001510566137200176505ustar00rootroot00000000000000fake.py-0.11.9/examples/django/article/__init__.py000066400000000000000000000000001510566137200217470ustar00rootroot00000000000000fake.py-0.11.9/examples/django/article/admin.py000066400000000000000000000004571510566137200213200ustar00rootroot00000000000000from django.contrib import admin from article.models import Article @admin.register(Article) class ArticleAdmin(admin.ModelAdmin): list_display = ( "title", "slug", "minutes_to_read", "safe_for_work", "pub_date", ) list_filter = ("safe_for_work",) fake.py-0.11.9/examples/django/article/apps.py000066400000000000000000000002221510566137200211610ustar00rootroot00000000000000from django.apps import AppConfig class ArticleConfig(AppConfig): default_auto_field = "django.db.models.BigAutoField" name = "article" fake.py-0.11.9/examples/django/article/factories.py000066400000000000000000000123131510566137200222010ustar00rootroot00000000000000from typing import Any, Dict from django.conf import settings from django.contrib.auth.models import ( Group, User, ) from django.utils import timezone from django.utils.text import slugify from fake import ( FACTORY, FAKER, DjangoModelFactory, FileSystemStorage, PostSave, PreInit, PreSave, SubFactory, post_save, pre_init, pre_save, trait, ) from article.models import Article __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "ArticleFactory", "GroupFactory", "UserFactory", ) # For Django, all files shall be placed inside `MEDIA_ROOT` directory. # That's why you need to apply this trick - define a # custom `FileSystemStorage` class and pass it to the file factory as # `storage` argument. STORAGE = FileSystemStorage(root_path=settings.MEDIA_ROOT, rel_path="tmp") CATEGORIES = ( "art", "technology", "literature", ) TAGS = ( "painting", "photography", "ai", "data-engineering", "fiction", "poetry", "manual", ) class GroupFactory(DjangoModelFactory): """Group factory. Usage example: .. code-block:: python group = GroupFactory() """ name = FACTORY.word() class Meta: model = Group get_or_create = ("name",) def set_password(user: User, password: str) -> None: user.set_password(password) def add_to_group(user: User, name: str) -> None: group = GroupFactory(name=name) user.groups.add(group) def set_username(data: Dict[str, Any]) -> None: first_name = slugify(data["first_name"]) last_name = slugify(data["last_name"]) data["username"] = f"{first_name}_{last_name}_{FAKER.pystr().lower()}" class UserFactory(DjangoModelFactory): """User factory. Usage example: .. code-block:: python # Create a user. Created user will automatically have his password # set to "test1234" and will be added to the group "Test group". user = UserFactory() # Create 5 users. users = UserFactory.create_batch(5) # Create a user with custom password user = UserFactory( password=PreSave(set_password, password="another-pass"), ) # 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"), ) """ username = PreInit(set_username) first_name = FACTORY.first_name() last_name = FACTORY.last_name() email = FACTORY.email() date_joined = FACTORY.date_time(tzinfo=timezone.get_current_timezone()) last_login = FACTORY.date_time(tzinfo=timezone.get_current_timezone()) is_superuser = False is_staff = False is_active = FACTORY.pybool() password = PreSave(set_password, password="test1234") group = PostSave(add_to_group, name="TestGroup1234") class Meta: model = User get_or_create = ("username",) @post_save def send_registration_email(self, instance): """Send an email with registration information.""" # Your code here @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True def set_headline(data: Dict[str, Any]) -> None: data["headline"] = data["content"][:25] class ArticleFactory(DjangoModelFactory): """Article factory. Usage example: .. code-block:: python # Create one article article = ArticleFactory() # Create 5 articles articles = ArticleFactory.create_batch(5) # Create one article with authors username set to admin. article = ArticleFactory(author__username="admin") """ title = FACTORY.sentence() slug = FACTORY.slug() content = FACTORY.text() headline = PreInit(set_headline) category = FACTORY.random_choice(elements=CATEGORIES) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore image = FACTORY.png_file(storage=STORAGE) pub_date = FACTORY.date(tzinfo=timezone.get_current_timezone()) safe_for_work = FACTORY.pybool() minutes_to_read = FACTORY.pyint(min_value=1, max_value=10) author = SubFactory(UserFactory) tags = FACTORY.random_sample(elements=TAGS, length=3) class Meta: model = Article @pre_init def set_auto_minutes_to_read(self, data: Dict[str, Any]) -> None: data["auto_minutes_to_read"] = data["pages"] @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True fake.py-0.11.9/examples/django/article/migrations/000077500000000000000000000000001510566137200220245ustar00rootroot00000000000000fake.py-0.11.9/examples/django/article/migrations/0001_initial.py000066400000000000000000000035531510566137200244750ustar00rootroot00000000000000# Generated by Django 5.0.6 on 2024-06-07 23:44 import django.db.models.deletion import django.utils.timezone from django.conf import settings from django.db import migrations, models class Migration(migrations.Migration): initial = True dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name="Article", fields=[ ( "id", models.BigAutoField( auto_created=True, primary_key=True, serialize=False, verbose_name="ID", ), ), ("title", models.CharField(max_length=255)), ("slug", models.SlugField(unique=True)), ("content", models.TextField()), ("headline", models.TextField()), ("category", models.CharField(max_length=255)), ("pages", models.IntegerField()), ("auto_minutes_to_read", models.IntegerField()), ( "image", models.ImageField(blank=True, null=True, upload_to=""), ), ( "pub_date", models.DateField(default=django.utils.timezone.now), ), ("safe_for_work", models.BooleanField(default=False)), ("minutes_to_read", models.IntegerField(default=5)), ("tags", models.JSONField(default=list)), ( "author", models.ForeignKey( on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL, ), ), ], ), ] fake.py-0.11.9/examples/django/article/migrations/__init__.py000066400000000000000000000000001510566137200241230ustar00rootroot00000000000000fake.py-0.11.9/examples/django/article/models.py000066400000000000000000000017051510566137200215100ustar00rootroot00000000000000from django.conf import settings from django.db import models from django.utils import timezone __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("Article",) class Article(models.Model): title = models.CharField(max_length=255) slug = models.SlugField(unique=True) content = models.TextField() headline = models.TextField() category = models.CharField(max_length=255) pages = models.IntegerField() auto_minutes_to_read = models.IntegerField() image = models.ImageField(null=True, blank=True) pub_date = models.DateField(default=timezone.now) safe_for_work = models.BooleanField(default=False) minutes_to_read = models.IntegerField(default=5) author = models.ForeignKey( settings.AUTH_USER_MODEL, on_delete=models.CASCADE ) tags = models.JSONField(default=list) def __str__(self): return self.title fake.py-0.11.9/examples/django/article/tests.py000066400000000000000000000070471510566137200213740ustar00rootroot00000000000000from datetime import datetime from django.contrib.auth.models import User from django.test import TestCase from fake import FILE_REGISTRY from article.factories import ArticleFactory, GroupFactory, UserFactory from article.models import Article __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("FactoriesTestCase",) class FactoriesTestCase(TestCase): def tearDown(self): super().tearDown() FILE_REGISTRY.clean_up() def test_sub_factory(self) -> None: article = ArticleFactory() # Testing SubFactory self.assertIsInstance(article.author, User) self.assertIsInstance(article.author.id, int) self.assertIsInstance(article.author.is_staff, bool) self.assertIsInstance(article.author.date_joined, datetime) # Testing Factory self.assertIsInstance(article.id, int) self.assertIsInstance(article.slug, str) # Testing hooks self.assertTrue( hasattr(article, "_pre_save_called") and article._pre_save_called ) self.assertTrue( hasattr(article, "_post_save_called") and article._post_save_called ) self.assertTrue( hasattr(article.author, "_pre_save_called") and article.author._pre_save_called ) self.assertTrue( hasattr(article.author, "_post_save_called") and article.author._post_save_called ) # Testing batch creation articles = ArticleFactory.create_batch(5) self.assertEqual(len(articles), 5) self.assertIsInstance(articles[0], Article) def test_sub_factory_nested(self) -> None: article = ArticleFactory(author__username="admin") # Testing SubFactory self.assertIsInstance(article.author, User) self.assertIsInstance(article.author.id, int) self.assertIsInstance(article.author.is_staff, bool) self.assertIsInstance(article.author.date_joined, datetime) self.assertEqual(article.author.username, "admin") # Testing Factory self.assertIsInstance(article.id, int) self.assertIsInstance(article.slug, str) # Testing hooks self.assertTrue( hasattr(article, "_pre_save_called") and article._pre_save_called ) self.assertTrue( hasattr(article, "_post_save_called") and article._post_save_called ) self.assertTrue( hasattr(article.author, "_pre_save_called") and article.author._pre_save_called ) self.assertTrue( hasattr(article.author, "_post_save_called") and article.author._post_save_called ) # Testing batch creation articles = ArticleFactory.create_batch(5) self.assertEqual(len(articles), 5) self.assertIsInstance(articles[0], Article) def test_pre_save_and_post_save(self) -> None: """Test PreSave and PostSave.""" user = UserFactory(is_staff=True, is_active=True) self.assertTrue( self.client.login( username=user.username, password="test1234", ) ) self.assertTrue(user.groups.first().name == "TestGroup1234") def test_group_factory(self): group = GroupFactory() assert group.name def test_user_factory(self): user = UserFactory() assert user.id def test_article_factory(self): article = ArticleFactory() assert article.id fake.py-0.11.9/examples/django/blog/000077500000000000000000000000001510566137200171505ustar00rootroot00000000000000fake.py-0.11.9/examples/django/blog/__init__.py000066400000000000000000000000001510566137200212470ustar00rootroot00000000000000fake.py-0.11.9/examples/django/blog/asgi.py000066400000000000000000000006011510566137200204420ustar00rootroot00000000000000""" ASGI config for blog project. It exposes the ASGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/4.2/howto/deployment/asgi/ """ import os from django.core.asgi import get_asgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "blog.settings") application = get_asgi_application() fake.py-0.11.9/examples/django/blog/settings.py000066400000000000000000000064761510566137200213770ustar00rootroot00000000000000""" Django settings for blog project. Generated by 'django-admin startproject' using Django 4.2.7. For more information on this file, see https://docs.djangoproject.com/en/4.2/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/4.2/ref/settings/ """ from pathlib import Path # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = ( "django-insecure-z0l(xs6*(0#0%zw*r63n-=ywho=yd%4pb$85tb8j6he)7ay0ee" ) # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ "django.contrib.admin", "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.messages", "django.contrib.staticfiles", "article", ] MIDDLEWARE = [ "django.middleware.security.SecurityMiddleware", "django.contrib.sessions.middleware.SessionMiddleware", "django.middleware.common.CommonMiddleware", "django.middleware.csrf.CsrfViewMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.contrib.messages.middleware.MessageMiddleware", "django.middleware.clickjacking.XFrameOptionsMiddleware", ] ROOT_URLCONF = "blog.urls" TEMPLATES = [ { "BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [], "APP_DIRS": True, "OPTIONS": { "context_processors": [ "django.template.context_processors.debug", "django.template.context_processors.request", "django.contrib.auth.context_processors.auth", "django.contrib.messages.context_processors.messages", ], }, }, ] WSGI_APPLICATION = "blog.wsgi.application" # Database # https://docs.djangoproject.com/en/4.2/ref/settings/#databases DATABASES = { "default": { "ENGINE": "django.db.backends.sqlite3", "NAME": BASE_DIR / "django_db.sqlite3", } } # Password validation # https://docs.djangoproject.com/en/4.2/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator", # noqa }, { "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator", # noqa }, { "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator", # noqa }, { "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator", # noqa }, ] # Internationalization # https://docs.djangoproject.com/en/4.2/topics/i18n/ LANGUAGE_CODE = "en-us" TIME_ZONE = "UTC" USE_I18N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/4.2/howto/static-files/ STATIC_URL = "static/" # Default primary key field type # https://docs.djangoproject.com/en/4.2/ref/settings/#default-auto-field DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField" MEDIA_URL = "/media/" STATIC_URL = "/static/" MEDIA_ROOT = BASE_DIR / "media" STATIC_ROOT = BASE_DIR / "static" fake.py-0.11.9/examples/django/blog/urls.py000066400000000000000000000016231510566137200205110ustar00rootroot00000000000000""" URL configuration for blog project. The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/4.2/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: path('', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.urls import include, path 2. Add a URL to urlpatterns: path('blog/', include('blog.urls')) """ from django.conf import settings from django.conf.urls.static import static from django.contrib import admin from django.urls import path urlpatterns = [ path("admin/", admin.site.urls), ] urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) fake.py-0.11.9/examples/django/blog/wsgi.py000066400000000000000000000006011510566137200204700ustar00rootroot00000000000000""" WSGI config for blog project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application os.environ.setdefault("DJANGO_SETTINGS_MODULE", "blog.settings") application = get_wsgi_application() fake.py-0.11.9/examples/django/manage.py000077500000000000000000000013271510566137200200350ustar00rootroot00000000000000#!/usr/bin/env python """Django's command-line utility for administrative tasks.""" import os import sys def main(): """Run administrative tasks.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) os.environ.setdefault("DJANGO_SETTINGS_MODULE", "blog.settings") try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?" ) from exc execute_from_command_line(sys.argv) if __name__ == "__main__": main() fake.py-0.11.9/examples/django/pyproject.toml000066400000000000000000000021541510566137200211430ustar00rootroot00000000000000[tool.pytest.ini_options] addopts = [ "-ra", "-vvv", "-q", "--cov=.", "--ignore=.tox", "--ignore=requirements", "--ignore=release", "--ignore=tmp", "--cov-report=html", "--cov-report=term", "--cov-report=annotate", "--cov-append", "--capture=no", ] testpaths = [ "**/test*.py", # matches test*.py in root, band/, address/, or any subdir # "**/*.rst", # matches *.rst (and test*.rst) everywhere ] pythonpath = [ ".", ] DJANGO_SETTINGS_MODULE = "blog.settings" [tool.coverage.run] relative_files = true omit = [ ".tox/*", "**/manage.py", "**/test*.py", "**/conftest.py", "blog/urls.py", "**/asgi.py", "**/wsgi.py", ] [tool.coverage.report] show_missing = true exclude_lines = [ "pragma: no cover", "@overload", ] [tool.mypy] check_untyped_defs = true warn_unused_ignores = true warn_redundant_casts = true warn_unused_configs = true [tool.pydoclint] style = 'sphinx' exclude = '\.git|\.tox|tests/data|__copy_fake\.py' require-return-section-when-returning-nothing = false allow-init-docstring = true arg-type-hints-in-docstring = false fake.py-0.11.9/examples/django/requirements.in000066400000000000000000000000161510566137200212750ustar00rootroot00000000000000django Pillow fake.py-0.11.9/examples/hypothesis/000077500000000000000000000000001510566137200171625ustar00rootroot00000000000000fake.py-0.11.9/examples/hypothesis/README.rst000066400000000000000000000004251510566137200206520ustar00rootroot00000000000000Hypothesis ========== Additional tests using `hypothesis `_. Installation ------------ .. code-block:: sh pip install -r requirements.in Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/hypothesis/manage.py000066400000000000000000000016641510566137200207730ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython def run_tests(): """Function to run tests in the article directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir=".", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) def main(): """Run administrative tasks based on command line arguments.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/hypothesis/pyproject.toml000077700000000000000000000000001510566137200253572../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/hypothesis/requirements.in000066400000000000000000000000131510566137200222270ustar00rootroot00000000000000hypothesis fake.py-0.11.9/examples/hypothesis/tests.py000066400000000000000000000313601510566137200207010ustar00rootroot00000000000000import string import unittest from decimal import Decimal from fake import FAKER, FILE_REGISTRY, StringValue, slugify from hypothesis import Verbosity, given, settings from hypothesis import strategies as st __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("TestFakerWithHypothesis",) # Enable verbose logging for all tests in the class settings.register_profile("debug", verbosity=Verbosity.verbose) settings.load_profile("debug") class TestFakerWithHypothesis(unittest.TestCase): """Test `fake.Faker` with hypothesis.""" def setUp(self) -> None: self.faker = FAKER def tearDown(self) -> None: FILE_REGISTRY.clean_up() @given(st.text(min_size=5)) def test_slugify(self, value): result = slugify(f"{value}a1") # Check that the result is lowercased self.assertEqual(result, result.lower()) # Check that the result does not contain any punctuation or whitespace for char in string.punctuation + string.whitespace: self.assertNotIn(char, result) # Check that the result is an alpha-numeric string (since all # punctuations and whitespaces are removed) self.assertTrue(result.isalnum()) @given(nb=st.integers(min_value=1, max_value=10)) def test_words(self, nb): words = self.faker.words(nb=nb) self.assertIsInstance(words, list) self.assertEqual(len(words), nb) @given(nb_words=st.integers(min_value=1, max_value=10)) def test_sentence(self, nb_words): sentence = self.faker.sentence(nb_words=nb_words) self.assertIsInstance(sentence, str) self.assertTrue(len(sentence.split()) == nb_words) @given(nb=st.integers(min_value=1, max_value=10)) def test_sentences(self, nb): sentences = self.faker.sentences(nb=nb) self.assertIsInstance(sentences, list) self.assertEqual(len(sentences), nb) @given(nb_sentences=st.integers(min_value=1, max_value=10)) def test_paragraph(self, nb_sentences): paragraph = self.faker.paragraph(nb_sentences=nb_sentences) self.assertIsInstance(paragraph, str) @given(nb=st.integers(min_value=1, max_value=10)) def test_paragraphs(self, nb): paragraphs = self.faker.paragraphs(nb=nb) self.assertIsInstance(paragraphs, list) self.assertEqual(len(paragraphs), nb) @given(nb_chars=st.integers(min_value=1, max_value=1000)) def test_text(self, nb_chars): text = self.faker.text(nb_chars=nb_chars) self.assertIsInstance(text, str) self.assertTrue(len(text) <= nb_chars) @given(nb=st.integers(min_value=1, max_value=10)) def test_texts(self, nb): texts = self.faker.texts(nb=nb) self.assertIsInstance(texts, list) self.assertEqual(len(texts), nb) @given( min_val=st.integers( min_value=-1e10, max_value=1e10, ), max_val=st.integers( min_value=-1e10, max_value=1e10, ), ) def test_pyint(self, min_val, max_val): if min_val > max_val: min_val, max_val = max_val, min_val val = self.faker.pyint(min_value=min_val, max_value=max_val) self.assertIsInstance(val, int) self.assertGreaterEqual(val, min_val) self.assertLessEqual(val, max_val) @given(nb_chars=st.integers(min_value=0, max_value=100)) def test_pystr(self, nb_chars): val = self.faker.pystr(nb_chars=nb_chars) self.assertIsInstance(val, str) self.assertEqual(len(val), nb_chars) @given( length=st.integers(min_value=1, max_value=50), min_lower=st.integers(min_value=0, max_value=5), min_upper=st.integers(min_value=0, max_value=5), min_digits=st.integers(min_value=0, max_value=5), min_special=st.integers(min_value=0, max_value=5), ) def test_password( self, length, min_lower, min_upper, min_digits, min_special, ): sum_req = min_lower + min_upper + min_digits + min_special if length < sum_req: with self.assertRaises(ValueError): self.faker.password( length=length, min_lower=min_lower, min_upper=min_upper, min_digits=min_digits, min_special=min_special, ) else: pwd = self.faker.password( length=length, min_lower=min_lower, min_upper=min_upper, min_digits=min_digits, min_special=min_special, ) self.assertIsInstance(pwd, str) self.assertEqual(len(pwd), length) lowers = sum(c.islower() for c in pwd) uppers = sum(c.isupper() for c in pwd) digits = sum(c.isdigit() for c in pwd) specials = length - (lowers + uppers + digits) self.assertGreaterEqual(lowers, min_lower) self.assertGreaterEqual(uppers, min_upper) self.assertGreaterEqual(digits, min_digits) self.assertGreaterEqual(specials, min_special) @given( min_val=st.floats( min_value=-1e10, max_value=1e10, allow_nan=False, allow_infinity=False, ), max_val=st.floats( min_value=-1e10, max_value=1e10, allow_nan=False, allow_infinity=False, ), ) def test_pyfloat(self, min_val, max_val): if min_val > max_val: min_val, max_val = max_val, min_val val = self.faker.pyfloat(min_value=min_val, max_value=max_val) self.assertIsInstance(val, float) self.assertGreaterEqual(val, min_val) self.assertLessEqual(val, max_val) @given( left_digits=st.integers(min_value=0, max_value=10), right_digits=st.integers(min_value=0, max_value=10), positive=st.booleans(), ) def test_pydecimal(self, left_digits, right_digits, positive): decimal_number = self.faker.pydecimal( left_digits=left_digits, right_digits=right_digits, positive=positive, ) self.assertIsInstance(decimal_number, Decimal) @given(nb_pages=st.integers(min_value=1, max_value=10)) def test_pdf(self, nb_pages): pdf_bytes = self.faker.pdf(nb_pages=nb_pages) self.assertIsInstance(pdf_bytes, bytes) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_png(self, size, color): png_bytes = self.faker.png(size=size, color=color) self.assertIsInstance(png_bytes, bytes) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_svg(self, size, color): svg_bytes = self.faker.svg(size=size, color=color) self.assertIsInstance(svg_bytes, bytes) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_bmp(self, size, color): bmp_bytes = self.faker.svg(size=size, color=color) self.assertIsInstance(bmp_bytes, bytes) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_gif(self, size, color): gif_bytes = self.faker.gif(size=size, color=color) self.assertIsInstance(gif_bytes, bytes) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_tif(self, size, color): tif_bytes = self.faker.tif(size=size, color=color) self.assertIsInstance(tif_bytes, bytes) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_ppm(self, size, color): ppm_bytes = self.faker.ppm(size=size, color=color) self.assertIsInstance(ppm_bytes, bytes) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_jpg(self, size, color): jpg_bytes = self.faker.jpg(size=size, color=color) self.assertIsInstance(jpg_bytes, bytes) @given(nb_pages=st.integers(min_value=1, max_value=10)) def test_docx(self, nb_pages): docx_bytes = self.faker.docx(nb_pages=nb_pages) self.assertIsInstance(docx_bytes, bytes) @given(nb_pages=st.integers(min_value=1, max_value=10)) def test_pdf_file(self, nb_pages): pdf_file = self.faker.pdf_file(nb_pages=nb_pages) self.assertIsInstance(pdf_file, StringValue) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_png_file(self, size, color): png_file = self.faker.png_file(size=size, color=color) self.assertIsInstance(png_file, StringValue) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_svg_file(self, size, color): svg_file = self.faker.svg_file(size=size, color=color) self.assertIsInstance(svg_file, StringValue) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_bmp_file(self, size, color): bmp_file = self.faker.bmp_file(size=size, color=color) self.assertIsInstance(bmp_file, StringValue) @given( size=st.tuples( st.integers(min_value=1, max_value=500), st.integers(min_value=1, max_value=500), ), color=st.tuples( st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), st.integers(min_value=0, max_value=255), ), ) def test_gif_file(self, size, color): gif_file = self.faker.gif_file(size=size, color=color) self.assertIsInstance(gif_file, StringValue) @given(nb_pages=st.integers(min_value=1, max_value=10)) def test_docx_file(self, nb_pages): docx_file = self.faker.docx_file(nb_pages=nb_pages) self.assertIsInstance(docx_file, StringValue) @given(nb_chars=st.integers(min_value=1, max_value=1000)) def test_txt_file(self, nb_chars): txt_file = self.faker.txt_file(nb_chars=nb_chars) self.assertIsInstance(txt_file, StringValue) if __name__ == "__main__": unittest.main() fake.py-0.11.9/examples/lazyfuzzy/000077500000000000000000000000001510566137200170525ustar00rootroot00000000000000fake.py-0.11.9/examples/lazyfuzzy/README.rst000066400000000000000000000004521510566137200205420ustar00rootroot00000000000000Lazy/Fuzzy ========== - A sample ``FuzzyChoice`` alternative implementation based on ``LazyFunction`` and ``functools.partial``. - Various usage examples of ``LazyFunction`` and ``LazyAttribute``. Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/lazyfuzzy/article/000077500000000000000000000000001510566137200204755ustar00rootroot00000000000000fake.py-0.11.9/examples/lazyfuzzy/article/__init__.py000066400000000000000000000000001510566137200225740ustar00rootroot00000000000000fake.py-0.11.9/examples/lazyfuzzy/article/factories.py000066400000000000000000000047241510566137200230350ustar00rootroot00000000000000import random from datetime import datetime from functools import partial from pathlib import Path from fake import ( FACTORY, FileSystemStorage, LazyAttribute, LazyFunction, ModelFactory, SubFactory, post_save, pre_save, trait, ) from article.models import Article, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "ArticleFactory", "UserFactory", ) # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent MEDIA_ROOT = BASE_DIR / "media" STORAGE = FileSystemStorage(root_path=MEDIA_ROOT, rel_path="tmp") CATEGORIES = ( "art", "technology", "literature", ) class UserFactory(ModelFactory): id = FACTORY.pyint() # type: ignore username = FACTORY.username() # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = LazyAttribute(lambda o: f"{o.username}@example.com") last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore date_joined = LazyFunction(datetime.now) class Meta: model = User @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True class ArticleFactory(ModelFactory): id = FACTORY.pyint() # type: ignore title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = LazyAttribute(lambda o: o.content[:25]) category = LazyFunction(partial(random.choice, CATEGORIES)) image = FACTORY.png_file(storage=STORAGE) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint(min_value=1, max_value=10) # type: ignore author = SubFactory(UserFactory) class Meta: model = Article @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True fake.py-0.11.9/examples/lazyfuzzy/article/models.py000066400000000000000000000017251510566137200223370ustar00rootroot00000000000000from dataclasses import dataclass from datetime import date, datetime from typing import Optional __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "Article", "User", ) @dataclass class User: id: int username: str first_name: str last_name: str email: str last_login: Optional[datetime] date_joined: Optional[datetime] password: Optional[str] = None is_superuser: bool = False is_staff: bool = False is_active: bool = True def __str__(self): return self.username @dataclass class Article: id: int title: str slug: str content: str headline: str category: str author: User image: Optional[str] = None # Use str to represent the image path or URL pub_date: date = date.today() safe_for_work: bool = False minutes_to_read: int = 5 def __str__(self): return self.title fake.py-0.11.9/examples/lazyfuzzy/article/tests.py000066400000000000000000000032271510566137200222150ustar00rootroot00000000000000import unittest from datetime import datetime from fake import FILE_REGISTRY from article.factories import ArticleFactory from article.models import Article, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("FactoriesTestCase",) class FactoriesTestCase(unittest.TestCase): def tearDown(self): FILE_REGISTRY.clean_up() def test_sub_factory(self) -> None: article = ArticleFactory() # Testing SubFactory self.assertIsInstance(article.author, User) self.assertIsInstance(article.author.id, int) # type: ignore self.assertIsInstance(article.author.is_staff, bool) # type: ignore self.assertIsInstance( article.author.date_joined, # type: ignore datetime, ) # Testing Factory self.assertIsInstance(article.id, int) self.assertIsInstance(article.slug, str) # Testing hooks self.assertTrue( hasattr(article, "_pre_save_called") and article._pre_save_called ) self.assertTrue( hasattr(article, "_post_save_called") and article._post_save_called ) self.assertTrue( hasattr(article.author, "_pre_save_called") and article.author._pre_save_called ) self.assertTrue( hasattr(article.author, "_post_save_called") and article.author._post_save_called ) # Testing batch creation articles = ArticleFactory.create_batch(5) self.assertEqual(len(articles), 5) self.assertIsInstance(articles[0], Article) fake.py-0.11.9/examples/lazyfuzzy/manage.py000077500000000000000000000016741510566137200206670ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython def run_tests(): """Function to run tests in the article directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir="./article", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) def main(): """Run administrative tasks based on command line arguments.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/lazyfuzzy/pyproject.toml000077700000000000000000000000001510566137200252472../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/pydantic/000077500000000000000000000000001510566137200165765ustar00rootroot00000000000000fake.py-0.11.9/examples/pydantic/README.rst000066400000000000000000000004261510566137200202670ustar00rootroot00000000000000Pydantic ======== Example factories for models based on `Pydantic `_. Installation ------------ .. code-block:: sh pip install -r requirements.in Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/pydantic/article/000077500000000000000000000000001510566137200202215ustar00rootroot00000000000000fake.py-0.11.9/examples/pydantic/article/__init__.py000066400000000000000000000000001510566137200223200ustar00rootroot00000000000000fake.py-0.11.9/examples/pydantic/article/factories.py000066400000000000000000000074411510566137200225600ustar00rootroot00000000000000from pathlib import Path from typing import Any, Dict from fake import ( FACTORY, FAKER, FileSystemStorage, PostSave, PreInit, PreSave, PydanticModelFactory, SubFactory, post_save, pre_init, pre_save, slugify, trait, ) from article.models import Article, Group, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "ArticleFactory", "GroupFactory", "UserFactory", ) # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent MEDIA_ROOT = BASE_DIR / "media" STORAGE = FileSystemStorage(root_path=MEDIA_ROOT, rel_path="tmp") CATEGORIES = ( "art", "technology", "literature", ) TAGS = ( "painting", "photography", "ai", "data-engineering", "fiction", "poetry", "manual", ) class GroupFactory(PydanticModelFactory): id = FACTORY.pyint() name = FACTORY.word() class Meta: model = Group get_or_create = ("name",) def set_password(user: User, password: str) -> None: user.set_password(password) def add_to_group(user: User, name: str) -> None: group = GroupFactory(name=name) user.groups.add(group) def set_username(data: Dict[str, Any]) -> None: first_name = slugify(data["first_name"]) last_name = slugify(data["last_name"]) data["username"] = f"{first_name}_{last_name}_{FAKER.pystr().lower()}" class UserFactory(PydanticModelFactory): id = FACTORY.pyint() username = PreInit(set_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") # type: ignore group = PostSave(add_to_group, name="TestGroup1234") # type: ignore class Meta: model = User @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_init def _pre_init_method(self, data): # For testing purposes only data["_pre_init_called"] = True @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True def set_headline(data) -> None: data["headline"] = data["content"][:25] class ArticleFactory(PydanticModelFactory): id = FACTORY.pyint() title = FACTORY.sentence() slug = FACTORY.slug() content = FACTORY.text() headline = PreInit(set_headline) category = FACTORY.random_choice(elements=CATEGORIES) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore image = FACTORY.png_file(storage=STORAGE) pub_date = FACTORY.date() safe_for_work = FACTORY.pybool() minutes_to_read = FACTORY.pyint(min_value=1, max_value=10) author = SubFactory(UserFactory) tags = FACTORY.random_sample(elements=TAGS, length=3) class Meta: model = Article @pre_init def set_auto_minutes_to_read(self, data: Dict[str, Any]) -> None: data["auto_minutes_to_read"] = data["pages"] @pre_init def _pre_init_method(self, data): # For testing purposes only data["_pre_init_called"] = True @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True fake.py-0.11.9/examples/pydantic/article/models.py000066400000000000000000000040161510566137200220570ustar00rootroot00000000000000from datetime import date, datetime from typing import List, Optional, Set from fake import xor_transform from pydantic import BaseModel, Field __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "Article", "Group", "User", ) class Group(BaseModel): id: int name: str class Config: allow_mutation = False def __hash__(self): return hash((self.id, self.name)) def __eq__(self, other): if isinstance(other, Group): return self.id == other.id and self.name == other.name return False class User(BaseModel): id: int username: str = Field(max_length=255) first_name: str = Field(max_length=255) last_name: str = Field(max_length=255) email: str = Field(max_length=255) date_joined: datetime = Field(default_factory=datetime.utcnow) last_login: Optional[datetime] = None password: Optional[str] = Field("", max_length=255) is_superuser: bool = Field(default=False) is_staff: bool = Field(default=False) is_active: bool = Field(default=True) groups: Set[Group] = Field(default_factory=set) class Config: extra = "allow" # For testing purposes only def __str__(self): return self.username def set_password(self, password: str) -> None: self.password = xor_transform(password) class Article(BaseModel): id: int title: str = Field(max_length=255) slug: str = Field(max_length=255, unique=True) content: str headline: str category: str = Field(max_length=255) pages: int auto_minutes_to_read: int author: User image: Optional[str] = None # Use str to represent the image path or URL pub_date: date = Field(default_factory=date.today) safe_for_work: bool = False minutes_to_read: int = 5 tags: List[str] = Field(default_factory=list) class Config: extra = "allow" # For testing purposes only def __str__(self): return self.title fake.py-0.11.9/examples/pydantic/article/tests.py000066400000000000000000000036221510566137200217400ustar00rootroot00000000000000import unittest from datetime import datetime from fake import FILE_REGISTRY, xor_transform from article.factories import ArticleFactory, UserFactory from article.models import Article, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("FactoriesTestCase",) class FactoriesTestCase(unittest.TestCase): def tearDown(self): FILE_REGISTRY.clean_up() def test_sub_factory(self) -> None: article = ArticleFactory() # Testing SubFactory self.assertIsInstance(article.author, User) self.assertIsInstance(article.author.id, int) self.assertIsInstance(article.author.is_staff, bool) self.assertIsInstance(article.author.date_joined, datetime) # Testing Factory self.assertIsInstance(article.id, int) self.assertIsInstance(article.slug, str) # Testing hooks self.assertTrue( hasattr(article, "_pre_save_called") and article._pre_save_called ) self.assertTrue( hasattr(article, "_post_save_called") and article._post_save_called ) self.assertTrue( hasattr(article.author, "_pre_save_called") and article.author._pre_save_called ) self.assertTrue( hasattr(article.author, "_post_save_called") and article.author._post_save_called ) # Testing batch creation articles = ArticleFactory.create_batch(5) self.assertEqual(len(articles), 5) self.assertIsInstance(articles[0], Article) def test_pre_save_and_post_save(self) -> None: """Test PreSave and PostSave.""" user = UserFactory(is_staff=True) self.assertEqual( xor_transform(user.password), "test1234", ) self.assertEqual(list(user.groups)[0].name, "TestGroup1234") fake.py-0.11.9/examples/pydantic/manage.py000077500000000000000000000016741510566137200204130ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython def run_tests(): """Function to run tests in the article directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir="./article", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) def main(): """Run administrative tasks based on command line arguments.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/pydantic/pyproject.toml000077700000000000000000000000001510566137200247732../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/pydantic/requirements.in000066400000000000000000000000111510566137200216410ustar00rootroot00000000000000pydantic fake.py-0.11.9/examples/sqlalchemy/000077500000000000000000000000001510566137200171255ustar00rootroot00000000000000fake.py-0.11.9/examples/sqlalchemy/README.rst000066400000000000000000000004311510566137200206120ustar00rootroot00000000000000SQLAlchemy ========== Example factories for models based on `SQLAlchemy `_. Installation ------------ .. code-block:: sh pip install -r requirements.in Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/sqlalchemy/article/000077500000000000000000000000001510566137200205505ustar00rootroot00000000000000fake.py-0.11.9/examples/sqlalchemy/article/__init__.py000066400000000000000000000000001510566137200226470ustar00rootroot00000000000000fake.py-0.11.9/examples/sqlalchemy/article/factories.py000066400000000000000000000107701510566137200231060ustar00rootroot00000000000000from pathlib import Path from typing import Any, Dict from fake import ( FACTORY, FAKER, FileSystemStorage, PostSave, PreInit, PreSave, SQLAlchemyModelFactory, SubFactory, post_save, pre_init, pre_save, slugify, trait, ) from article.models import Article, Group, User from config import SESSION __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "ArticleFactory", "UserFactory", ) # Storage config. Build paths inside the project like this: BASE_DIR / 'subdir' BASE_DIR = Path(__file__).resolve().parent.parent MEDIA_ROOT = BASE_DIR / "media" STORAGE = FileSystemStorage(root_path=MEDIA_ROOT, rel_path="tmp") CATEGORIES = ( "art", "technology", "literature", ) TAGS = ( "painting", "photography", "ai", "data-engineering", "fiction", "poetry", "manual", ) def get_session(): return SESSION() class GroupFactory(SQLAlchemyModelFactory): """User factory.""" name = FACTORY.word() class Meta: model = Group get_or_create = ("name",) class MetaSQLAlchemy: get_session = get_session def set_password(user: User, password: str) -> None: user.set_password(password) def add_to_group(user: User, name: str) -> None: session = get_session() # Check if the group already exists group = session.query(Group).filter_by(name=name).first() # If the group doesn't exist, create a new one if not group: group = Group(name=name) session.add(group) session.commit() # Commit to assign an ID to the new group # Add the group to the user's groups using append if group not in user.groups: user.groups.append(group) session.commit() # Commit the changes def set_username(data: Dict[str, Any]) -> None: first_name = slugify(data["first_name"]) last_name = slugify(data["last_name"]) data["username"] = f"{first_name}_{last_name}_{FAKER.pystr().lower()}" class UserFactory(SQLAlchemyModelFactory): """User factory.""" username = PreInit(set_username) # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = FACTORY.email() # type: ignore date_joined = FACTORY.date_time() # type: ignore last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore password = PreSave(set_password, password="test1234") # type: ignore group = PostSave(add_to_group, name="TestGroup1234") # type: ignore class Meta: model = User get_or_create = ("username",) class MetaSQLAlchemy: get_session = get_session @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True def set_headline(data: Dict[str, Any]) -> None: data["headline"] = data["content"][:25] class ArticleFactory(SQLAlchemyModelFactory): """Article factory.""" title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = PreInit(set_headline) category = FACTORY.random_choice(elements=CATEGORIES) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore image = FACTORY.png_file(storage=STORAGE) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint(min_value=1, max_value=10) # type: ignore author = SubFactory(UserFactory) # type: ignore tags = FACTORY.random_sample(elements=TAGS, length=3) class Meta: model = Article class MetaSQLAlchemy: get_session = get_session @pre_init def set_auto_minutes_to_read(self, data: Dict[str, Any]) -> None: data["auto_minutes_to_read"] = data["pages"] @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True fake.py-0.11.9/examples/sqlalchemy/article/models.py000066400000000000000000000054331510566137200224120ustar00rootroot00000000000000from datetime import datetime from fake import xor_transform from sqlalchemy import ( JSON, Boolean, Column, DateTime, ForeignKey, Integer, String, Table, Text, ) from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import relationship __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "Article", "Base", "User", ) Base = declarative_base() # Association table for the many-to-many relationship user_group_association = Table( "user_group", Base.metadata, Column("user_id", Integer, ForeignKey("users.id")), Column("group_id", Integer, ForeignKey("groups.id")), ) class Group(Base): """Group model.""" __tablename__ = "groups" id = Column(Integer, primary_key=True) name = Column(String(255), unique=True) def __repr__(self): return f"" class User(Base): """User model.""" __tablename__ = "users" id = Column(Integer, primary_key=True) username = Column(String(255), unique=True) first_name = Column(String(255)) last_name = Column(String(255)) email = Column(String(255)) date_joined = Column(DateTime, default=datetime.utcnow) last_login = Column(DateTime, nullable=True) password = Column(String(255), nullable=True) is_superuser = Column(Boolean, default=False) is_staff = Column(Boolean, default=False) is_active = Column(Boolean, default=True) # Many-to-many relationship groups = relationship( "Group", secondary=user_group_association, backref="users" ) # One-to-many relationship articles = relationship("Article", back_populates="author") def __repr__(self): return f"" def set_password(self, password: str) -> None: self.password = xor_transform(password) class Article(Base): """Article model.""" __tablename__ = "articles" id = Column(Integer, primary_key=True) title = Column(String(255)) slug = Column(String(255), unique=True) content = Column(Text) headline = Column(Text) category = Column(String(255)) pages = Column(Integer) auto_minutes_to_read = Column(Integer) image = Column(Text, nullable=True) pub_date = Column(DateTime, default=datetime.utcnow) safe_for_work = Column(Boolean, default=False) minutes_to_read = Column(Integer, default=5) author_id = Column(Integer, ForeignKey("users.id")) tags = Column(JSON, default=list) # Relationships author = relationship("User", back_populates="articles") def __repr__(self): return ( f"" ) fake.py-0.11.9/examples/sqlalchemy/article/tests.py000066400000000000000000000025411510566137200222660ustar00rootroot00000000000000import unittest from fake import FILE_REGISTRY, xor_transform from article.factories import ArticleFactory, UserFactory from config import SESSION __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("TestFactories",) class TestFactories(unittest.TestCase): def setUp(self): # Set up database session, if needed self.session = SESSION() def tearDown(self): # Clean up the session after each test self.session.rollback() self.session.close() # Clean up files FILE_REGISTRY.clean_up() def test_user_creation(self): user = UserFactory(username="testuser") self.assertIsNotNone(user.id) self.assertEqual(user.username, "testuser") def test_article_creation(self): user = UserFactory(username="authoruser") article = ArticleFactory(title="Test Article", author=user) self.assertIsNotNone(article.id) self.assertEqual(article.author.username, "authoruser") def test_pre_save_and_post_save(self) -> None: """Test PreSave and PostSave.""" user = UserFactory(is_staff=True) self.assertEqual( xor_transform(user.password), "test1234", ) self.assertEqual(list(user.groups)[0].name, "TestGroup1234") fake.py-0.11.9/examples/sqlalchemy/config.py000066400000000000000000000006561510566137200207530ustar00rootroot00000000000000from sqlalchemy import create_engine from sqlalchemy.orm import scoped_session, sessionmaker __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "DATABASE_URL", "ENGINE", "SESSION", ) # SQLAlchemy DATABASE_URL = "sqlite:///test_database.db" ENGINE = create_engine(DATABASE_URL) SESSION = scoped_session(sessionmaker(bind=ENGINE)) fake.py-0.11.9/examples/sqlalchemy/conftest.py000066400000000000000000000017201510566137200213240ustar00rootroot00000000000000import pytest @pytest.fixture(scope="session", autouse=True) def setup_database(): """Create all tables before any tests run, and drop them when the session ends. """ from article.models import Base from config import ENGINE Base.metadata.create_all(ENGINE) yield Base.metadata.drop_all(ENGINE) @pytest.fixture(scope="function") def db_session(): """Provide a new database session for a test and roll back after each test. """ from sqlalchemy.orm import sessionmaker from config import ENGINE # Establish a connection and start a transaction connection = ENGINE.connect() transaction = connection.begin() # Bind a sessionmaker to the connection session_cls = sessionmaker(bind=connection) session = session_cls() try: yield session finally: # Roll back any changes and close resources session.close() transaction.rollback() connection.close() fake.py-0.11.9/examples/sqlalchemy/manage.py000066400000000000000000000020561510566137200207320ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython def run_tests(): """Function to run tests in the article directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir=".", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) def main(): """Run administrative tasks based on command line arguments.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) from article.models import Base # noqa from config import ENGINE # noqa Base.metadata.create_all(ENGINE) parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/sqlalchemy/pyproject.toml000077700000000000000000000000001510566137200253222../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/sqlalchemy/requirements.in000066400000000000000000000000131510566137200221720ustar00rootroot00000000000000sqlalchemy fake.py-0.11.9/examples/sqlmodel/000077500000000000000000000000001510566137200166035ustar00rootroot00000000000000fake.py-0.11.9/examples/sqlmodel/README.rst000066400000000000000000000004321510566137200202710ustar00rootroot00000000000000SQLModel ======== Example factories for models based on `SQLModel `_. Installation ------------ .. code-block:: sh pip install -r requirements.in Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/sqlmodel/article/000077500000000000000000000000001510566137200202265ustar00rootroot00000000000000fake.py-0.11.9/examples/sqlmodel/article/__init__.py000066400000000000000000000000001510566137200223250ustar00rootroot00000000000000fake.py-0.11.9/examples/sqlmodel/article/factories.py000066400000000000000000000110141510566137200225540ustar00rootroot00000000000000from pathlib import Path from typing import Any, Dict from fake import ( FACTORY, FAKER, FileSystemStorage, PostSave, PreInit, PreSave, SQLAlchemyModelFactory, SubFactory, post_save, pre_init, pre_save, slugify, trait, ) from article.models import Article, Group, User from config import SESSION __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "ArticleFactory", "GroupFactory", "UserFactory", ) # Storage config. Build paths inside the project like this: BASE_DIR / 'subdir' BASE_DIR = Path(__file__).resolve().parent.parent MEDIA_ROOT = BASE_DIR / "media" STORAGE = FileSystemStorage(root_path=MEDIA_ROOT, rel_path="tmp") CATEGORIES = ( "art", "technology", "literature", ) TAGS = ( "painting", "photography", "ai", "data-engineering", "fiction", "poetry", "manual", ) def get_session(): return SESSION() class GroupFactory(SQLAlchemyModelFactory): """User factory.""" name = FACTORY.word() class Meta: model = Group get_or_create = ("name",) class MetaSQLAlchemy: get_session = get_session def set_password(user: User, password: str) -> None: user.set_password(password) def add_to_group(user: User, name: str) -> None: session = get_session() # Check if the group already exists group = session.query(Group).filter_by(name=name).first() # If the group doesn't exist, create a new one if not group: group = Group(name=name) session.add(group) session.commit() # Commit to assign an ID to the new group # Add the group to the user's groups using append if group not in user.groups: user.groups.append(group) session.commit() # Commit the changes def set_username(data: Dict[str, Any]) -> None: first_name = slugify(data["first_name"]) last_name = slugify(data["last_name"]) data["username"] = f"{first_name}_{last_name}_{FAKER.pystr().lower()}" class UserFactory(SQLAlchemyModelFactory): """User factory.""" username = PreInit(set_username) # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = FACTORY.email() # type: ignore date_joined = FACTORY.date_time() # type: ignore last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore password = PreSave(set_password, password="test1234") # type: ignore group = PostSave(add_to_group, name="TestGroup1234") # type: ignore class Meta: model = User get_or_create = ("username",) class MetaSQLAlchemy: get_session = get_session @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True def set_headline(data: Dict[str, Any]) -> None: data["headline"] = data["content"][:25] class ArticleFactory(SQLAlchemyModelFactory): """Article factory.""" title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = PreInit(set_headline) category = FACTORY.random_choice(elements=CATEGORIES) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore image = FACTORY.png_file(storage=STORAGE) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint(min_value=1, max_value=10) # type: ignore author = SubFactory(UserFactory) # type: ignore tags = FACTORY.random_sample(elements=TAGS, length=3) class Meta: model = Article class MetaSQLAlchemy: get_session = get_session @pre_init def set_auto_minutes_to_read(self, data: Dict[str, Any]) -> None: data["auto_minutes_to_read"] = data["pages"] @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True fake.py-0.11.9/examples/sqlmodel/article/models.py000066400000000000000000000052041510566137200220640ustar00rootroot00000000000000from datetime import datetime from typing import List, Optional from fake import xor_transform from sqlmodel import JSON, Column, Field, Relationship, SQLModel __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "Article", "Group", "User", ) class UserGroup(SQLModel, table=True): user_id: Optional[int] = Field( default=None, foreign_key="user.id", primary_key=True, ) group_id: Optional[int] = Field( default=None, foreign_key="group.id", primary_key=True, ) class Group(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str = Field(sa_column_kwargs={"unique": True}) users: List["User"] = Relationship( back_populates="groups", link_model=UserGroup, ) def __repr__(self): return f"" class User(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) username: str = Field(sa_column_kwargs={"unique": True}) first_name: str last_name: str email: str date_joined: datetime = Field(default_factory=datetime.utcnow) last_login: Optional[datetime] password: str is_superuser: bool = Field(default=False) is_staff: bool = Field(default=False) is_active: bool = Field(default=True) groups: List[Group] = Relationship( back_populates="users", link_model=UserGroup, ) articles: List["Article"] = Relationship(back_populates="author") def __repr__(self): return f"" def set_password(self, password: str) -> None: self.password = xor_transform(password) class Article(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) title: str slug: str = Field(sa_column_kwargs={"unique": True}) content: str headline: str category: str pages: int auto_minutes_to_read: int image: Optional[str] pub_date: datetime = Field(default_factory=datetime.utcnow) safe_for_work: bool = Field(default=False) minutes_to_read: int = Field(default=5) author_id: int = Field(foreign_key="user.id") tags: Optional[List[str]] = Field( default_factory=list, sa_column=Column(JSON), ) author: User = Relationship(back_populates="articles") # Needed for Column(JSON) class Config: arbitrary_types_allowed = True def __repr__(self): return ( f"" ) fake.py-0.11.9/examples/sqlmodel/article/tests.py000066400000000000000000000025411510566137200217440ustar00rootroot00000000000000import unittest from fake import FILE_REGISTRY, xor_transform from article.factories import ArticleFactory, UserFactory from config import SESSION __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("TestFactories",) class TestFactories(unittest.TestCase): def setUp(self): # Set up database session, if needed self.session = SESSION() def tearDown(self): # Clean up the session after each test self.session.rollback() self.session.close() # Clean up files FILE_REGISTRY.clean_up() def test_user_creation(self): user = UserFactory(username="testuser") self.assertIsNotNone(user.id) self.assertEqual(user.username, "testuser") def test_article_creation(self): user = UserFactory(username="authoruser") article = ArticleFactory(title="Test Article", author=user) self.assertIsNotNone(article.id) self.assertEqual(article.author.username, "authoruser") def test_pre_save_and_post_save(self) -> None: """Test PreSave and PostSave.""" user = UserFactory(is_staff=True) self.assertEqual( xor_transform(user.password), "test1234", ) self.assertEqual(list(user.groups)[0].name, "TestGroup1234") fake.py-0.11.9/examples/sqlmodel/config.py000066400000000000000000000013501510566137200204210ustar00rootroot00000000000000from sqlalchemy.orm import scoped_session, sessionmaker from sqlmodel import SQLModel, create_engine __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "DATABASE_URL", "ENGINE", "SESSION", ) # SQLAlchemy DATABASE_URL = "sqlite:///test_database.db" ENGINE = create_engine(DATABASE_URL) SESSION = scoped_session(sessionmaker(bind=ENGINE)) def create_tables(): """Create tables.""" SQLModel.metadata.create_all(ENGINE) def get_db(): """Get database connection.""" session = SESSION() try: yield session session.commit() finally: session.close() if __name__ == "__main__": create_tables() fake.py-0.11.9/examples/sqlmodel/conftest.py000066400000000000000000000004121510566137200207770ustar00rootroot00000000000000import pytest @pytest.fixture(scope="session", autouse=True) def setup_database(): """Create all tables once before any tests run.""" from config import create_tables # noqa from article.models import Article, Group, User # noqa create_tables() fake.py-0.11.9/examples/sqlmodel/manage.py000066400000000000000000000020641510566137200204070ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython def run_tests(): """Function to run tests in the article directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir=".", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) def main(): """Run administrative tasks based on command line arguments.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) from config import create_tables # noqa from article.models import Article, Group, User # noqa create_tables() parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/sqlmodel/pyproject.toml000077700000000000000000000000001510566137200250002../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/sqlmodel/requirements.in000066400000000000000000000000111510566137200216460ustar00rootroot00000000000000sqlmodel fake.py-0.11.9/examples/tortoise/000077500000000000000000000000001510566137200166335ustar00rootroot00000000000000fake.py-0.11.9/examples/tortoise/README.rst000066400000000000000000000004401510566137200203200ustar00rootroot00000000000000TortoiseORM =========== Example factories for models based on `TortoiseORM `_. Installation ------------ .. code-block:: sh pip install -r requirements.in Testing ------- .. code-block:: sh pytest or .. code-block:: sh python manage.py test fake.py-0.11.9/examples/tortoise/article/000077500000000000000000000000001510566137200202565ustar00rootroot00000000000000fake.py-0.11.9/examples/tortoise/article/__init__.py000066400000000000000000000000001510566137200223550ustar00rootroot00000000000000fake.py-0.11.9/examples/tortoise/article/factories.py000066400000000000000000000072331510566137200226140ustar00rootroot00000000000000from pathlib import Path from typing import Any, Dict from fake import ( FACTORY, FAKER, FileSystemStorage, PostSave, PreInit, PreSave, SubFactory, TortoiseModelFactory, post_save, pre_init, pre_save, run_async_in_thread, slugify, trait, ) from article.models import Article, Group, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "ArticleFactory", "GroupFactory", "UserFactory", ) # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent MEDIA_ROOT = BASE_DIR / "media" STORAGE = FileSystemStorage(root_path=MEDIA_ROOT, rel_path="tmp") CATEGORIES = ( "art", "technology", "literature", ) TAGS = ( "painting", "photography", "ai", "data-engineering", "fiction", "poetry", "manual", ) class GroupFactory(TortoiseModelFactory): """Group factory.""" name = FACTORY.word() class Meta: model = Group get_or_create = ("name",) def set_password(user: User, password: str) -> None: user.set_password(password) def add_to_group(user: User, name: str) -> None: group = GroupFactory(name=name) async def _add_to_group(): await user.groups.add(group) await user.save() run_async_in_thread(_add_to_group()) def set_username(data: Dict[str, Any]) -> None: first_name = slugify(data["first_name"]) last_name = slugify(data["last_name"]) data["username"] = f"{first_name}_{last_name}_{FAKER.pystr().lower()}" class UserFactory(TortoiseModelFactory): """User factory.""" username = PreInit(set_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="TestGroup1234") class Meta: model = User get_or_create = ("username",) @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True def set_headline(data: Dict[str, Any]) -> None: data["headline"] = data["content"][:25] class ArticleFactory(TortoiseModelFactory): """Article factory.""" title = FACTORY.sentence() slug = FACTORY.slug() content = FACTORY.text() headline = PreInit(set_headline) category = FACTORY.random_choice(elements=CATEGORIES) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore image = FACTORY.png_file(storage=STORAGE) pub_date = FACTORY.date() safe_for_work = FACTORY.pybool() minutes_to_read = FACTORY.pyint(min_value=1, max_value=10) author = SubFactory(UserFactory) tags = FACTORY.random_sample(elements=TAGS, length=3) class Meta: model = Article @pre_init def set_auto_minutes_to_read(self, data: Dict[str, Any]) -> None: data["auto_minutes_to_read"] = data["pages"] @pre_save def _pre_save_method(self, instance): # For testing purposes only instance._pre_save_called = True @post_save def _post_save_method(self, instance): # For testing purposes only instance._post_save_called = True fake.py-0.11.9/examples/tortoise/article/models.py000066400000000000000000000041121510566137200221110ustar00rootroot00000000000000from datetime import date from fake import xor_transform from tortoise import fields from tortoise.models import Model __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "Article", "Group", "User", ) class Group(Model): """Group model.""" id = fields.IntField(pk=True) name = fields.CharField(max_length=255, unique=True) def __str__(self): return self.name class User(Model): """User model.""" id = fields.IntField(pk=True) username = fields.CharField(max_length=255, unique=True) first_name = fields.CharField(max_length=255) last_name = fields.CharField(max_length=255) email = fields.CharField(max_length=255) password = fields.CharField(max_length=255, null=True, blank=True) last_login = fields.DatetimeField(null=True, blank=True) is_superuser = fields.BooleanField(default=False) is_staff = fields.BooleanField(default=False) is_active = fields.BooleanField(default=True) date_joined = fields.DatetimeField(null=True, blank=True) groups = fields.ManyToManyField("models.Group", on_delete=fields.CASCADE) def __str__(self): return self.title def set_password(self, password: str) -> None: self.password = xor_transform(password) class Article(Model): """Article model.""" id = fields.IntField(pk=True) title = fields.CharField(max_length=255) slug = fields.CharField(max_length=255, unique=True) content = fields.TextField() headline = fields.TextField() category = fields.CharField(max_length=255) pages = fields.IntField() auto_minutes_to_read = fields.IntField() image = fields.TextField(null=True, blank=True) pub_date = fields.DateField(default=date.today) safe_for_work = fields.BooleanField(default=False) minutes_to_read = fields.IntField(default=5) author = fields.ForeignKeyField( "models.User", on_delete=fields.CASCADE, ) tags = fields.JSONField(default=list) def __str__(self): return self.title fake.py-0.11.9/examples/tortoise/article/tests.py000066400000000000000000000100471510566137200217740ustar00rootroot00000000000000from datetime import datetime from fake import FILE_REGISTRY, run_async_in_thread, xor_transform from tortoise.contrib import test from tortoise.contrib.test import finalizer, initializer from article.factories import ArticleFactory, UserFactory from article.models import Article, User __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ("FactoriesTestCase",) class FactoriesTestCase(test.TestCase): @classmethod def setUpClass(cls): initializer(["article.models"], db_url="sqlite://:memory:") # Your setup code... @classmethod def tearDownClass(cls): finalizer() # Your teardown code... def tearDown(self): FILE_REGISTRY.clean_up() def test_sub_factory(self) -> None: with self.subTest("SubFactory"): article = ArticleFactory() # Testing SubFactory self.assertIsInstance(article.author, User) self.assertIsInstance(article.author.id, int) self.assertIsInstance(article.author.is_staff, bool) self.assertIsInstance(article.author.date_joined, datetime) # Testing Factory self.assertIsInstance(article.id, int) self.assertIsInstance(article.slug, str) # Testing hooks self.assertTrue( hasattr(article, "_pre_save_called") and article._pre_save_called ) self.assertTrue( hasattr(article, "_post_save_called") and article._post_save_called ) self.assertTrue( hasattr(article.author, "_pre_save_called") and article.author._pre_save_called ) self.assertTrue( hasattr(article.author, "_post_save_called") and article.author._post_save_called ) # Testing batch creation articles = ArticleFactory.create_batch(5) self.assertEqual(len(articles), 5) self.assertIsInstance(articles[0], Article) with self.subTest("SubFactory nested params"): article = ArticleFactory(author__username="admin") # Testing SubFactory self.assertIsInstance(article.author, User) self.assertIsInstance(article.author.id, int) self.assertIsInstance(article.author.is_staff, bool) self.assertIsInstance(article.author.date_joined, datetime) self.assertEqual(article.author.username, "admin") # Testing Factory self.assertIsInstance(article.id, int) self.assertIsInstance(article.slug, str) # Testing hooks self.assertTrue( hasattr(article, "_pre_save_called") and article._pre_save_called ) self.assertTrue( hasattr(article, "_post_save_called") and article._post_save_called ) self.assertTrue( hasattr(article.author, "_pre_save_called") and article.author._pre_save_called ) self.assertTrue( hasattr(article.author, "_post_save_called") and article.author._post_save_called ) # Testing batch creation articles = ArticleFactory.create_batch(5) self.assertEqual(len(articles), 5) self.assertIsInstance(articles[0], Article) def test_pre_save_and_post_save(self) -> None: """Test PreSave and PostSave.""" user = UserFactory(is_staff=True, is_active=True) self.assertEqual( xor_transform(user.password), "test1234", ) async def get_first_group_name(): first_group = await user.groups.all().first() if first_group: return first_group.name return None group_name = run_async_in_thread(get_first_group_name()) self.assertEqual(group_name, "TestGroup1234") fake.py-0.11.9/examples/tortoise/conftest.py000066400000000000000000000011161510566137200210310ustar00rootroot00000000000000import pytest async def init(): # Initialise SQLite DB and specify the app name of "models" # alongside the models "article.models" from tortoise import Tortoise await Tortoise.init( db_url="sqlite://:memory:", # db_url="sqlite://tortoise_db.sqlite3", modules={"models": ["article.models"]}, ) # Generate the schema await Tortoise.generate_schemas() @pytest.fixture(scope="session", autouse=True) def setup_database(): """Create all tables once before any tests run.""" from tortoise import run_async run_async(init()) fake.py-0.11.9/examples/tortoise/manage.py000077500000000000000000000025011510566137200204360ustar00rootroot00000000000000#!/usr/bin/env python import argparse import os import sys import unittest import IPython from tortoise import Tortoise, run_async def run_tests(): """Function to run tests in the article directory.""" loader = unittest.TestLoader() suite = loader.discover(start_dir="./article", pattern="tests.py") runner = unittest.TextTestRunner() runner.run(suite) async def init(): # Initialise SQLite DB and specify the app name of "models" # alongside the models "article.models" await Tortoise.init( db_url="sqlite://:memory:", # db_url="sqlite://tortoise_db.sqlite3", modules={"models": ["article.models"]}, ) # Generate the schema await Tortoise.generate_schemas() def main(): """Run administrative tasks.""" sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) sys.path.insert(0, os.path.abspath(".")) run_async(init()) parser = argparse.ArgumentParser( description="Management script for the project." ) parser.add_argument("command", help="The command to run (test or shell)") args = parser.parse_args() if args.command == "test": run_tests() elif args.command == "shell": IPython.embed() else: print("Unknown command. Use 'test' or 'shell'.") if __name__ == "__main__": main() fake.py-0.11.9/examples/tortoise/pyproject.toml000077700000000000000000000000001510566137200250302../_pyproject.tomlustar00rootroot00000000000000fake.py-0.11.9/examples/tortoise/requirements.in000066400000000000000000000000241510566137200217020ustar00rootroot00000000000000tortoise-orm<0.23.0 fake.py-0.11.9/fake.py000066400000000000000000011515421510566137200144360ustar00rootroot00000000000000""" https://github.com/barseghyanartur/fake.py/ """ import array import ast import asyncio import contextlib import io import locale import logging import math import mimetypes import os import random import re import secrets import string import struct import subprocess import tarfile import unittest import uuid import wave import zipfile import zlib import zoneinfo from abc import abstractmethod from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser from collections import defaultdict from concurrent.futures import ThreadPoolExecutor from copy import deepcopy from dataclasses import dataclass, field, fields, is_dataclass from datetime import date, datetime, time, timedelta, timezone from decimal import Decimal from email.message import EmailMessage from email.policy import Policy, default from email.utils import parseaddr from functools import partial from inspect import signature from io import BytesIO from pathlib import Path from tempfile import gettempdir, mktemp from textwrap import wrap from threading import Lock from typing import ( Any, Awaitable, Callable, Coroutine, Dict, Iterable, List, Literal, Optional, Sequence, Set, TextIO, Tuple, Type, TypeVar, Union, get_args, get_origin, get_type_hints, ) from unittest.mock import MagicMock, patch from uuid import UUID __title__ = "fake.py" __version__ = "0.11.9" __author__ = "Artur Barseghyan " __copyright__ = "2023-2025 Artur Barseghyan" __license__ = "MIT" __all__ = ( "AuthorshipData", "BaseStorage", "CLI", "DjangoModelFactory", "DocxGenerator", "EpubGenerator", "FACTORY", "FAKER", "FILE_REGISTRY", "Factory", "FactoryMethod", "Faker", "FileRegistry", "FileSystemStorage", "GraphicPdfGenerator", "LazyAttribute", "LazyFunction", "LazyStringTemplate", "MetaData", "ModelFactory", "OdtGenerator", "PROVIDER_REGISTRY", "PostSave", "PreInit", "PreSave", "PydanticModelFactory", "RtfGenerator", "SQLAlchemyModelFactory", "StringTemplate", "StringValue", "SubFactory", "TestCLI", "TestFaker", "TestLazyStringTemplate", "TestOrganiseProviders", "TestScript", "TestSlugify", "TestStringTemplate", "TextPdfGenerator", "TortoiseModelFactory", "create_inner_bmp_file", "create_inner_docx_file", "create_inner_eml_file", "create_inner_gif_file", "create_inner_jpg_file", "create_inner_odt_file", "create_inner_pdf_file", "create_inner_png_file", "create_inner_ppm_file", "create_inner_rtf_file", "create_inner_svg_file", "create_inner_tar_file", "create_inner_text_pdf_file", "create_inner_tif_file", "create_inner_txt_file", "create_inner_wav_file", "create_inner_zip_file", "fill_dataclass", "fill_pydantic_model", "format_type_hint", "fuzzy_choice_create_inner_file", "get_argparse_type", "get_provider_args", "get_provider_defaults", "is_optional_type", "list_create_inner_file", "main", "organise_providers", "post_save", "pre_init", "pre_save", "provider", "run_async_in_thread", "slugify", "trait", "wrap_text", "xor_transform", ) LOGGER = logging.getLogger(__name__) T = TypeVar("T") ElementType = Sequence[T] # ************************************************ # ******************* Public ********************* # ************************************************ IMAGE_SERVICES = ( "https://picsum.photos/{width}/{height}", "https://dummyimage.com/{width}x{height}", "https://placekitten.com/{width}/{height}", "https://loremflickr.com/{width}/{height}", ) FREE_EMAIL_DOMAINS = ( "gmail.com", "hotmail.com", "mail.com", "outlook.com", "proton.me", "protonmail.com", "yahoo.com", ) TLDS = ( "com", "org", "net", "io", ) URL_PROTOCOLS = ( "http", "https", ) URL_SUFFIXES = ( ".html", ".php", ".go", "", "/", ) FILE_TYPES = mimetypes.types_map FILE_EXTENSIONS = [__v[1:] for __v in FILE_TYPES.keys()] # noqa: SIM118 MIME_TYPES = list(FILE_TYPES.values()) UNWANTED_GEO_PATTERN = re.compile( r"^([A-Z0-9-+]+$|GB.*|localtime|Universal|Etc|Factory)" ) TAR_COMPRESSION_OPTIONS = {"gz", "bz2", "xz"} PDF_TEXT_TPL_PAGE_OBJECT = """{page_num} 0 obj <> endobj """ PDF_TEXT_TPL_CONTENT_OBJECT = """{obj_num} 0 obj <> stream {content} endstream 6 0 obj <> endobj """ PDF_GRAPHIC_TPL_IMAGE_OBJECT = """{obj_num} 0 obj <> stream """ PDF_GRAPHIC_TPL_PAGE_OBJECT = """{page_obj_num} 0 obj <> >> /Contents {content_obj_num} 0 R >> endobj """ PDF_GRAPHIC_TPL_CONTENT_OBJECT = """{content_obj_num} 0 obj <> stream q 100 0 0 100 0 0 cm /Im{image_obj_num} Do Q endstream endobj """ PDF_GRAPHIC_TPL_PAGES_OBJECT = """3 0 obj <> endobj """ PDF_GRAPHIC_TPL_CATALOG_OBJECT = """1 0 obj <> endobj """ PDF_GRAPHIC_TPL_TRAILER_OBJECT = """trailer <> startxref """ SVG_TPL = """ """ DOCX_TPL_DOC_HEADER = ( '' '' # noqa "" ) DOCX_TPL_DOC_FOOTER = "" DOC_TPL_DOC_STRUCTURE_RELS = ( b"" b"" # noqa b"" # noqa b"" ) DOC_TPL_DOC_STRUCTURE_WORD_RELS = ( b"" b"" # noqa b"" # noqa b"" ) DOC_TPL_DOC_STRUCTURE_WORD_STYLES = ( b"" b"" # noqa b"" b"" ) DOC_TPL_DOC_STRUCTURE_CONTENT_TYPES = ( b"" b"" # noqa b"" # noqa b"" b"" # noqa b"" # noqa b"" ) RTF_HEADER = r"{\rtf1\ansi\deff0" RTF_FONT_TABLE = r"{\fonttbl{\f0\fnil\fcharset0 Arial;}}" RTF_COLOR_TABLE = r"{\colortbl ;\red0\green0\blue0;}" RTF_DOCUMENT_START = "\n" RTF_DOCUMENT_END = "\n}" EPUB_MIMETYPE = b"application/epub+zip" EPUB_CONTAINER_XML = b""" """ # Missing/specific custom types MISSING_MIMETYPES = { ".docx": "application/" "vnd.openxmlformats-officedocument.wordprocessingml.document", ".pptx": "application/" "vnd.openxmlformats-officedocument.presentationml.presentation", ".xlsx": "application/" "vnd.openxmlformats-officedocument.spreadsheetml.sheet", ".epub": "application/epub+zip", ".odt": "application/vnd.oasis.opendocument.text", ".rtf": "application/rtf", } SLUGIFY_RE = re.compile(r"[^a-zA-Z0-9]") TEMP_DIR = gettempdir() def slugify(value: str, separator: str = "") -> str: """Slugify.""" return SLUGIFY_RE.sub(separator, value).lower() def get_mime_maintype_subtype(path: str) -> Tuple[str, str]: """ Determine the MIME maintype and subtype for the given file path, using Python's built-in mimetypes plus a few custom entries. :param path: Path to the file (extension is used for lookup). :return: (maintype, subtype) tuple, for example ("application", "pdf") :rtype: Tuple[str, str] """ # Initialize the system-wide mappings mimetypes.init() for ext, ctype in MISSING_MIMETYPES.items(): mimetypes.add_type(ctype, ext, strict=True) # Prefer `guess_file_type` on Python 3.13+, else `guess_type` if hasattr(mimetypes, "guess_file_type"): ctype, encoding = mimetypes.guess_file_type(path) else: ctype, encoding = mimetypes.guess_type(path) # If unknown or if an encoding hint was returned, fall back safely if ctype is None or encoding is not None: ctype = "application/octet-stream" # Split into maintype/subtype maintype, subtype = ctype.split("/", 1) return maintype, subtype class MetaData: __slots__ = ("content",) def __init__(self): self.content: Optional[str] = None def add_content(self, content: Union[str, List[str]]) -> None: if isinstance(content, list): self.content = "\n".join(content) else: self.content = content class StringValue(str): __slots__ = ("data",) data: Dict[str, Any] def __new__( cls: Type["StringValue"], value: str, *args, **kwargs, ) -> "StringValue": obj = str.__new__(cls, value) obj.data = {} return obj class BytesValue(bytes): data: Dict[str, Any] def __new__( cls: Type["BytesValue"], value: bytes, *args, **kwargs, ) -> "BytesValue": obj = bytes.__new__(cls, value) obj.data = {} return obj def returns_list(func: Callable) -> bool: """Checks if callable returns a list of `StringValue`. Returns True if it's a List. Returns False otherwise. """ try: return_type = get_type_hints(func).get("return", None) except Exception: return False if not return_type: return False return_origin = getattr(return_type, "__origin__", None) if return_origin is list or return_origin is List: # If it's a list, check the type of its elements element_type = getattr(return_type, "__args__", [None])[0] if element_type in {StringValue, BytesValue}: return True element_origin = getattr(element_type, "__origin__", None) if ( element_origin is Union and set(getattr(element_type, "__args__", [])) == { BytesValue, StringValue, } ): return True return False def wrap_text(text: str, wrap_chars_after: int) -> str: return "\n".join( wrap( text=text, width=wrap_chars_after, replace_whitespace=False, # drop_whitespace=False, ) ) class StringTemplateMixin: template: str wrap_chars_after: Optional[int] faker: Optional["Faker"] # Regular expression to match placeholders with optional arguments placeholder_pattern = re.compile(r"\{(\w+)(?:\((.*?)\))?}") def render(self) -> str: """Substitute all placeholders in the template with corresponding method calls on the object. :rtype: str :return: The formatted string with all placeholders replaced. """ content = self.placeholder_pattern.sub(self.replacer, self.template) if self.wrap_chars_after: content = wrap_text(content, self.wrap_chars_after) return content def replacer(self, match: re.Match) -> str: """Replacement method to process each regex match. :param match: The regex match object. :raises ValueError: If there is an error parsing arguments or calling the method. :raises AttributeError: If the method does not exist on the object. :return: The replacement string. :rtype: str """ method_name = match.group(1) args_str = match.group(2) # Parse arguments if any args = [] kwargs = {} if args_str: try: # Safely parse the arguments using ast.literal_eval # We wrap the arguments in a dummy function to parse them # Example: f('morning', format='%A, %B %d, %Y') parsed_args = ast.parse(f"f({args_str})", mode="eval").body for arg in parsed_args.args: args.append(ast.literal_eval(arg)) # noqa: PERF401 for kw in parsed_args.keywords: kwargs[kw.arg] = ast.literal_eval(kw.value) except Exception as err: raise ValueError( f"Error parsing arguments for '{method_name}': {err}" ) from err # Get the method from the object method = getattr(self.faker, method_name, None) if callable(method): try: return str(method(*args, **kwargs)) except Exception as err: raise ValueError( f"Error calling method '{method_name}': {err}" ) from err else: raise AttributeError( f"Method '{method_name}' not found in the " f"object '{self.faker.__class__.__name__}'." ) def __str__(self) -> str: return self.render() def __repr__(self) -> str: return self.render() def __iter__(self): # Allows iteration as a string return iter(str(self)) def __getitem__(self, index): # Allows indexing like a string return str(self)[index] class StringTemplate(str, StringTemplateMixin): """LazyStringTemplate. Usage example: .. code-block:: python from fake import FAKER, StringTemplate template = ''' {date(start_date='-7d')}, Dear {name}, {sentence(nb_words=25)} Best regards, {name} ''' string_template = StringTemplate(template) print(string_template) Integration with providers: .. code-block:: python from fake import FAKER, StringTemplate template = ''' {date(start_date='-7d')}, Dear {name}, {sentence(nb_words=25)} Best regards, {name} ''' string_template = StringTemplate(template) FAKER.docx_file( texts=[StringTemplate(template) for _ in range(10)] ) FAKER.eml_file(content=string_template) FAKER.txt_file(text=string_template) FAKER.text_pdf_file( texts=[StringTemplate(template) for _ in range(10)] ) """ def __new__( cls, template: str, wrap_chars_after: Optional[int] = None, faker: Optional["Faker"] = None, ) -> "StringTemplate": # Create a temporary instance to use render instance = super().__new__(cls, "") instance.faker = faker or FAKER instance.template = template instance.wrap_chars_after = wrap_chars_after # Render the content rendered = instance.render() # Return the new string instance with the rendered content return super().__new__(cls, rendered) class LazyStringTemplate(StringTemplateMixin): """LazyStringTemplate. Usage example: .. code-block:: python from fake import FAKER, LazyStringTemplate template = ''' {date(start_date='-7d')}, Dear {name}, {sentence(nb_words=25)} Best regards, {name} ''' string_template = LazyStringTemplate(template) print(string_template.render()) Integration with providers: .. code-block:: python from fake import FAKER, LazyStringTemplate template = ''' {date(start_date='-7d')}, Dear {name}, {sentence(nb_words=25)} Best regards, {name} ''' string_template = LazyStringTemplate(template) FAKER.docx_file(texts=[str(string_template)]) FAKER.eml_file(content=str(string_template)) FAKER.txt_file(text=str(string_template)) FAKER.text_pdf_file(texts=[str(string_template) for _ in range(10)]) """ def __init__( self, template: str, wrap_chars_after: Optional[int] = None, faker: Optional["Faker"] = None, ) -> None: self.faker = faker or FAKER self.template = template self.wrap_chars_after = wrap_chars_after class FileRegistry: """Stores list `StringValue` instances. .. code-block:: python 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() """ def __init__(self) -> None: self._registry: Set[StringValue] = set() self._lock = Lock() def add(self, string_value: StringValue) -> None: with self._lock: self._registry.add(string_value) def remove(self, string_value: Union[StringValue, str]) -> bool: if not isinstance(string_value, StringValue): string_value = self.search(string_value) # type: ignore if not string_value: return False with self._lock: # No error if the element doesn't exist self._registry.discard(string_value) # type: ignore try: string_value.data["storage"].unlink( # type: ignore string_value.data["filename"] # type: ignore ) return True except Exception as e: LOGGER.error( f"Failed to unlink file " f"{string_value.data['filename']}: {e}" # type: ignore ) return False def search(self, value: str) -> Optional[StringValue]: with self._lock: for string_value in self._registry: if string_value == value: return string_value return None def clean_up(self) -> None: with self._lock: while self._registry: file = self._registry.pop() try: file.data["storage"].unlink(file.data["filename"]) except Exception as err: LOGGER.error( f"Failed to unlink file {file.data['filename']}: {err}" ) FILE_REGISTRY = FileRegistry() class BaseStorage: """Base storage.""" def __init__(self, *args, **kwargs) -> None: self.args = args self.kwargs = kwargs def generate_basename( self: "BaseStorage", prefix: str = "tmp", length: int = 8, ) -> str: """Generate a random alphanumeric sequence.""" if not prefix: prefix = "tmp" # Use lowercase letters, digits and underscore characters = string.ascii_lowercase + string.digits + "_" return prefix + "".join(random.choices(characters, k=length)) @abstractmethod def generate_filename( self: "BaseStorage", extension: str, prefix: Optional[str] = None, basename: Optional[str] = None, ) -> Any: """Generate filename.""" @abstractmethod def write_text( self: "BaseStorage", filename: Any, data: str, encoding: Optional[str] = None, ) -> int: """Write text.""" @abstractmethod def write_bytes(self: "BaseStorage", filename: Any, data: bytes) -> int: """Write bytes.""" @abstractmethod def exists(self: "BaseStorage", filename: Any) -> bool: """Check if file exists.""" @abstractmethod def relpath(self: "BaseStorage", filename: Any) -> str: """Return relative path.""" @abstractmethod def abspath(self: "BaseStorage", filename: Any) -> str: """Return absolute path.""" @abstractmethod def unlink(self: "BaseStorage", filename: Any) -> None: """Delete the file.""" class FileSystemStorage(BaseStorage): """File storage class using pathlib for path handling. Usage example: .. code-block:: python 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: .. code-block:: python from fake import FAKER, FileSystemStorage storage = FileSystemStorage() docx_file = FAKER.docx_file(storage=storage) """ def __init__( self: "FileSystemStorage", root_path: Optional[Union[str, Path]] = TEMP_DIR, rel_path: Optional[str] = "tmp", *args, **kwargs, ) -> None: """ :param root_path: Path of your files root directory (e.g., Django's `settings.MEDIA_ROOT`). :param rel_path: Relative path (from root directory). :param *args: :param **kwargs: """ self.root_path = Path(root_path or "") self.rel_path = Path(rel_path or "") super().__init__(*args, **kwargs) def generate_filename( self: "FileSystemStorage", extension: str, prefix: Optional[str] = None, basename: Optional[str] = None, ) -> str: """Generate filename.""" dir_path = self.root_path / self.rel_path dir_path.mkdir(parents=True, exist_ok=True) if not extension: raise ValueError("Extension shall be given!") if not basename: basename = self.generate_basename(prefix) return str(dir_path / f"{basename}.{extension}") def write_text( self: "FileSystemStorage", filename: str, data: str, encoding: Optional[str] = None, ) -> int: """Write text.""" path = Path(filename) path.write_text(data, encoding=encoding or "utf-8") return len(data) def write_bytes( self: "FileSystemStorage", filename: str, data: bytes, ) -> int: """Write bytes.""" path = Path(filename) path.write_bytes(data) return len(data) def exists(self: "FileSystemStorage", filename: str) -> bool: """Check if file exists.""" file_path = Path(filename) if file_path.is_absolute(): return file_path.exists() return (self.root_path / file_path).exists() def relpath(self: "FileSystemStorage", filename: str) -> str: """Return relative path.""" return str(Path(filename).relative_to(self.root_path)) def abspath(self: "FileSystemStorage", filename: str) -> str: """Return absolute path.""" file_path = Path(filename) if file_path.is_absolute(): return str(file_path.resolve()) return str((self.root_path / file_path).resolve()) def unlink(self: "FileSystemStorage", filename: str) -> None: """Delete the file.""" file_path = Path(filename) if file_path.is_absolute(): file_path.unlink() else: (self.root_path / file_path).unlink() class TextPdfGenerator: """Text PDF generatr. Usage example: .. code-block:: python from pathlib import Path from fake import FAKER, TextPdfGenerator Path("/tmp/text_example.pdf").write_bytes( FAKER.pdf(nb_pages=100, generator=TextPdfGenerator) ) """ nb_pages: int texts: List[str] def __init__(self, faker: "Faker") -> None: self.faker = faker def _add_page_object(self, page_num, content_obj_num): return PDF_TEXT_TPL_PAGE_OBJECT.format( page_num=page_num, content_obj_num=content_obj_num, ) def _add_content_object(self, obj_num, page_text): content = f"BT /F1 24 Tf 100 700 Td ({page_text}) Tj ET" stream_length = len(content) return PDF_TEXT_TPL_CONTENT_OBJECT.format( obj_num=obj_num, stream_length=stream_length, content=content, ) def create( self, nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> bytes: # Initialization if not nb_pages and not texts: raise ValueError( "Either `nb_pages` or `texts` arguments shall be given." ) if texts: self.nb_pages: int = len(texts) self.texts = texts else: self.nb_pages: int = nb_pages or 1 self.texts = self.faker.sentences(nb=self.nb_pages) if metadata: metadata.add_content(self.texts) # Construction pdf_bytes = io.BytesIO() pdf_bytes.write(b"%PDF-1.4\n") pdf_bytes.write(b"1 0 obj\n<>\nendobj\n") pdf_bytes.write(b"2 0 obj\n<>>>\nendobj\n") pdf_bytes.write(b"3 0 obj\n<>\nendobj\n".encode()) for page_obj in page_objs: pdf_bytes.write(page_obj.encode()) for content_obj in content_objs: pdf_bytes.write(content_obj.encode()) pdf_bytes.write(f"xref\n0 {str(4 + 2 * self.nb_pages)}\n".encode()) pdf_bytes.write(b"0000000000 65535 f \n") pdf_bytes.write( b"0000000010 00000 n \n0000000057 00000 n \n0000000103 00000 n \n" ) offset = 149 for _ in range(self.nb_pages): pdf_bytes.write(f"{offset:010} 00000 n \n".encode()) offset += 78 pdf_bytes.write(f"{offset:010} 00000 n \n".encode()) offset += 73 pdf_bytes.write( f"trailer\n<>\n" f"".encode() ) pdf_bytes.write(b"startxref\n564\n%%EOF") return pdf_bytes.getvalue() class GraphicPdfGenerator: """Graphic PDF generatr. Usage example: .. code-block:: python from pathlib import Path from fake import FAKER, GraphicPdfGenerator Path("/tmp/graphic_example.pdf").write_bytes( FAKER.pdf(nb_pages=100, generator=GraphicPdfGenerator) ) """ nb_pages: int image_size: Tuple[int, int] image_color: Tuple[int, int, int] def __init__(self, faker: "Faker") -> None: self.faker = faker def _create_raw_image_data(self): width, height = self.image_size # Create uncompressed raw RGB data raw_data = bytes(self.image_color) * width * height return zlib.compress(raw_data) def _add_image_object(self, pdf_bytes, obj_num): width, height = self.image_size image_stream = self._create_raw_image_data() stream_length = len(image_stream) pdf_bytes.write( PDF_GRAPHIC_TPL_IMAGE_OBJECT.format( obj_num=obj_num, width=width, height=height, stream_length=stream_length, ).encode() ) pdf_bytes.write(image_stream) pdf_bytes.write(b"\nendstream\nendobj\n") def create( self, nb_pages: int = 1, image_size: Tuple[int, int] = (100, 100), image_color: Tuple[int, int, int] = (255, 0, 0), **kwargs, ) -> bytes: # Initialization self.nb_pages = nb_pages self.image_size = image_size self.image_color = image_color # Construction pdf_bytes = io.BytesIO() pdf_bytes.write(b"%PDF-1.0\n") # Image object number image_obj_num = 4 # Positions in the PDF for the xref table positions = [pdf_bytes.tell()] # Add image object self._add_image_object(pdf_bytes, image_obj_num) positions.append(pdf_bytes.tell()) # Add pages for i in range(self.nb_pages): page_obj_num = 5 + i content_obj_num = page_obj_num + self.nb_pages pdf_bytes.write( PDF_GRAPHIC_TPL_PAGE_OBJECT.format( page_obj_num=page_obj_num, image_obj_num=image_obj_num, content_obj_num=content_obj_num, ).encode() ) positions.append(pdf_bytes.tell()) # Content stream that uses the image pdf_bytes.write( PDF_GRAPHIC_TPL_CONTENT_OBJECT.format( content_obj_num=content_obj_num, image_obj_num=image_obj_num, ).encode() ) positions.append(pdf_bytes.tell()) # Pages object pages_kids = " ".join([f"{5 + i} 0 R" for i in range(self.nb_pages)]) pdf_bytes.write( PDF_GRAPHIC_TPL_PAGES_OBJECT.format( pages_kids=pages_kids, num_pages=self.nb_pages, ).encode() ) positions.append(pdf_bytes.tell()) # Catalog object pdf_bytes.write(PDF_GRAPHIC_TPL_CATALOG_OBJECT.encode()) positions.append(pdf_bytes.tell()) # xref table pdf_bytes.write(b"xref\n0 1\n0000000000 65535 f \n") for pos in positions: pdf_bytes.write(f"{pos:010} 00000 n \n".encode()) # Trailer pdf_bytes.write(PDF_GRAPHIC_TPL_TRAILER_OBJECT.encode()) pdf_bytes.write(f"{positions[-1]}\n".encode()) pdf_bytes.write(b"%%EOF") return pdf_bytes.getvalue() class AuthorshipData: _authorship_data: Dict[str, List[str]] = {} first_names: Set[str] = set() last_names: Set[str] = set() def _extract_info(self, file: TextIO) -> List[str]: return [ line.strip() for line in file if "__author__" in line or "Author:" in line ] def _find_authorship_info(self, file_path: str) -> List[str]: try: with open(file_path, "r", encoding="utf-8") as file: return self._extract_info(file) except UnicodeDecodeError: with open(file_path, "r", encoding="latin-1") as file: return self._extract_info(file) def _extract_authorship_info_from_stdlib(self) -> None: stdlib_path = os.path.dirname(os.__file__) for root, _, files in os.walk(stdlib_path): for file in files: if file.endswith(".py"): file_path = os.path.join(root, file) authorship_info = self._find_authorship_info(file_path) if authorship_info: self._authorship_data[file_path] = authorship_info def _extract_names(self) -> None: """Extract first and last names from authorship information. Ensures that multi-part last names are treated as a single entity. """ # Patterns for different cases patterns = { # For simple cases like '# Author: ' "simple": r"# Author: ([\w\s\-\']+)", # For cases like '__author__ = " "' "email_in_brackets": r'__author__\s*=\s*"([\w\s\-\']+)', # For multiple authors like '# Author: , ' "multiple_authors": r"# Author: ([\w\s\-\']+), ([\w\s\-\']+)", # For cases like '# Author: , ' "author_with_email": r"# Author: ([\w\s\-\']+), \w+@[\w\.-]+", } for info_list in self._authorship_data.values(): for info in info_list: # Ignoring anything after '--', emails, and dates info = re.sub( ( r"--.*|<[\w\.-]+@[\w\.-]+>|\b\d{4}\b|\bJanuary\b|" r"\bFebruary\b|\bMarch\b|\bApril\b|\bMay\b|\bJune\b|" r"\bJuly\b|\bAugust\b|\bSeptember\b|\bOctober\b|" r"\bNovember\b|\bDecember\b" ), "", info, ) for pattern in patterns.values(): found_names = re.findall(pattern, info) for name in found_names: if isinstance(name, tuple): # In case of multiple authors for n in name: split_name = n.strip().split() if len(split_name) >= 2: if split_name[0] not in {"The"}: self.first_names.add(split_name[0]) self.last_names.add( " ".join(split_name[1:]) ) # Joining multi-part last names else: split_name = name.strip().split() if len(split_name) >= 2: if split_name[0] not in {"The"}: self.first_names.add(split_name[0]) self.last_names.add( " ".join(split_name[1:]) ) # Joining multi-part last names def __init__(self): self._extract_authorship_info_from_stdlib() self._extract_names() class DocxGenerator: """DocxGenerator - generates a DOCX file with text. Usage example: .. code-block:: python from pathlib import Path from fake import FAKER Path("/tmp/example.docx").write_bytes( DocxGenerator(FAKER).create(nb_pages=100) ) """ def __init__(self, faker: "Faker") -> None: self.faker = faker def _create_page(self, text: str, is_last_page: bool) -> str: # Split the text into lines by \n lines = text.split("\n") # Wrap each line in the required XML and add a line break between them page_content = "" for line in lines: page_content += f"{line}" page_content += "" # Add a page break if this is not the last page if not is_last_page: page_content += '' return page_content def create( self, nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, ) -> bytes: if not nb_pages and not texts: raise ValueError( "Either `nb_pages` or `texts` arguments shall be given." ) if texts: nb_pages = len(texts) else: texts = self.faker.sentences(nb=nb_pages) if metadata: metadata.add_content(texts) # type: ignore # Construct the main document content document_content = DOCX_TPL_DOC_HEADER for i, page_text in enumerate(texts): # type: ignore document_content += self._create_page( page_text, i == nb_pages - 1 # type: ignore ) document_content += DOCX_TPL_DOC_FOOTER # Basic structure of a DOCX file docx_structure = { "word/document.xml": document_content.encode(), "_rels/.rels": DOC_TPL_DOC_STRUCTURE_RELS, "word/_rels/document.xml.rels": DOC_TPL_DOC_STRUCTURE_WORD_RELS, "word/styles.xml": DOC_TPL_DOC_STRUCTURE_WORD_STYLES, "[Content_Types].xml": DOC_TPL_DOC_STRUCTURE_CONTENT_TYPES, } # Create the DOCX file (ZIP archive) docx_bytes = io.BytesIO() with zipfile.ZipFile(docx_bytes, "w") as docx: for path, content in docx_structure.items(): docx.writestr(path, content) return docx_bytes.getvalue() class OdtGenerator: """OdtGenerator - generates an ODT file with text. Usage example: .. code-block:: python from pathlib import Path from fake import FAKER Path("/tmp/example.odt").write_bytes( OdtGenerator(FAKER).create(nb_pages=100) ) """ def __init__(self, faker: "Faker") -> None: self.faker = faker def _escape_xml(self, text: str) -> str: """Escapes XML special characters in the given text. :param text: The text to escape. :return: Escaped text. :rtype: str """ return ( text.replace("&", "&") .replace("<", "<") .replace(">", ">") .replace('"', """) .replace("'", "'") ) def _create_page(self, text: str) -> str: """Creates a paragraph with line breaks based on '\n' in the text. :param text: The text content with '\n' indicating where line breaks should be. :return: A string representing the XML of the paragraph with line breaks. :rtype: str """ # Split the text by '\n' to determine where to insert line breaks lines = text.split("\n") # Initialize the paragraph XML with the desired style paragraph_xml = '' # Iterate over each line and insert where needed for i, line in enumerate(lines): # Escape XML special characters in the line escaped_line = self._escape_xml(line) paragraph_xml += escaped_line if i < len(lines) - 1: paragraph_xml += "" # Close the paragraph tag paragraph_xml += "" return paragraph_xml def create( self, nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, ) -> bytes: if not nb_pages and not texts: raise ValueError("Either `nb_pages` or `texts` must be provided.") if texts: nb_pages = len(texts) else: texts = self.faker.sentences(nb=nb_pages) if metadata: metadata.add_content(texts) # type: ignore # Prepare the XML content with page breaks content_xml = f""" {"".join(self._create_page(text) for text in texts)} """ # Prepare the XML for styles (including style for page break) styles_xml = """ """ # Create the ODT file (ZIP archive) odt_bytes = io.BytesIO() with zipfile.ZipFile(odt_bytes, "w") as odt: # Add the mimetype file (needs to be the first file in the # archive and uncompressed) odt.writestr( "mimetype", "application/vnd.oasis.opendocument.text", zipfile.ZIP_STORED, ) # Add the content and styles files odt.writestr("content.xml", content_xml.encode("utf-8")) odt.writestr("styles.xml", styles_xml.encode("utf-8")) # Add the manifest file odt.writestr( "META-INF/manifest.xml", """ """.encode( "utf-8" ), ) return odt_bytes.getvalue() class RtfGenerator: """RtfGenerator - generates an RTF file with text. Usage example: .. code-block:: python from pathlib import Path from fake import FAKER Path("/tmp/example.rtf").write_bytes( RtfGenerator(FAKER).create(nb_pages=5) ) """ def __init__(self, faker: "Faker") -> None: self.faker = faker def _escape(self, text: str) -> str: """Escape backslashes, braces and unicode characters for RTF.""" # Basic escaping of backslash and braces; extend as needed. return ( text.replace("\\", r"\\") .replace("{", r"\{") .replace("}", r"\}") # TODO: for full unicode support \uXXXX escapes are needed ) def _create_page(self, text: str, is_last_page: bool) -> str: # Split into lines, wrap each as a paragraph paragraphs = [] for line in text.split("\n"): esc = self._escape(line) paragraphs.append(rf"\pard\sa200\sl276\slmult1 {esc}\par") page_rtf = "\n".join(paragraphs) # Insert a page break if not the last page if not is_last_page: page_rtf += r"\page" return page_rtf def create( self, nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional["MetaData"] = None, ) -> bytes: if not nb_pages and not texts: raise ValueError("Either `nb_pages` or `texts` must be provided.") if texts: nb_pages = len(texts) else: texts = self.faker.sentences(nb=nb_pages) # generate dummy texts if metadata: metadata.add_content(texts) # type: ignore # Build the full RTF document content = [ RTF_HEADER, RTF_FONT_TABLE, RTF_COLOR_TABLE, RTF_DOCUMENT_START, ] for i, page_text in enumerate(texts): # type: ignore content.append(self._create_page(page_text, i == nb_pages - 1)) # type: ignore content.append(RTF_DOCUMENT_END) # Return bytes return "\n".join(content).encode("utf-8") class EpubGenerator: """EpubGenerator - generates a minimal EPUB file with text pages.""" def __init__(self, faker: "Faker") -> None: self.faker = faker def _escape(self, text: str) -> str: """Basic escape for XML.""" return (text.replace("&", "&") .replace("<", "<") .replace(">", ">")) def _create_xhtml(self, text: str, index: int) -> bytes: escaped = self._escape(text) xhtml = f""" Page {index}
{escaped.replace(chr(10), '
')}
""" return xhtml.encode("utf-8") def _create_opf(self, nb_pages: int) -> bytes: manifest_items = [] spine_items = [] for i in range(1, nb_pages+1): manifest_items.append( f'' ) spine_items.append(f'') manifest = "\n ".join(manifest_items) spine = "\n ".join(spine_items) opf = f""" Fake Document en fake-book-id {manifest} {spine} """ return opf.encode("utf-8") def _create_ncx(self, nb_pages: int) -> bytes: navpoints = [ f""" Page {i} """ for i in range(1, nb_pages + 1) ] navbody = "\n ".join(navpoints) ncx = f""" Fake Document {navbody} """ return ncx.encode("utf-8") def create( self, nb_pages: Optional[int] = None, texts: Optional[List[str]] = None, metadata: Optional["MetaData"] = None, ) -> bytes: if not nb_pages and not texts: raise ValueError("Either `nb_pages` or `texts` must be provided.") if texts: nb_pages = len(texts) else: texts = self.faker.sentences(nb=nb_pages) # type: ignore if metadata: metadata.add_content(texts) # type: ignore buf = io.BytesIO() # EPUB requires mimetype as first file, uncompressed with zipfile.ZipFile(buf, "w") as epub: epub.writestr( "mimetype", EPUB_MIMETYPE, compress_type=zipfile.ZIP_STORED ) # Container epub.writestr("META-INF/container.xml", EPUB_CONTAINER_XML) # XHTML pages for idx, page in enumerate(texts, start=1): # type: ignore epub.writestr( f"OEBPS/page{idx}.xhtml", self._create_xhtml(page, idx) ) # OPF package epub.writestr("OEBPS/content.opf", self._create_opf(nb_pages)) # NCX epub.writestr("OEBPS/toc.ncx", self._create_ncx(nb_pages)) return buf.getvalue() class JpgGenerator: GRAY_1_PX_JPG = ( b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00" b"\xff\xdb\x00C\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xc0\x00\x0b\x08\x00\x01\x00\x01\x01\x01\x11\x00\xff\xc4\x00\x14" b"\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\xff\xda\x00\x08\x01\x01\x00\x00?\x00?\xff\xd9" ) GRAY_1_PX_JPG_BYTEARRAY = bytearray(GRAY_1_PX_JPG) RED_1_PX_JPG = ( b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00" b"\xff\xdb\x00C\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xdb\x00C\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b'\xff\xc0\x00\x11\x08\x00\x01\x00\x01\x03\x01"\x00\x02\x11\x01\x03\x11' b"\x01\xff\xc4\x00\x15\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x02\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xc4\x00\x15\x01" b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" b"\x03\xff\xc4\x00\x14\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11" b"\x00?\x00\x90\x02\x8f\xff\xd9" ) RED_1_PX_JPG_BYTEARRAY = bytearray(RED_1_PX_JPG) YELLOW_1_PX_JPG = ( b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00" b"\xff\xdb\x00C\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xdb\x00C\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b'\xff\xc0\x00\x11\x08\x00\x01\x00\x01\x03\x01"\x00\x02\x11\x01\x03\x11' b"\x01\xff\xc4\x00\x15\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x02\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xc4\x00\x15\x01" b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" b"\x03\xff\xc4\x00\x14\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11" b"\x00?\x00\xb0\x13/\xff\xd9" ) YELLOW_1_PX_JPG_BYTEARRAY = bytearray(YELLOW_1_PX_JPG) BLUE_1_PX_JPG = ( b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00" b"\xff\xdb\x00C\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xdb\x00C\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b'\xff\xc0\x00\x11\x08\x00\x01\x00\x01\x03\x01"\x00\x02\x11\x01\x03\x11' b"\x01\xff\xc4\x00\x15\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x02\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xc4\x00\x15\x01" b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" b"\x03\xff\xc4\x00\x14\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11" b"\x00?\x00\x80\x14\x0f\xff\xd9" ) BLUE_1_PX_JPG_BYTEARRAY = bytearray(BLUE_1_PX_JPG) GREEN_1_PX_JPG = ( b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00" b"\xff\xdb\x00C\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xdb\x00C\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b'\xff\xc0\x00\x11\x08\x00\x01\x00\x01\x03\x01"\x00\x02\x11\x01\x03\x11' b"\x01\xff\xc4\x00\x15\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x01\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xc4\x00\x14\x01" b"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02" b"\xff\xc4\x00\x14\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11\x00?" b"\x00\xa0\x00?\xff\xd9" ) GREEN_1_PX_JPG_BYTEARRAY = bytearray(GREEN_1_PX_JPG) BLACK_1_PX_JPG = ( b"\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00" b"\xff\xdb\x00C\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xdb\x00C\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" b'\xff\xc0\x00\x11\x08\x00\x01\x00\x01\x03\x01"\x00\x02\x11\x01\x03\x11' b"\x01\xff\xc4\x00\x15\x00\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x03\xff\xc4\x00\x14\x10\x01\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xc4\x00\x14\x01" b"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\xff\xc4\x00\x14\x11\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" b"\x00\x00\x00\x00\x00\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11\x00?" b"\x00\x98\x00\xff\xd9" ) BLACK_1_PX_JPG_BYTEARRAY = bytearray(BLACK_1_PX_JPG) COLORS = { (0, 255, 0): GREEN_1_PX_JPG_BYTEARRAY, (255, 255, 0): YELLOW_1_PX_JPG_BYTEARRAY, (255, 0, 0): RED_1_PX_JPG_BYTEARRAY, (0, 0, 255): BLUE_1_PX_JPG_BYTEARRAY, (0, 0, 0): BLACK_1_PX_JPG_BYTEARRAY, (128, 128, 128): GRAY_1_PX_JPG_BYTEARRAY, } @classmethod def euclidean_distance(cls, color1, color2): return math.sqrt(sum((a - b) ** 2 for a, b in zip(color1, color2))) @classmethod def detect_closest_color(cls, color: Tuple[int, int, int]) -> bytearray: closest = None min_distance = float("inf") for ref_color, color_name in cls.COLORS.items(): distance = cls.euclidean_distance(color, ref_color) if distance < min_distance: min_distance = distance closest = color_name return closest @classmethod def find_marker(cls, jpeg_bytes, marker) -> int: """Helper function to find a marker.""" marker_bytes = marker index = jpeg_bytes.find(marker_bytes) if index == -1: raise ValueError(f"Marker {marker} not found.") return index @classmethod def generate( cls, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (128, 128, 128), ) -> bytes: """Create a JPG image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format (tuple of three integers). :return: Byte content of the JPG image. :rtype: bytes """ original = cls.detect_closest_color(color) width, height = size jpeg = original.copy() # Step 1: Update the SOF0 marker with new dimensions sof0 = b"\xFF\xC0" sof0_index = cls.find_marker(jpeg, sof0) # SOF0 structure: # [Marker] # [Length] # [Precision] # [Height] # [Width] # [Components] # [Component Spec...] # Length is 2 bytes, Precision is 1 byte, Height and Width are 2 bytes # each. # Components: 1 byte ID, 1 byte Sampling factors, 1 byte Quantization # table number. # Extract current height and width (for 1x1 image) # Height is at sof0_index + 5 and sof0_index + 6 # Width is at sof0_index + 7 and sof0_index + 8 # We need to modify these to new_height and new_width # Pack new height and width as big-endian unsigned shorts new_height_bytes = struct.pack(">H", height) new_width_bytes = struct.pack(">H", width) # Replace height and width in the JPEG bytes jpeg[sof0_index + 5] = new_height_bytes[0] jpeg[sof0_index + 6] = new_height_bytes[1] jpeg[sof0_index + 7] = new_width_bytes[0] jpeg[sof0_index + 8] = new_width_bytes[1] # Step 2: Locate the Start of Scan (SOS) marker sos = b"\xFF\xDA" sos_index = cls.find_marker(jpeg, sos) # SOS structure: # [Marker] # [Length] # [Components] # [Component Spec...] # [Start & End of Spectral Selection] # [Successive Approximation] # Extract the length of the SOS segment to find where image data starts sos_length = struct.unpack(">H", jpeg[sos_index + 2 : sos_index + 4])[0] image_data_start = sos_index + 2 + sos_length # Locate the End of Image (EOI) marker eoi = b"\xFF\xD9" eoi_index = jpeg.find(eoi, image_data_start) if eoi_index == -1: eoi_index = 0 # raise ValueError("EOI marker not found.") # Step 3: Extract the original image data (between SOS and EOI) original_image_data = jpeg[image_data_start:eoi_index] # Step 4: Determine the number of 8x8 blocks needed blocks_per_row = (width + 7) // 8 # Ceiling division blocks_per_col = (height + 7) // 8 total_blocks = blocks_per_row * blocks_per_col # Step 5: Replicate the image data for each block # For a constant gray image, each block's data is identical replicated_image_data = original_image_data * total_blocks # Optional: If the image size isn't a multiple of 8, padding might be # necessary. # However, JPEG decoders typically ignore the extra padding, so we can # proceed. # Step 6: Assemble the new JPEG bytes new_jpeg = ( jpeg[:image_data_start] + replicated_image_data + jpeg[eoi_index:] ) return bytes(new_jpeg) class ProviderRegistryItem(str): __slots__ = ("tags",) tags: Optional[Tuple[str, ...]] def __new__(cls, value, *args, **kwargs): obj = str.__new__(cls, value) obj.tags = () return obj # Global registry for provider methods UID_REGISTRY: Dict[str, "Faker"] = {} ALIAS_REGISTRY: Dict[str, "Faker"] = {} PROVIDER_REGISTRY: Dict[str, Set[ProviderRegistryItem]] = defaultdict(set) class Provider: def __init__( self, func: Callable, tags: Optional[Tuple[str, ...]] = None, ) -> None: self.func = func self.is_provider = True self.registered_name = None self.tags = tags def __set_name__(self, owner, name): module = owner.__module__ class_name = owner.__name__ class_qualname = f"{module}.{class_name}" self.registered_name = f"{module}.{class_name}.{name}" func_name = ProviderRegistryItem(self.func.__name__) func_name.tags = self.tags PROVIDER_REGISTRY[class_qualname].add(func_name) def __get__(self, instance, owner): # Return a method bound to the instance or the unbound function return self.func.__get__(instance, owner) def provider(*args: Any, tags: Optional[Tuple[str, ...]] = None) -> Callable: # Decorator is used without arguments if args and callable(args[0]): return Provider(args[0]) # Decorator is used with arguments def wrapper(func: Callable) -> Provider: return Provider(func, tags=tags) return wrapper class Faker: """fake.py - simplified, standalone alternative with no dependencies. ---- Usage example: .. code-block:: python 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: .. code-block:: python 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: .. code-block:: python 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. """ def __init__(self, alias: Optional[str] = None) -> None: self._words: List[str] = [] self._first_names: List[str] = [] self._last_names: List[str] = [] self._cities: List[str] = [] self._countries: List[str] = [] self._geo_locations: List[str] = [] self._country_codes: List[str] = [] self._locales: List[str] = [] self.uid = f"{self.__class__.__module__}.{self.__class__.__name__}" if alias and alias in ALIAS_REGISTRY: LOGGER.warning( f"Alias '{alias}' already registered. " f"Using '{self.uid}' as alias instead." ) alias = None self.alias = alias or self.uid if self.uid not in UID_REGISTRY: UID_REGISTRY[self.uid] = self if self.alias not in ALIAS_REGISTRY: ALIAS_REGISTRY[self.alias] = self self.load_data() def load_data(self): self.load_words() self.load_names() self.load_geo_locations() self.load_locales_and_country_codes() @staticmethod def get_by_uid(uid: str) -> Union["Faker", None]: return UID_REGISTRY.get(uid) @staticmethod def get_by_alias(alias: str) -> Union["Faker", None]: return ALIAS_REGISTRY.get(alias) def load_words(self) -> None: with contextlib.redirect_stdout(io.StringIO()): # Dynamically import 'this' module this = __import__("this") zen_encoded: str = this.s translation_map: Dict[str, str] = {v: k for k, v in this.d.items()} zen: str = self._rot13_translate(zen_encoded, translation_map) self._words = ( zen.translate(str.maketrans("", "", string.punctuation)) .lower() .split() ) def load_names(self) -> None: authorship_data = AuthorshipData() self._first_names = list(authorship_data.first_names) self._last_names = list(authorship_data.last_names) def load_geo_locations(self) -> None: cities: Set[str] = set() countries: Set[str] = set() geo_locations: Set[str] = set() add_city = cities.add add_country = countries.add add_geo_location = geo_locations.add for tz in zoneinfo.available_timezones(): parts = tz.split("/") _parts = [ part.replace("_", " ") for part in parts if part and not UNWANTED_GEO_PATTERN.match(part) ] if _parts: add_geo_location("/".join(_parts)) # Ignore single-part entries that match our exclusion pattern if len(parts) == 1: if not UNWANTED_GEO_PATTERN.match(parts[0]): country = parts[0].replace("_", "") add_country(country) # Extract cities for Asia and Europe elif ( parts[0] in ["Asia", "Europe"] and len(parts) > 1 # Check to ensure there is a second part ): city = parts[1].replace("_", " ") add_city(city) self._cities = list(cities) self._countries = list(countries) self._geo_locations = list(geo_locations) def load_locales_and_country_codes(self) -> None: # Fetch all available locales from the system _available_locales = locale.locale_alias # Filter and clean the list to show more standardized locale names _locales = { __value.split(".")[0] for __key, __value in _available_locales.items() if "_" in __value } # Extract country codes from the locale keys _country_codes: Set[str] = set() add_country_code = _country_codes.add for __key in _locales: __parts = __key.split("_") if len(__parts) > 1: # Get the first two characters of the second part, # typically the country code __country_code = __parts[1][:2] # Add to set to ensure uniqueness add_country_code(__country_code.upper()) self._country_codes = list(_country_codes) self._locales = list(_locales) @staticmethod def _rot13_translate(text: str, translation_map: Dict[str, str]) -> str: return "".join([translation_map.get(c, c) for c in text]) @provider(tags=("Unique",)) def uuid(self) -> UUID: """Generate a UUID.""" return uuid.uuid4() @provider(tags=("Unique",)) def uuids(self, nb: int = 5) -> List[UUID]: """Generate a list of UUIDs.""" return [uuid.uuid4() for _ in range(nb)] @provider(tags=("Person",)) def first_name(self) -> str: """Generate a first name.""" return random.choice(self._first_names) @provider(tags=("Person",)) def first_names(self, nb: int = 5) -> List[str]: """Generate a list of first names.""" return [self.first_name() for _ in range(nb)] @provider(tags=("Person",)) def last_name(self) -> str: """Generate a last name.""" return random.choice(self._last_names) @provider(tags=("Person",)) def last_names(self, nb: int = 5) -> List[str]: """Generate a list of last names.""" return [self.last_name() for _ in range(nb)] @provider(tags=("Person",)) def name(self) -> str: """Generate a name.""" return f"{self.first_name()} {self.last_name()}" @provider(tags=("Person",)) def names(self, nb: int = 5) -> List[str]: """Generate a list of names.""" return [self.name() for _ in range(nb)] @provider(tags=("Person",)) def username(self) -> str: """Generate a username.""" return ( f"{self.word()}_{self.word()}_{self.word()}_{self.pystr()}" ).lower() @provider(tags=("Person",)) def usernames(self, nb: int = 5) -> List[str]: """Generate a list of usernames.""" return [self.username() for _ in range(nb)] @provider(tags=("Text",)) def slug(self) -> str: """Generate a slug.""" return ( f"{self.word()}-{self.word()}-{self.word()}-{self.pystr()}" ).lower() @provider(tags=("Text",)) def slugs(self, nb: int = 5) -> List[str]: """Generate a list of slugs.""" return [self.slug() for _ in range(nb)] @provider(tags=("Text",)) def word(self) -> str: """Generate a word.""" return random.choice(self._words).capitalize() @provider(tags=("Text",)) def words(self, nb: int = 5) -> List[str]: """Generate a list of words.""" return list(random.choices(self._words, k=nb)) @provider(tags=("Text",)) def sentence(self, nb_words: int = 5, suffix: str = ".") -> str: """Generate a sentence.""" return ( f"{' '.join([self.word() for _ in range(nb_words)]).capitalize()}" f"{suffix}" ) @provider(tags=("Text",)) def sentences(self, nb: int = 3) -> List[str]: """Generate a list of sentences.""" return [self.sentence() for _ in range(nb)] @provider(tags=("Text",)) def paragraph(self, nb_sentences: int = 5) -> str: """Generate a paragraph.""" return " ".join([self.sentence() for _ in range(nb_sentences)]) @provider(tags=("Text",)) def paragraphs(self, nb: int = 3) -> List[str]: """Generate a list of paragraphs.""" return [self.paragraph() for _ in range(nb)] @provider(tags=("Text",)) def text( self, nb_chars: int = 200, suffix: str = ".", allow_overflow: bool = False, ) -> str: """Generate a text.""" current_text: str = "" while len(current_text) < nb_chars: sentence: str = self.sentence() current_text += f" {sentence}" if current_text else sentence if allow_overflow: return current_text return current_text[: (nb_chars - len(suffix))] + suffix @provider(tags=("Text",)) def texts(self, nb: int = 3) -> List[str]: """Generate a list of texts.""" return [self.text() for _ in range(nb)] @provider(tags=("Filename",)) def file_name( self, prefix: Optional[str] = "", extension: str = "txt", ) -> str: """Generate a random filename.""" return os.path.basename( mktemp( suffix=f".{extension}" if extension else "", prefix=prefix or "", ) ) @provider(tags=("Filename",)) def file_path( self, prefix: Optional[str] = "", extension: str = "txt", ) -> str: """Generate a random file path.""" return mktemp( suffix=f".{extension}" if extension else "", prefix=prefix or "", ) @provider(tags=("Filename",)) def dir_path( self, depth: int = 1, ) -> str: """Generate a random dir path.""" _path_parts = [ random.choice(self._words).lower() for _ in range(depth) ] return os.path.join(*([os.path.sep] + _path_parts)) @provider(tags=("Filename",)) def file_extension(self) -> str: """Generate a random extension.""" return random.choice(FILE_EXTENSIONS) @provider(tags=("Filename",)) def mime_type(self) -> str: """Generate a random mime type.""" return random.choice(MIME_TYPES) @provider(tags=("Internet",)) def tld(self, tlds: Optional[Tuple[str, ...]] = None) -> str: """Generate a random TLD.""" return random.choice(tlds or TLDS) @provider(tags=("Internet",)) def domain_name(self, tlds: Optional[Tuple[str, ...]] = None) -> str: """Generate a random domain name.""" domain = self.word().lower() tld = self.tld(tlds) return f"{domain}.{tld}" @provider(tags=("Internet",)) def free_email_domain(self) -> str: """Generate a random free email domain.""" return random.choice(FREE_EMAIL_DOMAINS) @provider(tags=("Internet",)) def email(self, domain_names: Optional[Tuple[str, ...]] = None) -> str: """Generate a random email.""" domain = random.choice(domain_names) if domain_names else None return ( f"{'.'.join(_w.lower() for _w in self.words(3))}" f"@{domain or self.domain_name()}" ) @provider(tags=("Internet",)) def company_email( self, domain_names: Optional[Tuple[str, ...]] = None, ) -> str: """Generate a random company email.""" domain = random.choice(domain_names) if domain_names else None return f"{slugify(self.name())}@{domain or self.domain_name()}" @provider(tags=("Internet",)) def free_email( self, domain_names: Optional[Tuple[str, ...]] = None, ) -> str: """Generate a random free email.""" domain = random.choice(domain_names) if domain_names else None return f"{slugify(self.name())}@{domain or self.free_email_domain()}" @provider(tags=("Internet",)) def url( self, protocols: Optional[Tuple[str, ...]] = None, tlds: Optional[Tuple[str, ...]] = None, suffixes: Optional[Tuple[str, ...]] = None, ) -> str: """Generate a random URL.""" protocol = random.choice(protocols or URL_PROTOCOLS) suffix = random.choice(suffixes or URL_SUFFIXES) return ( f"{protocol}://" f"{self.domain_name(tlds)}" f"/{self.word().lower()}" f"{suffix}" ) @provider(tags=("Internet",)) def image_url( self, width: int = 800, height: int = 600, service_url: Optional[str] = None, ) -> str: """Generate a random image URL.""" if service_url is None: service_url = random.choice(IMAGE_SERVICES) return service_url.format(width=width, height=height) @provider(tags=("Python",)) def pyint(self, min_value: int = 0, max_value: int = 9999) -> int: """Generate a random integer. :param min_value: Min value of the generated integer. Default is 0. :param max_value: Max value of the generated integer. Default is 9999. :rtype: int :return: Random integer within the range [min_value, max_value]. """ return random.randint(min_value, max_value) @provider(tags=("Python",)) def pybool(self) -> bool: """Generate a random boolean.""" return random.choice( ( True, False, ) ) @provider(tags=("Python",)) def pystr(self, nb_chars: int = 20) -> str: """Generate a random string. :param nb_chars: Number of characters to generate. :rtype: str :return: Random string. """ return "".join(random.choices(string.ascii_letters, k=nb_chars)) @provider(tags=("Text",)) def password( self, length: int = 10, min_lower: int = 1, min_upper: int = 1, min_digits: int = 3, min_special: int = 0, ) -> str: """Generate a random password. :param length: Total length of the password. Default is 10. :param min_lower: Minimum number of lowercase letters. Default is 1. :param min_upper: Minimum number of uppercase letters. Default is 1. :param min_digits: Minimum number of digits. Default is 3. :param min_special: Minimum number of special characters. Default is 0. :rtype: str :return: Random password string. :raises: ValueError """ if length < min_lower + min_upper + min_digits + min_special: raise ValueError("Length is too short for the given constraints.") rng = secrets.SystemRandom() password_chars = ( [rng.choice(string.ascii_lowercase) for _ in range(min_lower)] + [rng.choice(string.ascii_uppercase) for _ in range(min_upper)] + [rng.choice(string.digits) for _ in range(min_digits)] + [rng.choice(string.punctuation) for _ in range(min_special)] ) remaining_length = length - ( min_lower + min_upper + min_digits + min_special ) if remaining_length > 0: all_chars = ( string.ascii_letters + string.digits + string.punctuation ) password_chars += [ rng.choice(all_chars) for _ in range(remaining_length) ] rng.shuffle(password_chars) return "".join(password_chars) @provider(tags=("Python",)) def pyfloat( self, min_value: float = 0.0, max_value: float = 10.0, ) -> float: """Generate a random float number.""" return random.uniform(min_value, max_value) @provider(tags=("Python",)) def pydecimal( self, left_digits: int = 5, right_digits: int = 2, positive: bool = True, ) -> Decimal: """Generate a random Decimal number. :param left_digits: Number of digits to the left of the decimal point. :param right_digits: Number of digits to the right of the decimal point. :param positive: If True, the number will be positive, otherwise it can be negative. :return: Random Decimal number. :rtype: Decimal :raises: ValueError """ if left_digits < 0: raise ValueError("`left_digits` must be at least 0") if right_digits < 0: raise ValueError("`right_digits` must be at least 0") if left_digits > 0: # Generate the integer part __lower = 10 ** (left_digits - 1) __upper = (10**left_digits) - 1 int_part = random.randint(__lower, __upper) else: int_part = 0 if right_digits > 0: # Generate the fractional part __lower = 10 ** (right_digits - 1) __upper = (10**right_digits) - 1 fractional_part = random.randint(__lower, __upper) else: fractional_part = 0 # Combine both parts number = Decimal(f"{int_part}.{fractional_part}") # Make the number negative if needed if not positive: number = -number return number @provider(tags=("Internet",)) def ipv4(self) -> str: """Generate a random IP v4.""" return ".".join(str(random.randint(0, 255)) for _ in range(4)) def _parse_date_string( self, date_str: str, tzinfo: timezone = timezone.utc ) -> datetime: """Parse date string with notation below into a datetime object: - '5M': 5 minutes from now - '-1d': 1 day ago - '-1H': 1 hour ago - '-365d': 365 days ago :param date_str: The date string with shorthand notation. :param tzinfo: Timezone info. :return: A datetime object representing the time offset. :rtype: datetime :raises: ValueError """ if date_str in ["now", "today"]: return datetime.now(tzinfo) match = re.match(r"([+-]?\d+)([dHM])", date_str) if not match: raise ValueError( "Date string format is incorrect. Expected formats like " "'-1d', '+2H', '-30M'." ) value, unit = match.groups() value = int(value) if unit == "d": # Days return datetime.now(tzinfo) + timedelta(days=value) elif unit == "H": # Hours return datetime.now(tzinfo) + timedelta(hours=value) # Otherwise it's minutes return datetime.now(tzinfo) + timedelta(minutes=value) @provider(tags=("Date/Time",)) def date( self, start_date: str = "-7d", end_date: str = "+0d", tzinfo: timezone = timezone.utc, ) -> date: """Generate random date between `start_date` and `end_date`. :param start_date: The start date from which the random date should be generated in the shorthand notation. :param end_date: The end date up to which the random date should be generated in the shorthand notation. :param tzinfo: The timezone. :return: A string representing the formatted date. :rtype: date """ start_datetime = self._parse_date_string(start_date, tzinfo) end_datetime = self._parse_date_string(end_date, tzinfo) time_between_dates = (end_datetime - start_datetime).days random_days = random.randrange( time_between_dates + 1 ) # Include the end date random_date = start_datetime + timedelta(days=random_days) return random_date.date() @provider(tags=("Date/Time",)) def date_time( self, start_date: str = "-7d", end_date: str = "+0d", tzinfo: timezone = timezone.utc, ) -> datetime: """Generate a random datetime between `start_date` and `end_date`. :param start_date: The start datetime from which the random datetime should be generated in the shorthand notation. :param end_date: The end datetime up to which the random datetime should be generated in the shorthand notation. :param tzinfo: The timezone. :return: A string representing the formatted datetime. :rtype: datetime """ start_datetime = self._parse_date_string(start_date, tzinfo) end_datetime = self._parse_date_string(end_date, tzinfo) time_between_datetimes = int( (end_datetime - start_datetime).total_seconds() ) random_seconds = random.randrange( time_between_datetimes + 1 ) # Include the end date time random_date_time = start_datetime + timedelta(seconds=random_seconds) return random_date_time @provider(tags=("Date/Time",)) def year(self, start_year: int = 1900, end_year: int = 2100) -> int: """Generate a random year between start_year and end_year (inclusive). :param start_year: The lower bound for the random year. :param end_year: The upper bound for the random year. :return: A random year as an integer. :rtype: int """ return random.randint(start_year, end_year) @provider(tags=("Date/Time",)) def time(self, fmt: str = "%H:%M:%S") -> str: """Generate a random time string formatted according to `fmt`. :param fmt: The format to use. :return: A random time string formatted according to `fmt`. :rtype: str """ hour = self.pyint(min_value=0, max_value=23) minute = self.pyint(min_value=0, max_value=59) second = self.pyint(min_value=0, max_value=59) return time(hour, minute, second).strftime(fmt) @provider(tags=("Binary", "Document",)) def pdf( self, nb_pages: int = 1, generator: Union[ Type[TextPdfGenerator], Type[GraphicPdfGenerator] ] = GraphicPdfGenerator, metadata: Optional[MetaData] = None, **kwargs, ) -> bytes: """Create a PDF document of a given size.""" _pdf = generator(faker=self) return _pdf.create(nb_pages=nb_pages, metadata=metadata, **kwargs) @provider(tags=("Binary", "Document",)) def text_pdf( self, nb_pages: int = 1, generator: Type[TextPdfGenerator] = TextPdfGenerator, metadata: Optional[MetaData] = None, **kwargs, ) -> bytes: """Create a PDF document of a given size.""" return self.pdf( nb_pages=nb_pages, generator=generator, metadata=metadata, **kwargs, ) @provider(tags=("Binary", "Image",)) def png( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), ) -> bytes: """Create a PNG image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format (tuple of three integers). :return: Byte content of the PNG image. :rtype: bytes """ width, height = size # PNG file format header png_header = b"\x89PNG\r\n\x1a\n" # IHDR chunk: width, height, bit depth, colour type, compression, # filter, interlace ihdr_content = ( width.to_bytes(4, byteorder="big") + height.to_bytes(4, byteorder="big") + b"\x08\x02\x00\x00\x00" ) ihdr = b"IHDR" + ihdr_content ihdr_chunk = ( len(ihdr_content).to_bytes(4, byteorder="big") + ihdr + zlib.crc32(ihdr).to_bytes(4, byteorder="big") ) # IDAT chunk: image data raw_data = ( b"\x00" + bytes(color) * width ) # No filter, and RGB data for each pixel compressed_data = zlib.compress(raw_data * height) # Compress the data idat_chunk = ( len(compressed_data).to_bytes(4, byteorder="big") + b"IDAT" + compressed_data + zlib.crc32(b"IDAT" + compressed_data).to_bytes( length=4, byteorder="big", ) ) # IEND chunk: marks the image end iend_chunk = b"\x00\x00\x00\x00IEND\xAE\x42\x60\x82" # Combine all chunks png_data = png_header + ihdr_chunk + idat_chunk + iend_chunk return png_data @provider(tags=("Binary", "Image",)) def svg( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), ) -> bytes: """Create an SVG image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format (tuple of three integers). :return: Byte content of the SVG image. :rtype: bytes """ width, height = size return SVG_TPL.format(width=width, height=height, color=color).encode() @provider(tags=("Binary", "Image",)) def bmp( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), ) -> bytes: """Create a BMP image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format (tuple of three integers). :return: Byte content of the BMP image. :rtype: bytes """ width, height = size # BMP Header and DIB Header (BITMAPINFOHEADER format) file_header = b"BM" # Signature dib_header = b"\x28\x00\x00\x00" # DIB Header size (40 bytes) # Image width and height width_bytes = width.to_bytes(4, byteorder="little") height_bytes = height.to_bytes(4, byteorder="little") # Image pixel data # BMP files are padded to be a multiple of 4 bytes wide row_padding = (4 - (3 * width) % 4) % 4 pixel_data = bytes(color[::-1]) * width + b"\x00" * row_padding image_data = pixel_data * height # File size file_size = ( 14 + 40 + len(image_data) ) # 14 bytes file header, 40 bytes DIB header file_size_bytes = file_size.to_bytes(4, byteorder="little") # Final assembly of the BMP file return ( file_header + file_size_bytes + b"\x00\x00\x00\x00" + b"\x36\x00\x00\x00" # Reserved 4 bytes # Pixel data offset (54 bytes: 14 for file header, 40 for DIB # header) + dib_header + width_bytes + height_bytes + b"\x01\x00" + b"\x18\x00" # Number of colour planes + b"\x00\x00\x00\x00" # Bits per pixel (24 for RGB) + len(image_data).to_bytes( # Compression method (0 for none) 4, byteorder="little" ) + b"\x13\x0B\x00\x00" # Size of the raw bitmap data # Print resolution of the image (2835 pixels/meter) + b"\x13\x0B\x00\x00" + b"\x00\x00\x00\x00" + b"\x00\x00\x00\x00" # Number of colours in the palette + image_data # Important colours ) @provider(tags=("Binary", "Image",)) def gif( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), ) -> bytes: """Create a GIF image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format (tuple of three integers). :return: Byte content of the GIF image. :rtype: bytes """ width, height = size # Header header = b"GIF89a" # Logical Screen Descriptor screen_width = width.to_bytes(2, byteorder="little") screen_height = height.to_bytes(2, byteorder="little") # Global Colour Table Flag set to 1, Colour resolution, and Sort Flag # to 0 packed_field = b"\xF7" bg_color_index = b"\x00" # Background Colour Index pixel_aspect_ratio = b"\x00" # No aspect ratio information # Global Colour Table. # Since it's a single colour, we only need one entry in our table, # rest are black. # Each colour is 3 bytes (RGB). color_table = bytes(color) + b"\x00" * (3 * 255) # Image Descriptor image_descriptor = ( b"\x2C" + b"\x00\x00\x00\x00" + screen_width + screen_height + b"\x00" ) # Image Data lzw_min_code_size = b"\x08" # Set to 8 for no compression # Image Data Blocks for a single colour. # Simplest LZW encoding for a single colour: clear code, followed # by colour index, end code. image_data_blocks = bytearray( [0x02, 0x4C, 0x01, 0x00] ) # Compressed data # Footer footer = b"\x3B" # Combine all parts return ( header + screen_width + screen_height + packed_field + bg_color_index + pixel_aspect_ratio + color_table + image_descriptor + lzw_min_code_size + image_data_blocks + footer ) @provider(tags=("Binary", "Image",)) def tif( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), ) -> bytes: """Create a TIF image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format (tuple of three integers). :return: Byte content of the TIF image. :rtype: bytes """ width, height = size r, g, b = color # TIFF Header # Byte order indication ('II' for little endian) # Version number (42) # Offset to the first IFD (8 bytes from the beginning) tiff_header = b"II\x2A\x00\x08\x00\x00\x00" # IFD setup num_entries = 12 ifd_offset = 8 next_ifd = 0 # No next IFD # Image data starting just after IFD # (8 bytes for header + 2 + 12*num_entries + 4 for next IFD) data_offset = ifd_offset + 2 + 12 * num_entries + 4 # Entries in IFD entries = [ (256, 4, 1, width), # Image width (257, 4, 1, height), # Image height (258, 3, 3, data_offset + width * height * 3), # Bits per sample (259, 3, 1, 1), # Compression (1 = no compression) (262, 3, 1, 2), # Photometric interpretation (2 = RGB) (273, 4, 1, data_offset), # Offset to image data (277, 3, 1, 3), # Samples per pixel (278, 4, 1, height), # Rows per strip (279, 4, 1, width * height * 3), # Strip byte counts (image data size) (282, 5, 1, data_offset + width * height * 3 + 6), # XResolution placeholder offset (283, 5, 1, data_offset + width * height * 3 + 14), # YResolution placeholder offset (284, 3, 1, 1), # Planar configuration (1 = chunky) ] # Write IFD ifd = bytearray() ifd += int.to_bytes(num_entries, 2, "little") for entry in entries: tag, type_, count, value = entry ifd += int.to_bytes(tag, 2, "little") ifd += int.to_bytes(type_, 2, "little") ifd += int.to_bytes(count, 4, "little") ifd += int.to_bytes(value, 4, "little") ifd += int.to_bytes(next_ifd, 4, "little") # Image data image_data = bytes([r, g, b] * width * height) # Bits per sample values (8 bits per channel) bits_per_sample = bytes([8, 0, 8, 0, 8, 0]) # Resolution (72 dpi, stored as a rational number 72/1) resolution = (72, 1) res_bytes = int.to_bytes(resolution[0], 4, "little") res_bytes += int.to_bytes(resolution[1], 4, "little") res_bytes += res_bytes # For both X and Y resolutions # Complete TIFF file return tiff_header + ifd + image_data + bits_per_sample + res_bytes @provider(tags=("Binary", "Image",)) def ppm( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), ) -> bytes: """Create a PPM image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format, tuple of three integers: (0-255, 0-255, 0-255). :return: Byte content of the PPM image. :rtype: bytes """ width, height = size # PPM Header ppm_header = f"P6\n{width} {height}\n255\n".encode() # Image data image_data = bytearray() for _ in range(height): for _ in range(width): image_data.extend(color) # Complete PPM file return ppm_header + bytes(image_data) @provider(tags=("Binary", "Image",)) def jpg( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (128, 128, 128), ) -> bytes: """Create a JPG image of a specified size and colour. :param size: Tuple of width and height of the image in pixels. :param color: Colour of the image in RGB format, tuple of three integers: (0-255, 0-255, 0-255). :return: Byte content of the JPG image. :rtype: bytes """ return JpgGenerator.generate(size=size, color=color) @provider(tags=("Binary", "Image",)) def image( self, image_format: Literal[ "png", "svg", "bmp", "gif", "tif", "ppm", "jpg", ] = "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 colour.""" if image_format not in { "png", "svg", "bmp", "gif", "tif", "ppm", "jpg", }: raise ValueError() image_func = getattr(self, image_format) return image_func(size=size, color=color) @provider(tags=("Binary", "Audio",)) def wav( self, frequency: int = 440, duration: int = 1, volume: Union[float, int] = 0.5, sample_rate: int = 44100, ) -> bytes: """Create a WAV audio. :param frequency: The frequency of the tone in Hz. :param duration: Duration of the tone in seconds. :param volume: Volume of the tone, scale between 0.0 and 1.0. :param sample_rate: Sampling rate in Hz. :return: Byte content of the WAV audio. :rtype: bytes """ num_samples = int(sample_rate * duration) samples_per_cycle = int(sample_rate / frequency) cycle = array.array( "h" ) # 'h' is the typecode for signed short integers # Precompute one cycle of the sine wave for i in range(samples_per_cycle): sample = ( volume * 32767 * math.sin(2 * math.pi * i / samples_per_cycle) ) cycle.append(int(sample)) # Generate full data by repeating the cycle data = (cycle * (1 + num_samples // samples_per_cycle))[:num_samples] # Prepare WAV file structure in a BytesIO stream buffer = io.BytesIO() with wave.open(buffer, "w") as _wav_file: _wav_file.setnchannels(1) # Mono _wav_file.setsampwidth(2) # 2 bytes per sample (16-bit) _wav_file.setframerate(sample_rate) _wav_file.writeframes(data.tobytes()) # Get the bytes wav_bytes = buffer.getvalue() buffer.close() return wav_bytes @provider(tags=("Binary", "Document",)) def docx( self, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, ) -> bytes: """Create a DOCX document.""" _docx = DocxGenerator(faker=self) return _docx.create(nb_pages=nb_pages, texts=texts, metadata=metadata) @provider(tags=("Binary", "Document",)) def rtf( self, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional["MetaData"] = None, ) -> bytes: """Create an RTF document.""" _rtf = RtfGenerator(faker=self) return _rtf.create(nb_pages=nb_pages, texts=texts, metadata=metadata) @provider(tags=("Binary", "Document",)) def epub( self, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional["MetaData"] = None, ) -> bytes: """Create a minimal EPUB document.""" _epub = EpubGenerator(faker=self) return _epub.create(nb_pages=nb_pages, texts=texts, metadata=metadata) @provider(tags=("Binary", "Document",)) def odt( self, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, ) -> bytes: """Create a ODT document.""" _odt = OdtGenerator(faker=self) return _odt.create(nb_pages=nb_pages, texts=texts, metadata=metadata) @provider(tags=("Binary",)) def bin( self, length: int = 16, ) -> bytes: """Create random bytes.""" return os.urandom(length) @provider(tags=("Binary", "Archive",)) def zip(self, options: Optional[Dict[str, Any]] = None, **kwargs): """Create a ZIP archive file as bytes. Usage example. A complex case. .. code-block:: python from fake import create_inner_txt_file, FAKER zip_file = FAKER.zip( options={ "count": 5, "create_inner_file_func": create_inner_txt_file, "create_inner_file_args": { "prefix": "zzz_file_", }, "directory": "zzz", }, ) """ data: Dict[str, Any] = { "inner": {}, "files": [], } fs_storage = FileSystemStorage() # Specific if options: # Complex case _count = options.get("count", 1) _create_inner_file_func = options.get( "create_inner_file_func", create_inner_txt_file ) _create_inner_file_args = options.get("create_inner_file_args", {}) _dir_path = Path("") _directory = options.get("directory", "") else: # Defaults _count = 1 _create_inner_file_func = create_inner_txt_file _create_inner_file_args = {} _dir_path = Path("") _directory = "" _zip_content = BytesIO() with zipfile.ZipFile(_zip_content, "w") as __fake_file: _kwargs = {} _kwargs.update(_create_inner_file_args) # If _create_inner_file_func returns a list of values if returns_list(_create_inner_file_func): _files = _create_inner_file_func( storage=fs_storage, **_kwargs, ) for __file in _files: data["inner"][str(__file)] = __file __file_abs_path = fs_storage.abspath(__file) __fake_file.write( __file_abs_path, arcname=Path(_directory) / Path(__file).name, ) os.remove(__file_abs_path) # Clean up temporary files data["files"].append(Path(_directory) / Path(__file).name) # If _create_inner_file_func returns a single value else: for __i in range(_count): __file = _create_inner_file_func( storage=fs_storage, **_kwargs, ) data["inner"][str(__file)] = __file __file_abs_path = fs_storage.abspath(__file) __fake_file.write( __file_abs_path, arcname=Path(_directory) / Path(__file).name, ) os.remove(__file_abs_path) # Clean up temporary files data["files"].append(Path(_directory) / Path(__file).name) raw_content = BytesValue(_zip_content.getvalue()) raw_content.data = data return raw_content @provider(tags=("Binary", "Archive",)) def tar( self, options: Optional[Dict[str, Any]] = None, compression: Optional[Literal["gz", "bz2", "xz"]] = None, **kwargs, ) -> BytesValue: """Generate a TAR archive file as bytes. :param options: Options (non-structured) for complex types, such as ZIP. :param compression: Desired compression. Can be None or `gz`, `bz2` or `xz`. :param **kwargs: Additional keyword arguments to pass to the function. :rtype: BytesValue :return: Relative path (from root directory) of the generated file or raw content of the file. Usage example. Complex case. .. code-block:: python from fake import create_inner_txt_file, FAKER tar_file = FAKER.tar( prefix="ttt_archive_", options={ "count": 5, "create_inner_file_func": create_inner_txt_file, "create_inner_file_args": { "prefix": "ttt_file_", }, "directory": "ttt", }, ) """ data: Dict[str, Any] = { "inner": {}, "files": [], } fs_storage = FileSystemStorage() # Specific if options: # Complex case _count = options.get("count", 1) _create_inner_file_func = options.get( "create_inner_file_func", create_inner_txt_file ) _create_inner_file_args = options.get("create_inner_file_args", {}) _dir_path = Path("") _directory = options.get("directory", "") else: # Defaults _count = 1 _create_inner_file_func = create_inner_txt_file _create_inner_file_args = {} _dir_path = Path("") _directory = "" _tar_content = BytesIO() _mode = "w" if compression and compression in TAR_COMPRESSION_OPTIONS: _mode += f":{compression}" with tarfile.open(fileobj=_tar_content, mode=_mode) as __fake_file: _kwargs = {} _kwargs.update(_create_inner_file_args) # If _create_inner_file_func returns a list of values if returns_list(_create_inner_file_func): _files = _create_inner_file_func( storage=fs_storage, **_kwargs, ) for __file in _files: data["inner"][str(__file)] = __file __file_abs_path = fs_storage.abspath(__file) __fake_file.add( __file_abs_path, arcname=Path(_directory) / Path(__file).name, ) os.remove(__file_abs_path) # Clean up temporary files data["files"].append(Path(_directory) / Path(__file).name) # If _create_inner_file_func returns a single value else: for __i in range(_count): __file = _create_inner_file_func( storage=fs_storage, **_kwargs, ) data["inner"][str(__file)] = __file __file_abs_path = fs_storage.abspath(__file) __fake_file.add( __file_abs_path, arcname=Path(_directory) / Path(__file).name, ) os.remove(__file_abs_path) # Clean up temporary files data["files"].append(Path(_directory) / Path(__file).name) raw_content = BytesValue(_tar_content.getvalue()) raw_content.data = data return raw_content @provider(tags=("Archive", "Binary", "Email")) def eml( self, options: Optional[Dict[str, Any]] = None, content: Optional[str] = None, subject: Optional[str] = None, cte_type: Optional[str] = None, policy: Optional[Policy] = None, **kwargs, ) -> BytesValue: """Generate an EML file bytes. :param options: Options (non-structured) for complex types, such as ZIP. :param content: Email body text. :param subject: Email subject. :param cte_type: Content-Transfer-Encoding (CTE) type. :param policy: Email message policy. :param **kwargs: Additional keyword arguments to pass to the function. :rtype: BytesValue :return: Relative path (from root directory) of the generated file or raw content of the file. Usage example. A complex case. .. code-block:: python from fake import create_inner_docx_file, FAKER eml_file = FAKER.eml_file( prefix="zzz_email_", options={ "count": 5, "create_inner_file_func": create_inner_docx_file, "create_inner_file_args": { "prefix": "zzz_file_", }, } ) """ fs_storage = FileSystemStorage() if not content: content = self.text() if not subject: subject = self.sentence() data: Dict[str, Any] = { "content": f"{subject}\n {content}", "inner": {}, } # Choose the policy to use for creating and serializing if policy is None: # Clone the `default` and apply `cte_type` if given policy = default.clone(cte_type=cte_type) if cte_type else default msg = EmailMessage(policy=policy) msg["To"] = self.email() msg["From"] = self.email() msg["Subject"] = subject msg.set_content(content, cte=policy.cte_type) data.update( { "to": msg["To"], "from": msg["From"], "subject": msg["Subject"], "body": content, } ) # Specific if options: # Complex case _count = options.get("count", 1) _create_inner_file_func = options.get("create_inner_file_func") _create_inner_file_args = options.get("create_inner_file_args", {}) else: # Defaults _count = 1 _create_inner_file_func = None _create_inner_file_args = {} _kwargs = {} _kwargs.update(_create_inner_file_args) if _create_inner_file_func and callable(_create_inner_file_func): # If _create_inner_file_func returns a list of values if returns_list(_create_inner_file_func): _files = _create_inner_file_func( storage=fs_storage, **_kwargs, ) for __file in _files: data["inner"][str(__file)] = __file __file_abs_path = fs_storage.abspath(__file) _maintype, _subtype = get_mime_maintype_subtype( path=__file_abs_path, ) with open(__file_abs_path, "rb") as _fp: _file_data = _fp.read() msg.add_attachment( _file_data, maintype=_maintype, subtype=_subtype, filename=os.path.basename(__file), ) os.remove(__file_abs_path) # Clean up temporary files # If _create_inner_file_func returns a single value else: for __i in range(_count): __file = _create_inner_file_func( storage=fs_storage, **_kwargs, ) data["inner"][str(__file)] = __file __file_abs_path = fs_storage.abspath(__file) _maintype, _subtype = get_mime_maintype_subtype( path=__file_abs_path, ) with open(__file_abs_path, "rb") as _fp: _file_data = _fp.read() msg.add_attachment( _file_data, maintype=_maintype, subtype=_subtype, filename=os.path.basename(__file), ) os.remove(__file_abs_path) # Clean up temporary files raw_content = BytesValue(msg.as_bytes(policy=policy)) raw_content.data = data return raw_content @provider(tags=("Document", "File")) def pdf_file( self, nb_pages: int = 1, generator: Union[ Type[TextPdfGenerator], Type[GraphicPdfGenerator] ] = GraphicPdfGenerator, metadata: Optional[MetaData] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, **kwargs, ) -> StringValue: """Create a PDF file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="pdf", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.pdf( nb_pages=nb_pages, generator=generator, metadata=metadata, **kwargs ) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("Document", "File")) def text_pdf_file( self, nb_pages: int = 1, generator: Type[TextPdfGenerator] = TextPdfGenerator, metadata: Optional[MetaData] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, **kwargs, ) -> StringValue: """Create a text PDF file.""" return self.pdf_file( nb_pages=nb_pages, generator=generator, metadata=metadata, storage=storage, basename=basename, prefix=prefix, **kwargs, ) def _image_file( self, image_format: Literal[ "png", "svg", "bmp", "gif", "tif", "ppm", "jpg", ] = "png", size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), extension: Optional[str] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, ) -> StringValue: if storage is None: storage = FileSystemStorage() if extension is None: extension = image_format filename = storage.generate_filename( extension=extension, prefix=prefix, basename=basename, ) data = self.image(image_format=image_format, size=size, color=color) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = {"storage": storage, "filename": filename} FILE_REGISTRY.add(file) return file @provider(tags=("Image", "File")) def png_file( self, 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 colour.""" return self._image_file( image_format="png", size=size, color=color, storage=storage, basename=basename, prefix=prefix, extension=extension, ) @provider(tags=("Image", "File")) def svg_file( self, 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 colour.""" return self._image_file( image_format="svg", size=size, color=color, storage=storage, basename=basename, prefix=prefix, extension=extension, ) @provider(tags=("Image", "File")) def bmp_file( self, 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 colour.""" return self._image_file( image_format="bmp", size=size, color=color, storage=storage, basename=basename, prefix=prefix, extension=extension, ) @provider(tags=("Image", "File")) def gif_file( self, 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 colour.""" return self._image_file( image_format="gif", size=size, color=color, storage=storage, basename=basename, prefix=prefix, extension=extension, ) @provider(tags=("Image", "File")) def tif_file( self, 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 colour.""" return self._image_file( image_format="tif", size=size, color=color, extension=extension, storage=storage, basename=basename, prefix=prefix, ) @provider(tags=("Image", "File")) def ppm_file( self, 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 colour.""" return self._image_file( image_format="ppm", size=size, color=color, extension=extension, storage=storage, basename=basename, prefix=prefix, ) @provider(tags=("Image", "File")) def jpg_file( self, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (128, 128, 128), storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, extension: Optional[str] = None, ) -> StringValue: """Create a JPG image file of a specified size and colour.""" return self._image_file( image_format="jpg", size=size, color=color, extension=extension, storage=storage, basename=basename, prefix=prefix, ) @provider(tags=("Audio", "File")) def wav_file( self, frequency: int = 440, duration: int = 1, volume: Union[float, int] = 0.5, sample_rate: int = 44100, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, ) -> StringValue: """Create a WAV audio file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="wav", prefix=prefix, basename=basename, ) data = self.wav( frequency=frequency, duration=duration, volume=volume, sample_rate=sample_rate, ) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, } FILE_REGISTRY.add(file) return file @provider(tags=("Document", "File")) def docx_file( self, 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.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="docx", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.docx(nb_pages=nb_pages, texts=texts, metadata=metadata) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("Document", "File")) def rtf_file( self, 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 an RTF document file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="rtf", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.rtf(nb_pages=nb_pages, texts=texts, metadata=metadata) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("Document", "File")) def epub_file( self, 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 EPUB document file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="epub", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.epub(nb_pages=nb_pages, texts=texts, metadata=metadata) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("Document", "File")) def odt_file( self, 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.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="odt", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.odt(nb_pages=nb_pages, texts=texts, metadata=metadata) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("File",)) def bin_file( self, length: int = 16, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, **kwargs, ) -> StringValue: """Create a BIN file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="bin", prefix=prefix, basename=basename, ) data = self.bin(length=length) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, } FILE_REGISTRY.add(file) return file @provider(tags=("Archive", "File")) def zip_file( self, metadata: Optional[MetaData] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, options: Optional[Dict[str, Any]] = None, **kwargs, ) -> StringValue: """Create a ZIP archive file. Usage example. A simple case. .. code-block:: python from fake import FAKER zip_archive = FAKER.zip() Usage example. A complex case. .. code-block:: python from fake import create_inner_txt_file, FAKER zip_file = FAKER.zip( prefix="zzz_archive_", options={ "count": 5, "create_inner_file_func": create_inner_txt_file, "create_inner_file_args": { "prefix": "zzz_file_", }, "directory": "zzz", }, ) """ if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="zip", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.zip(metadata=metadata, options=options) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("Archive", "File")) def tar_file( self, metadata: Optional[MetaData] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, options: Optional[Dict[str, Any]] = None, compression: Optional[Literal["gz", "bz2", "xz"]] = None, **kwargs, ) -> StringValue: """Create a TAR archive file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="tar", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.tar( metadata=metadata, options=options, compression=compression, ) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("Archive", "Email", "File")) def eml_file( self, metadata: Optional[MetaData] = None, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, options: Optional[Dict[str, Any]] = None, content: Optional[str] = None, subject: Optional[str] = None, cte_type: Optional[str] = None, policy: Optional[Policy] = None, **kwargs, ) -> StringValue: """Create an EML file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="eml", prefix=prefix, basename=basename, ) if not metadata: metadata = MetaData() data = self.eml( metadata=metadata, options=options, content=content, subject=subject, cte_type=cte_type, policy=policy, ) storage.write_bytes(filename=filename, data=data) file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": metadata.content, } FILE_REGISTRY.add(file) return file @provider(tags=("File", "Text")) def txt_file( self, 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.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension="txt", prefix=prefix, basename=basename, ) if not text: if not nb_chars: nb_chars = 200 text = self.text(nb_chars=nb_chars) storage.write_text(filename=filename, data=text) # type: ignore file = StringValue(storage.relpath(filename)) file.data = { "storage": storage, "filename": filename, "content": text, } FILE_REGISTRY.add(file) return file @provider(tags=("File",)) def generic_file( self, content: Union[bytes, str], extension: str, storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, ) -> StringValue: """Create a generic file.""" if storage is None: storage = FileSystemStorage() filename = storage.generate_filename( extension=extension, prefix=prefix, basename=basename, ) if isinstance(content, bytes): storage.write_bytes(filename, content) else: storage.write_text(filename, content) file = StringValue(storage.relpath(filename)) file.data = { "content": content, "filename": filename, "storage": storage, } FILE_REGISTRY.add(file) return file @provider(tags=("Geographic",)) def city(self) -> str: """Get a random city.""" return random.choice(self._cities) @provider(tags=("Geographic",)) def country(self) -> str: """Get a random country.""" return random.choice(self._countries) @provider(tags=("Geographic",)) def geo_location(self) -> str: """Get a random geo-location.""" return random.choice(self._geo_locations) @provider(tags=("Geographic",)) def country_code(self) -> str: """Get a random country code.""" return random.choice(self._country_codes) @provider(tags=("Geographic",)) def locale(self) -> str: """Get a random locale.""" return random.choice(self._locales) @provider(tags=("Geographic",)) def latitude(self) -> float: """Generate a random latitude.""" return random.uniform(-90, 90) lat = latitude # noqa @provider(tags=("Geographic",)) def longitude(self) -> float: """Generate a random longitude.""" return random.uniform(-180, 180) lng = lon = longitude # noqa @provider(tags=("Geographic",)) def latitude_longitude(self) -> Tuple[float, float]: """Generate a random (latitude, longitude) pair.""" return random.uniform(-90, 90), random.uniform(-180, 180) latlng = latlon = latitude_longitude # noqa @provider(tags=("Banking",)) def iban( self, country_code: Optional[str] = None, bank_length: int = 8, account_length: int = 10, ) -> str: """Generate a random valid IBAN number.""" if not country_code: country_code = random.choice(self._country_codes) # Generate the bank number and account number bank_number = "".join( str(random.randint(0, 9)) for _ in range(bank_length) ) account_number = "".join( str(random.randint(0, 9)) for _ in range(account_length) ) # Basic Bank Account Number (BBAN) bban = bank_number + account_number # Convert country code and calculate checksum country_number = "".join( str(ord(c) - 55) for c in country_code ) # Convert letters to numbers # Temporary IBAN for checksum calculation temporary_iban = bban + country_number + "00" # Calculate the checksum using modulo 97 checksum = 98 - (int(temporary_iban) % 97) # Format checksum to be two digits checksum_str = f"{checksum:02d}" # Construct the actual IBAN iban = f"{country_code}{checksum_str}{bban}" return iban def _calculate_isbn10_checksum(self, digits: str) -> str: """Calculate ISBN-10 checksum using correct modulo 11 calculation.""" weights = range(10, 1, -1) # Weights from 10 to 2 total = sum(w * int(d) for w, d in zip(weights, digits)) remainder = total % 11 checksum = "X" if remainder == 1 else str((11 - remainder) % 11) return checksum @provider(tags=("Book",)) def isbn10(self): """Generate a random valid ISBN-10.""" # Randomly generate the first 9 digits as a string digits = "".join(str(random.randint(0, 9)) for _ in range(9)) # Calculate the checksum digit checksum = self._calculate_isbn10_checksum(digits) # Form the full ISBN-10 number isbn10 = digits + checksum # Example format: 'XXX-XXX-XXX-X', commonly used in ISBN return f"{isbn10[:3]}-{isbn10[3:6]}-{isbn10[6:9]}-{isbn10[9]}" def _isbn13_checksum(self, digits: List[str]) -> str: """Calculate the ISBN-13 checksum digit.""" total = sum( (3 if i % 2 else 1) * int(digit) for i, digit in enumerate(digits) ) checksum = (10 - (total % 10)) % 10 return str(checksum) @provider(tags=("Book",)) def isbn13(self) -> str: """Generate a random valid ISBN-13, starting with 978 or 979.""" prefix = random.choice(["978", "979"]) digits = [str(random.randint(0, 9)) for _ in range(9)] full_digits = list(prefix) + digits checksum = self._isbn13_checksum(full_digits) isbn = "".join(full_digits) + checksum return f"{isbn[0:3]}-{isbn[3:4]}-{isbn[4:7]}-{isbn[7:12]}-{isbn[12]}" @provider(tags=("Choice",)) def random_choice(self, elements: ElementType[T]) -> T: """Random choice: pick a single element from the given list.""" return random.choice(elements) random_element = random_choice # noqa @provider(tags=("Choice",)) def random_sample(self, elements: ElementType[T], length: int) -> List[T]: """Random sample: pick random `length` elements from the given list.""" return random.sample(elements, length) random_elements = random_sample # noqa @provider(tags=("Text",)) def randomise_string( self, value: str, letters: str = string.ascii_uppercase, digits: str = string.digits, ) -> str: """Randomise string: `?` is replaced with letter, `#` with number.""" result = "" for char in value: if char == "?": result += random.choice(letters) elif char == "#": result += random.choice(digits) else: result += char return result randomize_string = bothify = randomise_string # noqa @provider(tags=("Text",)) def string_template( self, template: str, wrap_chars_after: Optional[int] = None, faker: Optional["Faker"] = None, ) -> str: """String template. Generate a string by substituting placeholders in a template with fake data or provided values. :param template: Template string containing placeholders in curly braces (e.g., '{name}', '{words(nb=2)}'). Placeholders should match Faker method names or be overridden by kwargs. :param wrap_chars_after: Number of characters to wrap around. :param faker: Faker instance to use. :rtype: str :returns: String with placeholders replaced with correspondent fake values. Example: .. code-block:: python from fake import FAKER FAKER.string_template( "Hello {first_name}! I have two words for you: {words(nb=2)}" ) # "Hello Mike! I have two words for you: ['idea', 'first']" """ return StringTemplate( template=template, wrap_chars_after=wrap_chars_after, faker=faker or self, ) @provider(tags=("Text",)) def lazy_string_template( self, template: str, wrap_chars_after: Optional[int] = None, faker: Optional["Faker"] = None, ) -> "LazyStringTemplate": """Lazy string template. Generate a string by substituting placeholders in a template with fake data or provided values. :param template: Template string containing placeholders in curly braces (e.g., '{name}', '{words(nb=2)}'). Placeholders should match Faker method names or be overridden by kwargs. :param wrap_chars_after: Number of characters to wrap around. :param faker: Faker instance to use. :rtype: LazyStringTemplate :returns: String with placeholders replaced with correspondent fake values. Example: .. code-block:: python from fake import FAKER tpl = FAKER.lazy_string_template( "Hello {first_name}! I have two words for you: {words(nb=2)}" ) print(tpl) # "Hello Mike! I have two words for you: ['idea', 'first']" print(tpl) # Hello Lars! I have two words for you: ['be', 'if'] """ return LazyStringTemplate( template=template, wrap_chars_after=wrap_chars_after, faker=faker or self, ) FAKER = Faker(alias="default") def create_inner_pdf_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, nb_pages: Optional[int] = 1, generator: Union[ Type[TextPdfGenerator], Type[GraphicPdfGenerator] ] = GraphicPdfGenerator, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner PDF file.""" return FAKER.pdf_file( storage=storage, basename=basename, prefix=prefix, nb_pages=nb_pages, generator=generator, metadata=metadata, **kwargs, ) def create_inner_text_pdf_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, nb_pages: Optional[int] = 1, generator: Type[TextPdfGenerator] = TextPdfGenerator, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner text PDF file.""" return FAKER.text_pdf_file( storage=storage, basename=basename, prefix=prefix, nb_pages=nb_pages, generator=generator, metadata=metadata, **kwargs, ) def create_inner_png_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), **kwargs, ) -> StringValue: """Create inner PNG file.""" return FAKER.png_file( storage=storage, basename=basename, prefix=prefix, size=size, color=color, **kwargs, ) def create_inner_svg_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), **kwargs, ) -> StringValue: """Create inner SVG file.""" return FAKER.svg_file( storage=storage, basename=basename, prefix=prefix, size=size, color=color, **kwargs, ) def create_inner_bmp_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), **kwargs, ) -> StringValue: """Create inner BMP file.""" return FAKER.bmp_file( storage=storage, basename=basename, prefix=prefix, size=size, color=color, **kwargs, ) def create_inner_gif_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), **kwargs, ) -> StringValue: """Create inner GIF file.""" return FAKER.gif_file( storage=storage, basename=basename, prefix=prefix, size=size, color=color, **kwargs, ) def create_inner_tif_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), **kwargs, ) -> StringValue: """Create inner TIF file.""" return FAKER.tif_file( storage=storage, basename=basename, prefix=prefix, size=size, color=color, **kwargs, ) def create_inner_ppm_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (0, 0, 255), **kwargs, ) -> StringValue: """Create inner PPM file.""" return FAKER.ppm_file( storage=storage, basename=basename, prefix=prefix, size=size, color=color, **kwargs, ) def create_inner_jpg_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, size: Tuple[int, int] = (100, 100), color: Tuple[int, int, int] = (128, 128, 128), **kwargs, ) -> StringValue: """Create inner JPG file.""" return FAKER.jpg_file( storage=storage, basename=basename, prefix=prefix, size=size, color=color, **kwargs, ) def create_inner_wav_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, frequency: int = 440, duration: int = 1, volume: Union[float, int] = 0.5, sample_rate: int = 44100, **kwargs, ) -> StringValue: """Create inner WAV file.""" return FAKER.wav_file( storage=storage, basename=basename, prefix=prefix, frequency=frequency, duration=duration, volume=volume, sample_rate=sample_rate, **kwargs, ) def create_inner_docx_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner DOCX file.""" return FAKER.docx_file( storage=storage, basename=basename, prefix=prefix, nb_pages=nb_pages, texts=texts, metadata=metadata, **kwargs, ) def create_inner_rtf_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner RTF file.""" return FAKER.rtf_file( storage=storage, basename=basename, prefix=prefix, nb_pages=nb_pages, texts=texts, metadata=metadata, **kwargs, ) def create_inner_epub_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner EPUB file.""" return FAKER.epub_file( storage=storage, basename=basename, prefix=prefix, nb_pages=nb_pages, texts=texts, metadata=metadata, **kwargs, ) def create_inner_odt_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, nb_pages: Optional[int] = 1, texts: Optional[List[str]] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner ODT file.""" return FAKER.odt_file( storage=storage, basename=basename, prefix=prefix, nb_pages=nb_pages, texts=texts, metadata=metadata, **kwargs, ) def create_inner_zip_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, options: Optional[Dict[str, Any]] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner ZIP file.""" return FAKER.zip_file( storage=storage, basename=basename, prefix=prefix, options=options, metadata=metadata, **kwargs, ) def create_inner_tar_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, options: Optional[Dict[str, Any]] = None, compression: Optional[Literal["gz", "bz2", "xz"]] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner TAR file.""" return FAKER.tar_file( storage=storage, basename=basename, prefix=prefix, options=options, compression=compression, metadata=metadata, **kwargs, ) def create_inner_eml_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, options: Optional[Dict[str, Any]] = None, content: Optional[str] = None, subject: Optional[str] = None, cte_type: Optional[str] = None, policy: Optional[Policy] = None, metadata: Optional[MetaData] = None, **kwargs, ) -> StringValue: """Create inner EML file.""" return FAKER.eml_file( storage=storage, basename=basename, prefix=prefix, options=options, content=content, subject=subject, cte_type=cte_type, policy=policy, metadata=metadata, **kwargs, ) def create_inner_txt_file( storage: Optional[BaseStorage] = None, basename: Optional[str] = None, prefix: Optional[str] = None, text: Optional[str] = None, **kwargs, ) -> StringValue: """Create inner TXT file.""" if not text: text = FAKER.text() return FAKER.txt_file( storage=storage, basename=basename, prefix=prefix, text=text, **kwargs, ) def fuzzy_choice_create_inner_file( func_choices: List[Tuple[Callable[..., StringValue], Dict[str, Any]]], **kwargs, ) -> StringValue: """Create inner file from given list of function choices. :param func_choices: List of functions to choose from. :param **kwargs: Additional keyword arguments to pass to the function. :rtype: StringValue :return: StringValue instance. Usage example: .. code-block:: python from fake import ( FAKER, FileSystemStorage, create_inner_docx_file, create_inner_png_file, create_inner_txt_file, fuzzy_choice_create_inner_file, ) STORAGE = FileSystemStorage() kwargs = {"storage": STORAGE} file = fuzzy_choice_create_inner_file( [ (create_inner_docx_file, kwargs), (create_inner_png_file, kwargs), (create_inner_txt_file, kwargs), ] ) You could use it in archives to make a variety of different file types within the archive. .. code-block:: python from fake import ( FAKER, FileSystemStorage, create_inner_docx_file, create_inner_png_file, create_inner_txt_file, fuzzy_choice_create_inner_file, ) STORAGE = FileSystemStorage() kwargs = {"storage": STORAGE} file = FAKER.zip_file( prefix="zzz_archive_", options={ "count": 50, "create_inner_file_func": fuzzy_choice_create_inner_file, "create_inner_file_args": { "func_choices": [ (create_inner_docx_file, kwargs), (create_inner_png_file, kwargs), (create_inner_txt_file, kwargs), ], }, "directory": "zzz", } ) """ _func, _kwargs = random.choice(func_choices) return _func(**_kwargs) def list_create_inner_file( func_list: List[Tuple[Callable[..., StringValue], Dict[str, Any]]], **kwargs, ) -> List[StringValue]: """Generates multiple files based on the provided list of functions and arguments. :param func_list: List of tuples, each containing a function to generate a file and its arguments. :param **kwargs: Additional keyword arguments to pass to the functions. :rtype: List[StringValue] :return: List of generated file names. Usage example: .. code-block:: python from fake import ( FAKER, FileSystemStorage, create_inner_docx_file, create_inner_txt_file, list_create_inner_file, ) file = FAKER.zip_file( basename="alice-looking-through-the-glass", options={ "create_inner_file_func": list_create_inner_file, "create_inner_file_args": { "func_list": [ (create_inner_docx_file, {"basename": "doc"}), (create_inner_txt_file, {"basename": "doc_metadata"}), (create_inner_txt_file, {"basename": "doc_isbn"}), ], }, } ) Note, that while all other inner functions return back `StringValue` value, `list_create_inner_file` returns back a `List[StringValue]` value. Notably, all inner functions were designed to support archives (such as ZIP, TAR and EML, but the list may grow in the future). If the inner function passed in the `create_inner_file_func` argument returns a List of `StringValue` values, the `option` argument is being ignored and generated files are simply limited to what has been passed in the `func_list` list of tuples. """ created_files = [] for func, func_kwargs in func_list: file = func(**func_kwargs) created_files.append(file) return created_files class FactoryMethod: def __init__( self, method_name: str, faker: Optional[Faker] = None, **kwargs, ): self.method_name = method_name self.kwargs = kwargs self.faker = faker or FAKER def __call__(self): method = getattr(self.faker, self.method_name) return method(**self.kwargs) def create_factory_method(method_name): def method(self, **kwargs): return FactoryMethod(method_name, faker=self.faker, **kwargs) return method class SubFactory: def __init__(self, factory_class, **kwargs): self.factory_class = factory_class self.factory_kwargs = kwargs def __call__(self): # Initialize the specified factory class and create an instance return self.factory_class.create(**self.factory_kwargs) class Factory: """Factory.""" def __init__(self, faker: Optional[Faker] = None) -> None: # Directly use the setter to ensure provider methods are added self.faker = faker or FAKER @property def faker(self): return self._faker @faker.setter def faker(self, value): self._faker = value self._add_provider_methods(value) def _add_provider_methods(self, faker_instance): for class_name, methods in PROVIDER_REGISTRY.items(): if ( class_name == f"{__name__}.{Faker.__name__}" or class_name == self.faker.uid ): for method_name in methods: if hasattr(faker_instance, method_name): bound_method = create_factory_method(method_name) setattr(self, method_name, bound_method.__get__(self)) FACTORY = Factory(faker=FAKER) def pre_init(func): func.is_pre_init = True return func def pre_save(func): func.is_pre_save = True return func def post_save(func): func.is_post_save = True return func def trait(func): func.is_trait = True return func class LazyAttribute: def __init__(self, func): self.func = func def __get__(self, obj, objtype=None): if obj is None: return self value = self.func(obj) setattr(obj, self.func.__name__, value) return value class LazyFunction: def __init__(self, func): self.func = func def __call__(self): return self.func() def __get__(self, obj, objtype=None): if obj is None: return self return self.func() class PreInit: def __init__(self, func, *args, **kwargs): self.func = func self.args = args self.kwargs = kwargs def execute(self, data: Dict[str, Any]) -> None: self.func(data, *self.args, **self.kwargs) class PreSave: def __init__(self, func, *args, **kwargs): self.func = func self.args = args self.kwargs = kwargs def execute(self, instance): self.func(instance, *self.args, **self.kwargs) class PostSave: def __init__(self, func, *args, **kwargs): self.func = func self.args = args self.kwargs = kwargs def execute(self, instance): self.func(instance, *self.args, **self.kwargs) class ModelFactory: """ModelFactory.""" class Meta: get_or_create = ("id",) # Default fields for get_or_create def __init_subclass__(cls, **kwargs): base_meta = getattr( cls.__bases__[0], "_meta", { attr: getattr(cls.__bases__[0].Meta, attr) # type: ignore for attr in dir(cls.__bases__[0].Meta) # type: ignore if not attr.startswith("_") }, ) cls_meta = { attr: getattr(cls.Meta, attr) for attr in dir(cls.Meta) if not attr.startswith("_") } cls._meta = {**base_meta, **cls_meta} # type: ignore @classmethod def _run_hooks(cls, hooks, instance): for method in hooks: getattr(cls, method)(cls, instance) @classmethod def _apply_traits(cls, instance, **kwargs) -> None: for name, method in cls.__dict__.items(): if getattr(method, "is_trait", False) and kwargs.get(name, False): method(cls, instance) @classmethod def _apply_lazy_attributes(cls, instance, model_data): for _field, value in model_data.items(): if isinstance(value, LazyAttribute): # Trigger computation and setting of the attribute setattr(instance, _field, value.__get__(instance, cls)) @classmethod def create(cls, **kwargs): model = cls.Meta.model # type: ignore trait_keys = { name for name, method in cls.__dict__.items() if getattr(method, "is_trait", False) } # Collect PreInit, PreSave, PostSave methods and prepare model data pre_init_methods = {} pre_save_methods = {} post_save_methods = {} model_data = {} for _field, value in cls.__dict__.items(): # Do not process any fields that have been otherwise # provided directly using keyword arguments. if _field in kwargs: continue if isinstance(value, PreInit): pre_init_methods[_field] = value elif isinstance(value, PreSave): pre_save_methods[_field] = value elif isinstance(value, PostSave): post_save_methods[_field] = value elif ( not _field.startswith(("_", "Meta",)) and ( not getattr(value, "is_trait", False) and not getattr(value, "is_pre_init", False) and not getattr(value, "is_pre_save", False) and not getattr(value, "is_post_save", False) ) ): model_data[_field] = ( value() if isinstance( value, (FactoryMethod, SubFactory, LazyFunction), ) else value ) # Update model_data with non-trait kwargs and collect PreSave from # kwargs. for key, value in kwargs.items(): if isinstance(value, PreInit): pre_init_methods[key] = value elif isinstance(value, PreSave): pre_save_methods[key] = value elif isinstance(value, PostSave): post_save_methods[key] = value elif key not in trait_keys and key not in pre_save_methods: model_data[key] = value # Execute pre-init methods for pre_init_method in pre_init_methods.values(): pre_init_method.execute(model_data) # Pre-init hooks pre_init_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_init", False) ] cls._run_hooks(pre_init_hooks, model_data) # Create a new instance instance = model(**model_data) # Apply traits cls._apply_traits(instance, **kwargs) # Apply LazyAttribute values cls._apply_lazy_attributes(instance, model_data) # Execute PreSave methods for __pre_save_method in pre_save_methods.values(): __pre_save_method.execute(instance) # Pre-save hooks pre_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_save", False) ] cls._run_hooks(pre_save_hooks, instance) # Save the instance cls.save(instance) # Execute PostSave methods for __post_save_method in post_save_methods.values(): __post_save_method.execute(instance) # Post-save hooks post_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_post_save", False) ] cls._run_hooks(post_save_hooks, instance) return instance @classmethod def create_batch(cls, count, **kwargs): return [cls.create(**kwargs) for _ in range(count)] def __new__(cls, **kwargs): return cls.create(**kwargs) @classmethod def save(cls, instance): """Save the instance.""" class PydanticModelFactory(ModelFactory): """Pydantic ModelFactory.""" class DjangoModelFactory(ModelFactory): """Django ModelFactory.""" @classmethod def save(cls, instance): instance.save() @classmethod def create(cls, **kwargs): model = cls.Meta.model # type: ignore unique_fields = cls._meta.get("get_or_create", ["id"]) # type: ignore trait_keys = { name for name, method in cls.__dict__.items() if getattr(method, "is_trait", False) } # Construct a query for unique fields query = { _field: kwargs[_field] for _field in unique_fields if _field in kwargs } # Try to get an existing instance if query: instance = model.objects.filter(**query).first() if instance: return instance # Collect PreInit, PreSave, PostSave methods and prepare model data pre_init_methods = {} pre_save_methods = {} post_save_methods = {} model_data = {} for _field, value in cls.__dict__.items(): # Do not process any fields that have been otherwise # provided directly using keyword arguments. if _field in kwargs: continue if isinstance(value, PreInit): pre_init_methods[_field] = value elif isinstance(value, PreSave): pre_save_methods[_field] = value elif isinstance(value, PostSave): post_save_methods[_field] = value elif ( not _field.startswith(("_", "Meta",)) and ( not getattr(value, "is_trait", False) and not getattr(value, "is_pre_init", False) and not getattr(value, "is_pre_save", False) and not getattr(value, "is_post_save", False) ) ): model_data[_field] = ( value() if isinstance( value, (FactoryMethod, SubFactory, LazyFunction) ) else value ) # TODO: Check if this block is really needed now, that # nested_attrs and direct_attrs are already handled separately # later on. # Update model_data with non-trait kwargs and collect PreSave # from kwargs. for key, value in kwargs.items(): if isinstance(value, PreInit): pre_init_methods[key] = value elif isinstance(value, PreSave): pre_save_methods[key] = value elif isinstance(value, PostSave): post_save_methods[key] = value # Separate nested attributes and direct attributes nested_attrs = {k: v for k, v in kwargs.items() if "__" in k} direct_attrs = {k: v for k, v in kwargs.items() if "__" not in k} # Update direct attributes with callable results for _field, value in model_data.items(): if isinstance(value, (FactoryMethod, SubFactory)): model_data[_field] = ( value() if _field not in direct_attrs else direct_attrs[_field] ) # Update model_data with non-trait kwargs and collect PreSave # and PostSave from direct_attrs. for key, value in direct_attrs.items(): if isinstance(value, PreInit): pre_init_methods[key] = value elif isinstance(value, PreSave): pre_save_methods[key] = value elif isinstance(value, PostSave): post_save_methods[key] = value elif key not in trait_keys and key not in pre_save_methods: model_data[key] = value # Execute pre-init methods for pre_init_method in pre_init_methods.values(): pre_init_method.execute(model_data) # Pre-init hooks pre_init_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_init", False) ] cls._run_hooks(pre_init_hooks, model_data) # Create a new instance if none found instance = model(**model_data) # Apply traits cls._apply_traits(instance, **kwargs) # Apply LazyAttribute values cls._apply_lazy_attributes(instance, model_data) # Handle nested attributes for attr, value in nested_attrs.items(): field_name, nested_attr = attr.split("__", 1) if isinstance(getattr(cls, field_name, None), SubFactory): related_instance = getattr( cls, field_name ).factory_class.create(**{nested_attr: value}) setattr(instance, field_name, related_instance) # Execute PreSave methods for __pre_save_method in pre_save_methods.values(): __pre_save_method.execute(instance) # Run pre-save hooks pre_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_save", False) ] cls._run_hooks(pre_save_hooks, instance) # Save instance cls.save(instance) # Execute PostSave methods for __post_save_method in post_save_methods.values(): __post_save_method.execute(instance) # Run post-save hooks post_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_post_save", False) ] cls._run_hooks(post_save_hooks, instance) return instance def run_async_in_thread(coroutine: Coroutine) -> Awaitable: """Run an asynchronous coroutine in a separate thread. :param coroutine: An asyncio coroutine to be run. :return: The result of the coroutine. :rtype: Awaitable """ def thread_target(): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete(coroutine) with ThreadPoolExecutor() as executor: future = executor.submit(thread_target) return future.result() class TortoiseModelFactory(ModelFactory): """Tortoise ModelFactory.""" @classmethod def save(cls, instance): async def async_save(): await instance.save() run_async_in_thread(async_save()) @classmethod def create(cls, **kwargs): model = cls.Meta.model # type: ignore unique_fields = cls._meta.get("get_or_create", ["id"]) # type: ignore trait_keys = { name for name, method in cls.__dict__.items() if getattr(method, "is_trait", False) } # Construct a query for unique fields query = { _field: kwargs[_field] for _field in unique_fields if _field in kwargs } # Try to get an existing instance if query: async def async_filter(): return await model.filter(**query).first() instance = run_async_in_thread(async_filter()) if instance: return instance # Collect PreInit, PreSave, PostSave methods and prepare model data pre_init_methods = {} pre_save_methods = {} post_save_methods = {} model_data = {} for _field, value in cls.__dict__.items(): # Do not process any fields that have been otherwise # provided directly using keyword arguments. if _field in kwargs: continue if isinstance(value, PreInit): pre_init_methods[_field] = value elif isinstance(value, PreSave): pre_save_methods[_field] = value elif isinstance(value, PostSave): post_save_methods[_field] = value elif ( not _field.startswith(("_", "Meta",)) and ( not getattr(value, "is_trait", False) and not getattr(value, "is_pre_init", False) and not getattr(value, "is_pre_save", False) and not getattr(value, "is_post_save", False) ) ): model_data[_field] = ( value() if isinstance( value, (FactoryMethod, SubFactory, LazyFunction) ) else value ) # TODO: Check is this block is needed now that kwargs are split # into nested_attrs and direct_attrs later on. # Update model_data with non-trait kwargs and collect PreSave # and PostSave from kwargs. for key, value in kwargs.items(): if isinstance(value, PreSave): pre_save_methods[key] = value elif isinstance(value, PostSave): post_save_methods[key] = value # Separate nested attributes and direct attributes nested_attrs = {k: v for k, v in kwargs.items() if "__" in k} direct_attrs = {k: v for k, v in kwargs.items() if "__" not in k} # Update direct attributes with callable results for _field, value in model_data.items(): if isinstance(value, (FactoryMethod, SubFactory)): model_data[_field] = ( value() if _field not in direct_attrs else direct_attrs[_field] ) # Update model_data with non-trait kwargs and collect PreSave # from direct_attrs. for key, value in direct_attrs.items(): if isinstance(value, PreInit): pre_init_methods[key] = value elif isinstance(value, PreSave): pre_save_methods[key] = value elif isinstance(value, PostSave): post_save_methods[key] = value elif key not in trait_keys and key not in pre_save_methods: model_data[key] = value # Execute pre-init methods for pre_init_method in pre_init_methods.values(): pre_init_method.execute(model_data) # Pre-init hooks pre_init_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_init", False) ] cls._run_hooks(pre_init_hooks, model_data) # Create a new instance if none found instance = model(**model_data) # Apply traits cls._apply_traits(instance, **kwargs) # Apply LazyAttribute values cls._apply_lazy_attributes(instance, model_data) # Handle nested attributes for _attr, _value in nested_attrs.items(): _field_name, _nested_attr = _attr.split("__", 1) if isinstance(getattr(cls, _field_name, None), SubFactory): async def async_related_instance( field_name_=_field_name, nested_attr_=_nested_attr, value_=_value, ): return getattr(cls, field_name_).factory_class.create( **{nested_attr_: value_} ) related_instance = run_async_in_thread(async_related_instance()) setattr(instance, _field_name, related_instance) # Execute PreSave methods for __pre_save_method in pre_save_methods.values(): __pre_save_method.execute(instance) # Run pre-save hooks pre_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_save", False) ] cls._run_hooks(pre_save_hooks, instance) # Save instance cls.save(instance) # Execute PostSave methods for __post_save_method in post_save_methods.values(): __post_save_method.execute(instance) # Run post-save hooks post_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_post_save", False) ] cls._run_hooks(post_save_hooks, instance) return instance class SQLAlchemyModelFactory(ModelFactory): """SQLAlchemy ModelFactory.""" @classmethod def save(cls, instance): session = cls.MetaSQLAlchemy.get_session() # type: ignore session.add(instance) session.commit() @classmethod def create(cls, **kwargs): session = cls.MetaSQLAlchemy.get_session() # type: ignore model = cls.Meta.model # type: ignore unique_fields = cls._meta.get("get_or_create", ["id"]) # type: ignore trait_keys = { name for name, method in cls.__dict__.items() if getattr(method, "is_trait", False) } # Check for existing instance if unique_fields: query_kwargs = { _field: kwargs.get(_field) for _field in unique_fields } instance = session.query(model).filter_by(**query_kwargs).first() if instance: return instance # Collect PreInit, PreSave, PostSave methods and prepare model data pre_init_methods = {} pre_save_methods = {} post_save_methods = {} model_data = {} for _field, value in cls.__dict__.items(): # Do not process any fields that have been otherwise # provided directly using keyword arguments. if _field in kwargs: continue if isinstance(value, PreInit): pre_init_methods[_field] = value elif isinstance(value, PreSave): pre_save_methods[_field] = value elif isinstance(value, PostSave): post_save_methods[_field] = value elif ( not _field.startswith(("_", "Meta",)) and ( not getattr(value, "is_trait", False) and not getattr(value, "is_pre_init", False) and not getattr(value, "is_pre_save", False) and not getattr(value, "is_post_save", False) ) ): model_data[_field] = ( value() if isinstance( value, (FactoryMethod, SubFactory, LazyFunction) ) else value ) # TODO: Check if this is really needed now that kwargs are # handled in direct_attrs later on. # Update model_data with non-trait kwargs and collect PreSave # from kwargs. for key, value in kwargs.items(): if isinstance(value, PreSave): pre_save_methods[key] = value elif isinstance(value, PostSave): post_save_methods[key] = value # Separate nested attributes and direct attributes nested_attrs = {k: v for k, v in kwargs.items() if "__" in k} direct_attrs = {k: v for k, v in kwargs.items() if "__" not in k} # Update direct attributes with callable results for _field, value in model_data.items(): if isinstance(value, (FactoryMethod, SubFactory)): model_data[_field] = ( value() if _field not in direct_attrs else direct_attrs[_field] ) # Update model_data with non-trait kwargs and collect PreSave # from direct_attrs. for key, value in direct_attrs.items(): if isinstance(value, PreInit): pre_init_methods[key] = value elif isinstance(value, PreSave): pre_save_methods[key] = value elif isinstance(value, PostSave): post_save_methods[key] = value elif key not in trait_keys and key not in pre_save_methods: model_data[key] = value # Execute pre-init methods for pre_init_method in pre_init_methods.values(): pre_init_method.execute(model_data) # Pre-init hooks pre_init_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_init", False) ] cls._run_hooks(pre_init_hooks, model_data) # Create a new instance instance = model(**model_data) # Apply traits cls._apply_traits(instance, **kwargs) # Apply LazyAttribute values cls._apply_lazy_attributes(instance, model_data) # Handle nested attributes for attr, value in nested_attrs.items(): field_name, nested_attr = attr.split("__", 1) if isinstance(getattr(cls, field_name, None), SubFactory): related_instance = getattr( cls, field_name ).factory_class.create(**{nested_attr: value}) setattr(instance, field_name, related_instance) # Execute PreSave methods for __pre_save_method in pre_save_methods.values(): __pre_save_method.execute(instance) # Run pre-save hooks pre_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_pre_save", False) ] cls._run_hooks(pre_save_hooks, instance) # Save instance cls.save(instance) # Execute PostSave methods for __post_save_method in post_save_methods.values(): __post_save_method.execute(instance) # Run post-save hooks post_save_hooks = [ method for method in dir(cls) if getattr(getattr(cls, method), "is_post_save", False) ] cls._run_hooks(post_save_hooks, instance) return instance # ************************************************ # ******************* Internal ******************* # ************************************************ class ClassProperty(property): """ClassProperty.""" def __get__(self, cls, owner): """Get.""" return classmethod(self.fget).__get__(None, owner)() # type: ignore classproperty = ClassProperty def xor_transform(val: str, key: int = 10) -> str: """Simple, deterministic string encoder/decoder. Usage example: .. code-block:: python val = "abcd" encoded_val = xor_transform(val) decoded_val = xor_transform(encoded_val) """ return "".join(chr(ord(__c) ^ key) for __c in val) class BaseDataFiller: TYPE_TO_PROVIDER = { bool: FAKER.pybool, int: FAKER.pyint, str: FAKER.pystr, datetime: FAKER.date_time, date: FAKER.date, float: FAKER.pyfloat, Decimal: FAKER.pydecimal, } FIELD_NAME_TO_PROVIDER = { "name": FAKER.word, "title": FAKER.sentence, "slug": FAKER.slug, "content": FAKER.text, "category": FAKER.word, "username": FAKER.username, "email": FAKER.email, "headline": FAKER.sentence, "first_name": FAKER.first_name, "last_name": FAKER.last_name, "uuid": FAKER.uuid, "body": FAKER.text, "summary": FAKER.paragraph, "date_of_birth": FAKER.date, "dob": FAKER.date, "age": partial(FAKER.pyint, min_value=1, max_value=100), "url": FAKER.url, } @classmethod def get_provider_for_field_name(cls, field_name) -> Optional[Callable]: return BaseDataFiller.FIELD_NAME_TO_PROVIDER.get(field_name) class DataclassDataFiller(BaseDataFiller): @classmethod def get_provider_for_type(cls, field_type) -> Optional[Callable]: """Get provider function for the type given.""" # Extract the base type from Optional if get_origin(field_type) is Optional: field_type = get_args(field_type)[0] return cls.TYPE_TO_PROVIDER.get(field_type) @classmethod def fill(cls, dataclass_type: Type) -> Any: """Fill dataclass with data.""" if not is_dataclass(dataclass_type): raise ValueError("The provided type must be a dataclass") kwargs = {} for _field in fields(dataclass_type): provider_func = cls.get_provider_for_field_name(_field.name) if not provider_func: if is_dataclass(_field.type): # Recursive call for nested dataclass def provider_func(field_=_field): return cls.fill(field_.type) else: provider_func = cls.get_provider_for_type(_field.type) if provider_func: kwargs[_field.name] = provider_func() else: # Skip if no provider function is defined continue return dataclass_type(**kwargs) fill_dataclass = DataclassDataFiller.fill class PydanticDataFiller(BaseDataFiller): @classmethod def get_provider_for_type(cls, field_type) -> Optional[Callable]: if isinstance(field_type, type) and issubclass( field_type, (list, dict, set) ): return None if ( hasattr(field_type, "__origin__") and field_type.__origin__ is Optional # noqa ): field_type = field_type.__args__[0] # noqa return cls.TYPE_TO_PROVIDER.get(field_type) @classmethod def is_class_type(cls, type_hint): return isinstance(type_hint, type) and not any( issubclass(type_hint, primitive) for primitive in (int, str, float, bool, Decimal) ) @classmethod def fill(cls, object_type: Type) -> Any: if not ( hasattr(object_type, "__fields__") and hasattr(object_type, "Config") ): raise ValueError("The provided type must be a Pydantic model") type_hints = get_type_hints(object_type) kwargs = {} for field_name, field_type in type_hints.items(): # Check for Pydantic's default_factory default_factory = getattr( object_type.__fields__[field_name], "default_factory", None ) if default_factory is not None: kwargs[field_name] = default_factory() continue provider_func = cls.get_provider_for_field_name(field_name) if not provider_func: if cls.is_class_type(field_type): kwargs[field_name] = cls.fill(field_type) else: provider_func = cls.get_provider_for_type(field_type) if provider_func: kwargs[field_name] = provider_func() else: continue else: kwargs[field_name] = provider_func() return object_type(**kwargs) fill_pydantic_model = PydanticDataFiller.fill # ************************************************ # ********************* CLI ********************** # ************************************************ def get_provider_args(func: Callable) -> Dict[str, Any]: """Retrieve the argument list and types for a provider function by inspecting its signature. """ sig = signature(func) return {param.name: param.annotation for param in sig.parameters.values()} def get_provider_defaults(func: Callable) -> Dict[str, Any]: """Retrieve the argument list and defaults for a provider function by inspecting its signature. """ sig = signature(func) return {param.name: param.default for param in sig.parameters.values()} def is_optional_type(type_hint) -> bool: """Check if the type hint is an Optional.""" origin = get_origin(type_hint) args = get_args(type_hint) return origin is Optional or (origin is Union and type(None) in args) def get_argparse_type(param_type) -> Any: """Get the corresponding argparse type for a given parameter type.""" origin = get_origin(param_type) args = get_args(param_type) if origin is Union: if type(None) in args: non_none_types = [arg for arg in args if arg is not type(None)] if len(non_none_types) == 1: return get_argparse_type(non_none_types[0]) return str # Default to string if multiple types are present return str # Default to string if it's a non-optional Union elif origin in [list, tuple, set]: return lambda x: [get_argparse_type(args[0])(i) for i in x.split(",")] elif param_type is int: return int elif param_type is float: return float elif param_type is bool: return lambda x: x.lower() in ("true", "1", "yes") else: return str def organise_providers(provider_tags) -> Dict[str, Any]: """Organise providers by category for easier navigation.""" categories: Dict[str, Any] = {} for _provider, tags in provider_tags: for tag in tags: if tag not in categories: categories[tag] = [] categories[tag].append(_provider) # Sort the providers within each category for category in categories: categories[category] = sorted(categories[category]) # Return categories sorted by the category names return dict(sorted(categories.items())) organize_providers = organise_providers # For backwards compatibility def format_type_hint(type_hint) -> str: """Format the type hint for display.""" origin = get_origin(type_hint) _args = get_args(type_hint) _type = ", ".join( [format_type_hint(arg) for arg in _args if arg is not type(None)] ) if is_optional_type(type_hint): return f"Optional[{_type}]" elif origin is Tuple: formatted_args = [] for arg in _args: if arg is Ellipsis: formatted_args.append("...") else: formatted_args.append(format_type_hint(arg)) return f"Tuple[{', '.join(formatted_args)}]" elif _args: return ( f"{getattr(origin, '__name__', str(origin))}" f"[{', '.join([format_type_hint(arg) for arg in _args])}]" ) elif isinstance(type_hint, type) and type_hint.__module__ == "builtins": return type_hint.__name__ elif type_hint is Ellipsis: return "..." elif isinstance(type_hint, str): return type_hint else: try: return f"{type_hint.__module__}.{type_hint.__name__}" except Exception: return str(type_hint) class CLI: """CLI.""" def __init__(self, faker: Optional[Faker] = None) -> None: if faker: self.faker = faker else: self.faker = FAKER faker_id = f"{self.faker.__module__}.{self.faker.__class__.__name__}" self.provider_list = sorted(PROVIDER_REGISTRY[faker_id]) self.provider_tags = [ (_provider, _provider.tags) for _provider in self.provider_list ] self.parser = self.setup_parser() self.args = self.parser.parse_args() def setup_parser(self) -> ArgumentParser: _parser = ArgumentParser( description=f"CLI for fake.py (version {__version__})", formatter_class=ArgumentDefaultsHelpFormatter, ) subparsers = _parser.add_subparsers( dest="command", help="Available commands" ) for provider_name in self.provider_list: provider_func = getattr(self.faker, provider_name) doc_string = ( provider_func.__doc__.split("\n")[0] if provider_func.__doc__ else None ) subparser = subparsers.add_parser(provider_name, help=doc_string) provider_args = get_provider_args(provider_func) provider_defaults = get_provider_defaults(provider_func) for param_name, param_type in provider_args.items(): formatted_type = format_type_hint(param_type) default_value = provider_defaults.get(param_name, None) argparse_type = get_argparse_type(param_type) if is_optional_type(param_type) or default_value is not None: subparser.add_argument( f"--{param_name}", help=f"{param_name} (type: {formatted_type})", type=argparse_type, default=default_value, ) else: subparser.add_argument( param_name, help=( f"{param_name} (type: {formatted_type}, " f"default value: {default_value})" ), type=argparse_type, ) return _parser def execute_command(self) -> None: command = self.args.command if not command: self.parser.print_help() return provider_func = getattr(self.faker, command) provider_params = signature(provider_func).parameters kwargs = {} for param_name in provider_params: if hasattr(self.args, param_name): param_value = getattr(self.args, param_name) if param_value is not None: kwargs[param_name] = param_value result = provider_func(**kwargs) print(result) def main() -> None: cli = CLI() cli.execute_command() if __name__ == "__main__": main() # ************************************************ # ******************** Tests ********************* # ************************************************ class TestScript(unittest.TestCase): def test_main(self): # Call the script directly and check that it executes without errors result = subprocess.run( ["python", "fake.py"], capture_output=True, text=True, ) self.assertEqual(result.returncode, 0) result.stdout.startswith("usage:") class TestOrganiseProviders(unittest.TestCase): def setUp(self): self.provider_list = sorted(PROVIDER_REGISTRY[f"{__name__}.Faker"]) self.provider_tags = [ (_provider, _provider.tags) for _provider in self.provider_list ] def test_organise_providers_empty(self): provider_tags: List[Tuple[str, Iterable[str]]] = [] result = organise_providers(provider_tags) expected: Dict[str, Any] = {} self.assertEqual(result, expected) def test_organise_providers_single_tag(self): provider_tags = [(ProviderRegistryItem("provider1"), ("Tag1",))] result = organise_providers(provider_tags) expected = {"Tag1": [ProviderRegistryItem("provider1")]} self.assertEqual(result, expected) def test_organise_providers_multiple_tags(self): provider_tags = [(ProviderRegistryItem("provider1"), ("Tag1", "Tag2"))] result = organise_providers(provider_tags) expected = { "Tag1": [ProviderRegistryItem("provider1")], "Tag2": [ProviderRegistryItem("provider1")], } self.assertEqual(result, expected) def test_organise_providers_multiple_providers(self): provider_tags = [ (ProviderRegistryItem("provider1"), ("Tag1",)), (ProviderRegistryItem("provider2"), ("Tag1", "Tag2")), (ProviderRegistryItem("provider3"), ("Tag3",)), ] result = organise_providers(provider_tags) expected = { "Tag1": [ ProviderRegistryItem("provider1"), ProviderRegistryItem("provider2"), ], "Tag2": [ProviderRegistryItem("provider2")], "Tag3": [ProviderRegistryItem("provider3")], } self.assertEqual(result, expected) def test_organise_providers_sorting(self): provider_tags = [ (ProviderRegistryItem("provider3"), ("Tag1",)), (ProviderRegistryItem("provider1"), ("Tag1",)), (ProviderRegistryItem("provider2"), ("Tag1",)), ] result = organise_providers(provider_tags) expected = { "Tag1": [ ProviderRegistryItem("provider1"), ProviderRegistryItem("provider2"), ProviderRegistryItem("provider3"), ] } self.assertEqual(result, expected) def test_organise_providers_category_sorting(self): provider_tags = [ (ProviderRegistryItem("provider1"), ("TagB",)), (ProviderRegistryItem("provider2"), ("TagA",)), ] result = organise_providers(provider_tags) expected = { "TagA": [ProviderRegistryItem("provider2")], "TagB": [ProviderRegistryItem("provider1")], } self.assertEqual(result, expected) class TestCLI(unittest.TestCase): def setUp(self): self.provider_list = sorted(PROVIDER_REGISTRY[f"{__name__}.Faker"]) @patch("sys.argv", ["fake-py"]) def test_provider_list(self): cli = CLI() self.assertEqual(cli.provider_list, self.provider_list) @patch("sys.argv", ["fake-py", "pyint"]) def test_pyint_provider(self): with patch("sys.stdout", new=io.StringIO()) as fake_out: main() self.assertTrue(fake_out.getvalue().strip().isdigit()) @patch( "sys.argv", [ "fake-py", "generic_file", "--content", "MyContent", "--extension", "txt", "--basename", "my_file", ], ) def test_generic_file_provider(self): with patch("sys.stdout", new=io.StringIO()) as fake_out: main() self.assertEqual( fake_out.getvalue().strip(), "tmp/my_file.txt", ) @patch("sys.argv", ["fake-py", "date"]) def test_date_provider(self): with patch("sys.stdout", new=io.StringIO()) as fake_out: main() self.assertRegex( fake_out.getvalue().strip(), r"\d{4}-\d{2}-\d{2}", ) @patch("sys.argv", ["fake-py", "date", "--start_date=-2d"]) def test_date_provider_with_args(self): with patch("sys.stdout", new=io.StringIO()) as fake_out: main() self.assertRegex( fake_out.getvalue().strip(), r"\d{4}-\d{2}-\d{2}", ) @patch("sys.argv", ["fake-py", "docx_file", "--nb_pages=1"]) def test_docx_file_provider(self): with patch("sys.stdout", new=io.StringIO()) as fake_out: main() self.assertTrue(fake_out.getvalue().strip().endswith(".docx")) @patch("sys.argv", ["fake-py"]) def test_no_command(self): with patch("sys.stdout", new=io.StringIO()) as fake_out: main() self.assertIn( "usage: fake-py", fake_out.getvalue().strip(), ) class TestFaker(unittest.TestCase): def setUp(self) -> None: self.faker = FAKER def tearDown(self): FILE_REGISTRY.clean_up() @classmethod def is_valid_email(cls, email: str) -> bool: parsed_address = parseaddr(email) return "@" in parsed_address[1] def test_uuid(self) -> None: uuid_value = self.faker.uuid() self.assertIsInstance(uuid_value, uuid.UUID) def test_uuids(self) -> None: uuids = self.faker.uuids() for uuid_value in uuids: self.assertIsInstance(uuid_value, uuid.UUID) def test_first_name(self) -> None: first_name: str = self.faker.first_name() self.assertIsInstance(first_name, str) self.assertTrue(len(first_name) > 0) self.assertIn(first_name, self.faker._first_names) def test_first_names(self) -> None: first_names: List[str] = self.faker.first_names() for first_name in first_names: self.assertIsInstance(first_name, str) self.assertTrue(len(first_name) > 0) self.assertIn(first_name, self.faker._first_names) def test_last_name(self) -> None: last_name: str = self.faker.last_name() self.assertIsInstance(last_name, str) self.assertTrue(len(last_name) > 0) self.assertIn(last_name, self.faker._last_names) def test_last_names(self) -> None: last_names: List[str] = self.faker.last_names() for last_name in last_names: self.assertIsInstance(last_name, str) self.assertTrue(len(last_name) > 0) self.assertIn(last_name, self.faker._last_names) def test_name(self) -> None: name: str = self.faker.name() self.assertIsInstance(name, str) self.assertTrue(len(name) > 0) parts = name.split(" ") first_name = parts[0] last_name = " ".join(parts[1:]) self.assertIn(first_name, self.faker._first_names) self.assertIn(last_name, self.faker._last_names) def test_names(self) -> None: names: List[str] = self.faker.names() for name in names: self.assertIsInstance(name, str) self.assertTrue(len(name) > 0) parts = name.split(" ") first_name = parts[0] last_name = " ".join(parts[1:]) self.assertIn(first_name, self.faker._first_names) self.assertIn(last_name, self.faker._last_names) def test_username(self) -> None: username: str = self.faker.username() self.assertIsInstance(username, str) def test_usernames(self) -> None: usernames: List[str] = self.faker.usernames() for username in usernames: self.assertIsInstance(username, str) def test_slug(self) -> None: slug: str = self.faker.slug() self.assertIsInstance(slug, str) def test_slugs(self) -> None: slugs: List[str] = self.faker.slugs() for slug in slugs: self.assertIsInstance(slug, str) def test_word(self) -> None: word: str = self.faker.word() self.assertIsInstance(word, str) self.assertTrue(len(word) > 0) def test_words(self) -> None: words: List[str] = self.faker.words(nb=3) self.assertIsInstance(words, list) self.assertEqual(len(words), 3) def test_sentence(self) -> None: sentence: str = self.faker.sentence() self.assertIsInstance(sentence, str) self.assertTrue(len(sentence.split()) >= 5) self.assertTrue(sentence.endswith(".")) def test_sentences(self) -> None: sentences: List[str] = self.faker.sentences(nb=3) self.assertIsInstance(sentences, list) self.assertEqual(len(sentences), 3) def test_paragraph(self) -> None: paragraph: str = self.faker.paragraph() self.assertIsInstance(paragraph, str) self.assertTrue(len(paragraph.split(".")) >= 5) def test_paragraphs(self) -> None: paragraphs: List[str] = self.faker.paragraphs(nb=3) self.assertIsInstance(paragraphs, list) self.assertEqual(len(paragraphs), 3) def test_text(self) -> None: text: str = self.faker.text(nb_chars=100) self.assertIsInstance(text, str) self.assertTrue(len(text) <= 100) def test_texts(self) -> None: texts: List[str] = self.faker.texts(nb=3) self.assertIsInstance(texts, list) self.assertEqual(len(texts), 3) def test_file_name(self) -> None: extensions = [(None, "txt"), ("txt", "txt"), ("jpg", "jpg")] for extension, expected_extension in extensions: with self.subTest( extension=extension, expected_extension=expected_extension ): kwargs = {} if extension is not None: kwargs["extension"] = extension file_name: str = self.faker.file_name(**kwargs) self.assertIsInstance(file_name, str) self.assertTrue(file_name.endswith(f".{expected_extension}")) def test_file_path(self) -> None: extensions = [(None, "txt"), ("txt", "txt"), ("jpg", "jpg")] for extension, expected_extension in extensions: with self.subTest( extension=extension, expected_extension=expected_extension ): kwargs = {} if extension is not None: kwargs["extension"] = extension file_path: str = self.faker.file_path(**kwargs) self.assertIsInstance(file_path, str) self.assertTrue(file_path.endswith(f".{expected_extension}")) def test_dir_path(self) -> None: with self.subTest("test_default_depth"): # Test with default depth (should be 1) random.seed(0) # Set seed for reproducibility path = self.faker.dir_path() self.assertTrue( path.startswith(os.path.sep), "Path should start with os.path.sep", ) # Split path and remove empty parts caused by leading separator parts = [part for part in path.split(os.path.sep) if part] self.assertEqual( len(parts), 1, "There should be exactly one directory name appended", ) # Check that the generated folder is one of the expected words # in lowercase self.assertIn( parts[0], [word.lower() for word in self.faker._words], ) with self.subTest("test_depth_three"): # Test with depth set to 3 depth = 3 random.seed(1) # Set seed for reproducibility path = self.faker.dir_path(depth) self.assertTrue( path.startswith(os.path.sep), "Path should start with os.path.sep", ) parts = [part for part in path.split(os.path.sep) if part] self.assertEqual( len(parts), depth, f"There should be exactly {depth} directory names appended", ) for part in parts: self.assertIn( part, [word.lower() for word in self.faker._words], ) with self.subTest(" test_randomness_reproducibility"): # Given a fixed seed, the output should be reproducible. random.seed(123) path1 = self.faker.dir_path(2) random.seed(123) path2 = self.faker.dir_path(2) self.assertEqual( path1, path2, "Paths should be the same for the same random seed", ) def test_file_extension(self) -> None: with self.subTest("Return type"): _ext = self.faker.file_extension() self.assertIsInstance(_ext, str) with self.subTest("Extension validity"): _ext = self.faker.file_extension() self.assertIn(_ext, FILE_EXTENSIONS) def test_mime_type(self) -> None: with self.subTest("Return type"): _mime_type = self.faker.mime_type() self.assertIsInstance(_mime_type, str) with self.subTest("Mime type validity"): _mime_type = self.faker.mime_type() self.assertIn(_mime_type, MIME_TYPES) def test_tld_with_defaults(self) -> None: for _ in range(20): result = self.faker.tld() self.assertIn(result, TLDS) def test_tld_with_custom_tlds(self) -> None: custom_tlds = ("edu", "gov", "mil") for _ in range(20): result = self.faker.tld(custom_tlds) self.assertIn(result, custom_tlds) def test_domain_name_with_defaults(self) -> None: result = self.faker.domain_name() parts = result.split(".") self.assertEqual(len(parts), 2) domain, tld = parts self.assertTrue(domain.islower()) self.assertIn(tld, TLDS) def test_domain_name_custom_domain_names(self) -> None: custom_tlds = ("edu", "gov", "mil") for _ in range(20): result = self.faker.domain_name(custom_tlds) parts = result.split(".") self.assertEqual(len(parts), 2) domain, tld = parts self.assertTrue(domain.islower()) self.assertIn(tld, custom_tlds) def test_free_email_domain(self): for _ in range(20): result = self.faker.free_email_domain() self.assertIn(result, FREE_EMAIL_DOMAINS) def test_email(self) -> None: email: str = self.faker.email() self.assertIsInstance(email, str) self.assertTrue(self.is_valid_email(email)) def test_email_custom_domain_names(self) -> None: domains = [ ("example.com", "example.com"), ("gmail.com", "gmail.com"), ] for domain, expected_domain in domains: with self.subTest(domain=domain, expected_domain=expected_domain): kwargs = {"domain_names": [domain]} email: str = self.faker.email(**kwargs) self.assertIsInstance(email, str) self.assertTrue(self.is_valid_email(email)) self.assertTrue(email.endswith(f"@{expected_domain}")) def test_company_email(self) -> None: email: str = self.faker.company_email() self.assertIsInstance(email, str) self.assertTrue(self.is_valid_email(email)) def test_company_email_custom_domain_names(self) -> None: domains = [ ("microsoft.com", "microsoft.com"), ("google.com", "google.com"), ] for domain, expected_domain in domains: with self.subTest(domain=domain, expected_domain=expected_domain): kwargs = {"domain_names": [domain]} email: str = self.faker.company_email(**kwargs) self.assertIsInstance(email, str) self.assertTrue(self.is_valid_email(email)) self.assertTrue(email.endswith(f"@{expected_domain}")) def test_free_email(self) -> None: email: str = self.faker.free_email() self.assertIsInstance(email, str) self.assertTrue(self.is_valid_email(email)) def test_url(self) -> None: protocols = ("http", "https") tlds = ("com", "org", "net", "io") suffixes = (".html", ".php", ".go", "", "/") for protocol in protocols: for tld in tlds: for suffix in suffixes: with self.subTest( protocol=protocol, tld=tld, suffix=suffix ): url: str = self.faker.url( protocols=(protocol,), tlds=(tld,), suffixes=(suffix,), ) self.assertIsInstance(url, str) self.assertTrue(url.startswith(f"{protocol}://")) self.assertTrue(f".{tld}/" in url) self.assertTrue( url.endswith(suffix) or url.endswith(f"{suffix}/") ) def test_image_url(self) -> None: params = ( (None, None, None, {"width": 800, "height": 600}), (640, 480, None, {"width": 640, "height": 480}), ( None, None, "https://example.com/{width}x{height}", {"width": 800, "height": 600}, ), ) for width, height, service_url, expected in params: kwargs: Dict[str, Union[str, int, None]] = {} if width: kwargs["width"] = width if height: kwargs["height"] = height if service_url: kwargs["service_url"] = service_url image_url = self.faker.image_url(**kwargs) self.assertIn(str(expected["width"]), image_url) self.assertIn(str(expected["height"]), image_url) self.assertTrue(image_url.startswith("https://")) def test_pyint(self) -> None: ranges = [ (None, None, 0, 9999), (0, 5, 0, 5), (-5, 0, -5, 0), ] for min_val, max_val, expected_min_val, expected_max_val in ranges: with self.subTest( min_value=min_val, max_value=max_val, expected_min_value=expected_min_val, expected_max_value=expected_max_val, ): kwargs = {} if min_val is not None: kwargs["min_value"] = min_val if max_val is not None: kwargs["max_value"] = max_val val: int = self.faker.pyint(**kwargs) self.assertIsInstance(val, int) self.assertGreaterEqual(val, expected_min_val) self.assertLessEqual(val, expected_max_val) def test_pybool(self) -> None: value: bool = self.faker.pybool() self.assertIsInstance(value, bool) def test_pystr(self) -> None: ranges = [ (None, 20), (0, 0), (1, 1), (5, 5), (10, 10), (100, 100), ] valid_characters = set(string.ascii_letters) # ASCII letters for nb_chars, expected_nb_chars in ranges: with self.subTest( nb_chars=nb_chars, expected_nb_chars=expected_nb_chars, ): kwargs = {} if nb_chars is not None: kwargs["nb_chars"] = nb_chars val: str = self.faker.pystr(**kwargs) # Check if the output is a string self.assertIsInstance(val, str) # Check if the string has the correct length self.assertEqual(len(val), expected_nb_chars) # Check if all characters are from the valid set self.assertTrue(all(c in valid_characters for c in val)) def test_password(self): """Test password.""" with self.subTest("That has the correct length."): lengths = [10, 12, 15, 20] for length in lengths: with self.subTest(length=length): pwd = self.faker.password(length=length, min_digits=3) self.assertEqual( len(pwd), length, f"Password length should be {length}", ) with self.subTest("Test contains at least 1 lowercase letter."): pwd = self.faker.password() self.assertTrue( any(c.islower() for c in pwd), "Password must contain at least 1 lowercase letter.", ) with self.subTest("Test contains at least 1 uppercase letter."): pwd = self.faker.password() self.assertTrue( any(c.isupper() for c in pwd), "Password must contain at least 1 uppercase letter.", ) with self.subTest("Test contains at least the min number of digits."): min_digits = 3 pwd = self.faker.password(min_digits=min_digits) digit_count = sum(c.isdigit() for c in pwd) self.assertGreaterEqual( digit_count, min_digits, f"Password must contain at least {min_digits} digits.", ) with self.subTest("Test generator with custom constraints."): length = 15 min_digits = 5 pwd = self.faker.password(length=length, min_digits=min_digits) self.assertEqual(len(pwd), length, "Password length mismatch.") self.assertTrue( any(c.islower() for c in pwd), "Password must contain at least 1 lowercase letter.", ) self.assertTrue( any(c.isupper() for c in pwd), "Password must contain at least 1 uppercase letter.", ) digit_count = sum(c.isdigit() for c in pwd) self.assertGreaterEqual( digit_count, min_digits, f"Password must contain at least {min_digits} digits.", ) with ( self.subTest("Test raises ValueError when length too short."), self.assertRaises(ValueError), ): self.faker.password( length=4, min_digits=3 ) # 2 required characters + 3 digits > 4 with self.subTest("Test multiple generated passwords are unique."): passwords = {self.faker.password() for _ in range(25)} self.assertEqual(len(passwords), 25, "Passwords should be unique.") def test_pyfloat(self) -> None: ranges = [ (None, None, 0.0, 10.0), (0.0, 5.0, 0.0, 5.0), (-5.0, 0.0, -5.0, 0.0), ] for min_val, max_val, expected_min_val, expected_max_val in ranges: with self.subTest( min_value=min_val, max_value=max_val, expected_min_value=expected_min_val, expected_max_value=expected_max_val, ): kwargs = {} if min_val is not None: kwargs["min_value"] = min_val if max_val is not None: kwargs["max_value"] = max_val val: float = self.faker.pyfloat(**kwargs) self.assertIsInstance(val, float) self.assertGreaterEqual(val, expected_min_val) self.assertLessEqual(val, expected_max_val) def test_pydecimal(self): with self.subTest("With positive=True"): for __ in range(100): decimal_number = self.faker.pydecimal( left_digits=3, right_digits=2, positive=True, ) self.assertIsInstance(decimal_number, Decimal) self.assertTrue(1 <= decimal_number < 1000) # Check if right digits are 2 self.assertTrue(decimal_number.as_tuple().exponent == -2) with self.subTest("With positive=False"): for __ in range(100): negative_decimal_number = self.faker.pydecimal( left_digits=2, right_digits=2, positive=False, ) self.assertTrue(-100 <= negative_decimal_number <= 100) with self.subTest("With right_digits=0"): for __ in range(100): decimal_number = self.faker.pydecimal( left_digits=2, right_digits=0, positive=True, ) self.assertIsInstance(decimal_number, Decimal) # Check if there is no fractional part self.assertEqual(decimal_number % 1, 0) # Check if it's a 3-digit number self.assertTrue(10 <= decimal_number < 100) with self.subTest("With left_digits=0"): for __ in range(100): decimal_number = self.faker.pydecimal( left_digits=0, right_digits=2, positive=True ) self.assertIsInstance(decimal_number, Decimal) self.assertTrue(0 <= decimal_number < 1) self.assertTrue( 10 <= decimal_number * 100 < 100 ) # Check that the fractional part is correct # Test for zero left digits with negative numbers decimal_number_neg = self.faker.pydecimal( left_digits=0, right_digits=2, positive=False ) self.assertTrue(-1 < decimal_number_neg <= 0) with ( self.subTest("Fail on `left_digits` < 0"), self.assertRaises(ValueError), ): self.faker.pydecimal(left_digits=-1) with ( self.subTest("Fail on `right_digits` < 0"), self.assertRaises(ValueError), ): self.faker.pydecimal(right_digits=-1) def test_ipv4(self) -> None: # Test a large number of IPs to ensure randomness and correctness for _ in range(1000): ip = self.faker.ipv4() self.assertIsNotNone(ip) self.assertIsInstance(ip, str) parts = ip.split(".") self.assertEqual(len(parts), 4) for part in parts: self.assertTrue(part.isdigit()) self.assertTrue(0 <= int(part) <= 255) def test_parse_date_string(self) -> None: # Test 'now' and 'today' special keywords self.assertAlmostEqual( self.faker._parse_date_string("now"), datetime.now(timezone.utc), delta=timedelta(seconds=1), ) self.assertAlmostEqual( self.faker._parse_date_string("today"), datetime.now(timezone.utc), delta=timedelta(seconds=1), ) # Test days, hours, and minutes self.assertAlmostEqual( self.faker._parse_date_string("1d"), datetime.now(timezone.utc) + timedelta(days=1), delta=timedelta(seconds=1), ) self.assertAlmostEqual( self.faker._parse_date_string("-1H"), datetime.now(timezone.utc) - timedelta(hours=1), delta=timedelta(seconds=1), ) self.assertAlmostEqual( self.faker._parse_date_string("30M"), datetime.now(timezone.utc) + timedelta(minutes=30), delta=timedelta(seconds=1), ) # Test invalid format with self.assertRaises(ValueError): self.faker._parse_date_string("1y") def test_date(self) -> None: # Test the same date for start and end start_date = "now" end_date = "+0d" random_date = self.faker.date(start_date, end_date) self.assertIsInstance(random_date, date) self.assertEqual(random_date, datetime.now(timezone.utc).date()) # Test date range start_date = "-2d" end_date = "+2d" random_date = self.faker.date(start_date, end_date) self.assertIsInstance(random_date, date) self.assertTrue( datetime.now(timezone.utc).date() - timedelta(days=2) <= random_date <= datetime.now(timezone.utc).date() + timedelta(days=2) ) def test_date_time(self) -> None: # Test the same datetime for start and end start_date = "now" end_date = "+0d" random_datetime = self.faker.date_time(start_date, end_date) self.assertIsInstance(random_datetime, datetime) self.assertAlmostEqual( random_datetime, datetime.now(timezone.utc), delta=timedelta(seconds=1), ) # Test datetime range start_date = "-2H" end_date = "+2H" random_datetime = self.faker.date_time(start_date, end_date) self.assertIsInstance(random_datetime, datetime) self.assertTrue( datetime.now(timezone.utc) - timedelta(hours=2) <= random_datetime <= datetime.now(timezone.utc) + timedelta(hours=2) ) def test_year(self) -> None: """Test that the default year is between 1900 and 2100.""" _year = self.faker.year() self.assertGreaterEqual(_year, 1900) self.assertLessEqual(_year, 2100) def test_time(self) -> None: # Test default format with self.subTest("test_time_default_format"): t = self.faker.time() # HH:MM:SS self.assertRegex( t, r"^[0-1]\d:[0-5]\d:[0-5]\d$|^2[0-3]:[0-5]\d:[0-5]\d$", ) # Test custom format with self.subTest("test_time_custom_format"): t2 = self.faker.time(fmt="%H:%M") # HH:MM self.assertRegex(t2, r"^[0-1]\d:[0-5]\d$|^2[0-3]:[0-5]\d$") def test_text_pdf(self) -> None: with ( self.subTest("All params None, should fail"), self.assertRaises(ValueError), ): self.faker.pdf( nb_pages=None, texts=None, generator=TextPdfGenerator, ) with self.subTest("Without params"): pdf = self.faker.pdf(generator=TextPdfGenerator) self.assertTrue(pdf) self.assertIsInstance(pdf, bytes) with self.subTest("With `texts` provided"): texts = self.faker.sentences() pdf = self.faker.pdf(texts=texts, generator=TextPdfGenerator) self.assertTrue(pdf) self.assertIsInstance(pdf, bytes) with self.subTest("With `metadata` provided"): metadata = MetaData() pdf = self.faker.pdf( generator=TextPdfGenerator, metadata=metadata, ) self.assertTrue(pdf) self.assertIsInstance(pdf, bytes) with self.subTest("text_pdf shortcut"): metadata = MetaData() pdf = self.faker.text_pdf( metadata=metadata, ) self.assertTrue(pdf) self.assertIsInstance(pdf, bytes) def test_graphic_pdf(self) -> None: pdf = self.faker.pdf(generator=GraphicPdfGenerator) self.assertTrue(pdf) self.assertIsInstance(pdf, bytes) def test_png(self) -> None: png = self.faker.png() self.assertTrue(png) self.assertIsInstance(png, bytes) def test_svg(self) -> None: svg = self.faker.svg() self.assertTrue(svg) self.assertIsInstance(svg, bytes) def test_bmp(self) -> None: bmp = self.faker.bmp() self.assertTrue(bmp) self.assertIsInstance(bmp, bytes) def test_gif(self) -> None: gif = self.faker.gif() self.assertTrue(gif) self.assertIsInstance(gif, bytes) def test_tif(self) -> None: tif = self.faker.tif() self.assertTrue(tif) self.assertIsInstance(tif, bytes) def test_ppm(self) -> None: ppm = self.faker.ppm() self.assertTrue(ppm) self.assertIsInstance(ppm, bytes) def test_jpg(self) -> None: jpg = self.faker.jpg() self.assertTrue(jpg) self.assertIsInstance(jpg, bytes) def test_image(self): for image_format in {"png", "svg", "bmp", "gif", "tif", "ppm", "jpg"}: with self.subTest(image_format=image_format): image = self.faker.image( image_format=image_format, ) self.assertTrue(image) self.assertIsInstance(image, bytes) for image_format in {"bin"}: with ( self.subTest(image_format=image_format), self.assertRaises(ValueError), ): self.faker.image(image_format=image_format) def test_wav(self) -> None: wav = self.faker.wav() self.assertTrue(wav) self.assertIsInstance(wav, bytes) def test_docx(self) -> None: with ( self.subTest("All params None, should fail"), self.assertRaises(ValueError), ): self.faker.docx(nb_pages=None, texts=None) with self.subTest("Without params"): docx = self.faker.docx() self.assertTrue(docx) self.assertIsInstance(docx, bytes) with self.subTest("With `texts` provided"): texts = self.faker.sentences() docx = self.faker.docx(texts=texts) self.assertTrue(docx) self.assertIsInstance(docx, bytes) def test_rtf(self) -> None: with ( self.subTest("All params None, should fail"), self.assertRaises(ValueError), ): self.faker.rtf(nb_pages=None, texts=None) with self.subTest("Without params"): rtf = self.faker.rtf() self.assertTrue(rtf) self.assertIsInstance(rtf, bytes) with self.subTest("With `texts` provided"): texts = self.faker.sentences() rtf = self.faker.rtf(texts=texts) self.assertTrue(rtf) self.assertIsInstance(rtf, bytes) def test_epub(self) -> None: with ( self.subTest("All params None, should fail"), self.assertRaises(ValueError), ): self.faker.epub(nb_pages=None, texts=None) with self.subTest("Without params"): epub = self.faker.epub() self.assertTrue(epub) self.assertIsInstance(epub, bytes) with self.subTest("With `texts` provided"): texts = self.faker.sentences() epub = self.faker.epub(texts=texts) self.assertTrue(epub) self.assertIsInstance(epub, bytes) def test_odt(self) -> None: with ( self.subTest("All params None, should fail"), self.assertRaises(ValueError), ): self.faker.odt(nb_pages=None, texts=None) with self.subTest("Without params"): odt = self.faker.odt() self.assertTrue(odt) self.assertIsInstance(odt, bytes) with self.subTest("With `texts` provided"): texts = self.faker.sentences() odt = self.faker.odt(texts=texts) self.assertTrue(odt) self.assertIsInstance(odt, bytes) def test_bin(self) -> None: value = self.faker.bin() self.assertTrue(value) self.assertIsInstance(value, bytes) def test_zip(self) -> None: value = self.faker.zip() self.assertTrue(value) self.assertIsInstance(value, bytes) def test_tar(self) -> None: value = self.faker.tar() self.assertTrue(value) self.assertIsInstance(value, bytes) def test_eml(self) -> None: value = self.faker.eml() self.assertTrue(value) self.assertIsInstance(value, bytes) def test_pdf_file(self) -> None: file = self.faker.pdf_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_text_pdf_file(self) -> None: file = self.faker.text_pdf_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_png_file(self) -> None: file = self.faker.png_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_svg_file(self) -> None: file = self.faker.svg_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_bmp_file(self) -> None: file = self.faker.bmp_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_gif_file(self) -> None: file = self.faker.gif_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_tif_file(self) -> None: file = self.faker.tif_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_ppm_file(self) -> None: file = self.faker.ppm_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_jpg_file(self) -> None: file = self.faker.jpg_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_wav_file(self) -> None: file = self.faker.wav_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_docx_file(self) -> None: file = self.faker.docx_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_odt_file(self) -> None: file = self.faker.odt_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_bin_file(self) -> None: file = self.faker.bin_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_zip_file(self) -> None: file = self.faker.zip_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_tar_file(self) -> None: file = self.faker.tar_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_eml_file(self) -> None: file = self.faker.eml_file() self.assertTrue(os.path.exists(file.data["filename"])) def test_txt_file(self) -> None: with self.subTest("Without arguments"): file = self.faker.txt_file() self.assertTrue(os.path.exists(file.data["filename"])) with self.subTest("nb_chars=None"): file = self.faker.txt_file(nb_chars=None) self.assertTrue(os.path.exists(file.data["filename"])) def test_generic_file(self) -> None: with self.subTest("Without text content"): file = self.faker.generic_file( content=self.faker.text(), extension="txt", ) self.assertTrue(os.path.exists(file.data["filename"])) with self.subTest("With bytes content"): file = self.faker.generic_file( content=self.faker.text().encode(), extension="txt", ) self.assertTrue(os.path.exists(file.data["filename"])) def test_create_inner_pdf_file(self): value = create_inner_pdf_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_text_pdf_file(self): value = create_inner_text_pdf_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_png_file(self): value = create_inner_png_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_svg_file(self): value = create_inner_svg_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_bmp_file(self): value = create_inner_bmp_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_gif_file(self): value = create_inner_gif_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_tif_file(self): value = create_inner_tif_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_ppm_file(self): value = create_inner_ppm_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_jpg_file(self): value = create_inner_jpg_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_wav_file(self): value = create_inner_wav_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_docx_file(self): value = create_inner_docx_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_rtf_file(self): value = create_inner_rtf_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_epub_file(self): value = create_inner_epub_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_odt_file(self): value = create_inner_odt_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_zip_file(self): value = create_inner_zip_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_zip_file_with_options(self): value = create_inner_zip_file( prefix="zzz_archive_", options={ "count": 5, "create_inner_file_func": create_inner_txt_file, "create_inner_file_args": { "prefix": "zzz_file_", }, "directory": "zzz", }, ) self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_zip_file_with_options_list_create(self): value = create_inner_zip_file( basename="alice-looking-through-the-glass", options={ "create_inner_file_func": list_create_inner_file, "create_inner_file_args": { "func_list": [ (create_inner_txt_file, {}), (create_inner_txt_file, {}), (create_inner_docx_file, {}), ] }, }, ) self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_tar_file(self): value = create_inner_tar_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_tar_file_with_options(self): value = create_inner_tar_file( prefix="ttt_archive_", options={ "count": 5, "create_inner_file_func": create_inner_txt_file, "create_inner_file_args": { "prefix": "ttt_file_", }, "directory": "ttt", }, ) self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_tar_file_with_options_list_create(self): value = create_inner_tar_file( basename="alice-looking-through-the-glass", options={ "create_inner_file_func": list_create_inner_file, "create_inner_file_args": { "func_list": [ (create_inner_txt_file, {}), (create_inner_txt_file, {}), (create_inner_docx_file, {}), ] }, }, ) self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_eml_file(self): value = create_inner_eml_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_eml_file_with_options(self): value = create_inner_eml_file( prefix="eee_email_", options={ "count": 5, "create_inner_file_func": create_inner_docx_file, "create_inner_file_args": { "prefix": "eee_file_", }, }, ) self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_eml_file_with_options_list_create(self): value = create_inner_eml_file( basename="alice-looking-through-the-glass", options={ "create_inner_file_func": list_create_inner_file, "create_inner_file_args": { "func_list": [ (create_inner_txt_file, {}), (create_inner_txt_file, {}), (create_inner_docx_file, {}), ] }, }, ) self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_create_inner_txt_file(self): value = create_inner_txt_file() self.assertTrue(value) self.assertIsInstance(value, StringValue) def test_random_choice(self) -> None: _categories = ["art", "technology", "literature"] _choice = self.faker.random_choice(_categories) self.assertIn(_choice, _categories) def test_random_sample(self) -> None: _categories = ["art", "technology", "literature"] _sample = self.faker.random_sample(_categories, 2) self.assertEqual(len(_sample), 2) for _element in _sample: self.assertIn(_element, _categories) def test_city(self): city = self.faker.city() self.assertIn(city, self.faker._cities) def test_country(self): country = self.faker.country() self.assertIn(country, self.faker._countries) def test_geo_location(self): geo_location = self.faker.geo_location() self.assertIn(geo_location, self.faker._geo_locations) def test_country_code(self): country_code = self.faker.country_code() self.assertIn(country_code, self.faker._country_codes) self.assertTrue(len(country_code) == 2) self.assertTrue(country_code.isupper()) def test_locale(self): _locale = self.faker.locale() self.assertIn(_locale, self.faker._locales) self.assertIn("_", _locale) parts = _locale.split("_") self.assertTrue(len(parts), 2) def test_latitude(self): """Test that the latitude function returns a valid latitude.""" for _ in range(50): # Run multiple times to test randomness lat = self.faker.latitude() self.assertTrue(-90 <= lat <= 90) def test_longitude(self): """Test that the longitude function returns a valid longitude.""" for _ in range(50): # Run multiple times to test randomness lon = self.faker.longitude() self.assertTrue(-180 <= lon <= 180) def test_latitude_longitude(self): """Test that the latlng returns a valid (latitude, longitude) pair.""" for _ in range(50): # Run multiple times to test randomness lat, lon = self.faker.latitude_longitude() self.assertTrue(-90 <= lat <= 90) self.assertTrue(-180 <= lon <= 180) def test_iban(self): iban = self.faker.iban() self.assertEqual(len(iban), 22) self.assertTrue(iban[:2].isalpha()) self.assertTrue(iban[2:4].isdigit()) self.assertTrue(iban[4:].isdigit()) def test_isbn10(self): isbn10 = self.faker.isbn10() self.assertTrue(isbn10.count("-"), 3) parts = isbn10.split("-") self.assertEqual(len(parts), 4) self.assertTrue(all(part.isdigit() for part in parts[:-1])) self.assertTrue(parts[-1].isdigit() or parts[-1] == "X") def test_isbn13(self): isbn13 = self.faker.isbn13() self.assertTrue(isbn13.count("-"), 4) parts = isbn13.split("-") self.assertEqual(len(parts), 5) self.assertTrue(parts[0] in ["978", "979"]) self.assertTrue(all(part.isdigit() for part in parts[1:])) def test_isbn13_checksum(self): # Generate an ISBN-13 excluding the checksum prefix = random.choice(["978", "979"]) digits = [str(random.randint(0, 9)) for _ in range(9)] full_digits = list(prefix) + digits # Get the checksum using the _isbn13_checksum method calculated_checksum = self.faker._isbn13_checksum(full_digits) # Append the checksum and form the full ISBN-13 isbn = "".join(full_digits) + calculated_checksum # Re-calculate to verify correctness self.assertEqual( calculated_checksum, self.faker._isbn13_checksum(list(isbn[:-1])), ) def test_randomise_string(self): # Test pattern with both letters and digits placeholders pattern = "??##-####-??" expected_length = len(pattern) result = self.faker.randomise_string(pattern) self.assertEqual(len(result), expected_length) self.assertTrue( all(char in string.ascii_uppercase for char in result[:2]) ) self.assertTrue(all(char in string.digits for char in result[2:4])) self.assertEqual( result[4], "-", ) self.assertTrue(all(char in string.digits for char in result[5:9])) self.assertEqual(result[9], "-") self.assertTrue( all(char in string.ascii_uppercase for char in result[10:]) ) # Test pattern with only letters placeholders pattern = "???" result = self.faker.randomise_string(pattern) self.assertEqual(len(result), len(pattern)) self.assertTrue(all(char in string.ascii_uppercase for char in result)) # Test pattern with only digits placeholders pattern = "###" result = self.faker.randomise_string(pattern) self.assertEqual(len(result), len(pattern)) self.assertTrue(all(char in string.digits for char in result)) # Test pattern with no placeholders pattern = "ABC-123" result = self.faker.randomise_string(pattern) self.assertEqual(result, pattern) def test_string_template(self) -> None: # Create a mock faker object with some methods mock_faker = MagicMock() mock_faker.name.return_value = "John Doe" mock_faker.sentence.return_value = "This is a test sentence." mock_faker.date.return_value = "2023-01-01" mock_faker.custom_method.return_value = "Custom value" mock_faker.method123.return_value = "Numeric method" mock_faker.boolean_method.return_value = "Boolean result" mock_faker.string_template = deepcopy(self.faker.string_template) template = ( "Name: {name()}\n" "Sentence: {sentence(nb_words=10)}\n" "Date: {date(start_date='-7d')}\n" "Custom: {custom_method(param='value')}" ) string_template = self.faker.string_template( template, faker=mock_faker, ) expected = ( "Name: John Doe\n" "Sentence: This is a test sentence.\n" "Date: 2023-01-01\n" "Custom: Custom value" ) self.assertEqual(string_template, expected) mock_faker.name.assert_called_once() mock_faker.sentence.assert_called_once_with(nb_words=10) mock_faker.date.assert_called_once_with(start_date="-7d") mock_faker.custom_method.assert_called_once_with(param="value") def test_lazy_string_template(self) -> None: # Create a mock faker object with some methods mock_faker = MagicMock() mock_faker.name.return_value = "John Doe" mock_faker.sentence.return_value = "This is a test sentence." mock_faker.date.return_value = "2023-01-01" mock_faker.custom_method.return_value = "Custom value" mock_faker.method123.return_value = "Numeric method" mock_faker.boolean_method.return_value = "Boolean result" mock_faker.lazy_string_template = deepcopy( self.faker.lazy_string_template ) template = ( "Name: {name()}\n" "Sentence: {sentence(nb_words=10)}\n" "Date: {date(start_date='-7d')}\n" "Custom: {custom_method(param='value')}" ) string_template = self.faker.lazy_string_template( template, faker=mock_faker, ) expected = ( "Name: John Doe\n" "Sentence: This is a test sentence.\n" "Date: 2023-01-01\n" "Custom: Custom value" ) result = str(string_template) self.assertEqual(result, expected) mock_faker.name.assert_called_once() mock_faker.sentence.assert_called_once_with(nb_words=10) mock_faker.date.assert_called_once_with(start_date="-7d") mock_faker.custom_method.assert_called_once_with(param="value") def test_storage(self) -> None: storage = FileSystemStorage() with self.assertRaises(ValueError): storage.generate_filename(extension=None) # type: ignore def test_storage_integration(self) -> None: file = self.faker.txt_file() file_2 = self.faker.txt_file(basename="file_2") file_3 = self.faker.txt_file(basename="file_3") storage: FileSystemStorage = file.data["storage"] with self.subTest("Test os.path.exists"): self.assertTrue(os.path.exists(file.data["filename"])) with self.subTest("Test storage.exists on StringValue"): self.assertTrue(storage.exists(file)) with self.subTest("Test storage.exists on rel path"): self.assertTrue(storage.exists(str(file))) with self.subTest("Test storage.exists on abs path"): self.assertTrue(storage.exists(file.data["filename"])) with self.subTest("Test storage.abspath using relative path"): self.assertEqual( os.path.realpath(storage.abspath(str(file))), os.path.realpath(file.data["filename"]), ) with self.subTest("Test storage.abspath using absolute path"): self.assertEqual( os.path.realpath(storage.abspath(file.data["filename"])), os.path.realpath(file.data["filename"]), ) with self.subTest("Test storage.unlink on absolute path"): storage.unlink(file.data["filename"]) self.assertFalse(storage.exists(str(file))) self.assertFalse(storage.exists(file.data["filename"])) with self.subTest("Test storage.unlink on relative path"): storage.unlink(str(file_2)) self.assertFalse(storage.exists(file_2.data["filename"])) with self.subTest("Test storage.unlink on relative path"): storage.unlink(str(file_3)) self.assertFalse(storage.exists(file_3.data["filename"])) def test_authorship_data(self): """Test `AuthorshipData`.""" authorship_data = AuthorshipData() with self.subTest("Testing UnicodeDecodeError case"): # Creating a text file with non-UTF-8 characters. # Using a character that is not compatible with UTF-8 but is with # Latin-1. For example, the byte sequence for a character not # representable in UTF-8. file = self.faker.generic_file( content=b"\xff\xff", extension="txt", basename="non_utf8_file", ) val = authorship_data._find_authorship_info(file.data["filename"]) self.assertFalse(val) def test_metadata(self) -> None: """Test MetaData.""" with self.subTest("Test str"): metadata = MetaData() content = self.faker.word() metadata.add_content(content) self.assertEqual(metadata.content, content) with self.subTest("Test list"): metadata = MetaData() content = self.faker.words() metadata.add_content(content) self.assertEqual(metadata.content, "\n".join(content)) def test_faker_init(self) -> None: faker = Faker(alias="default") self.assertNotEqual(faker.alias, "default") def test_get_by_uid(self) -> None: faker = Faker.get_by_uid(f"{__name__}.{Faker.__name__}") self.assertIs(faker, self.faker) def test_get_by_alias(self) -> None: faker = Faker.get_by_alias("default") self.assertIs(faker, self.faker) def test_factory_method(self) -> None: """Test FactoryMethod.""" with self.subTest("sentence"): sentence_factory_method = FactoryMethod("sentence") generated_sentence = sentence_factory_method() self.assertIsInstance(generated_sentence, str) with self.subTest("pyint"): pyint_factory_method = FactoryMethod("pyint") generated_int = pyint_factory_method() self.assertIsInstance(generated_int, int) def test_factory_methods(self) -> None: # Assuming 'Faker' is the class with methods decorated by @provider faker = Faker() factory = Factory(faker) # Iterate through methods of Faker for attr_name in dir(faker): attr_value = getattr(faker, attr_name) if callable(attr_value) and getattr( attr_value, "is_provider", False ): # Check if Factory has the method self.assertTrue(hasattr(factory, attr_name)) def test_sub_factory(self) -> None: """Test FACTORY and SubFactory.""" # ************************* # ********* Models ******** # ************************* class MockPydanticField: """Mock field simulating a Pydantic model field.""" def __init__(self, type, default_factory): self.type = type self.default_factory = default_factory class MockPydanticModel: """Mock class simulating a Pydantic model.""" # Adjusting __fields__ to mimic Pydantic's structure __fields__ = { "id": MockPydanticField(int, lambda: 1), "name": MockPydanticField(str, lambda: "default"), "is_active": MockPydanticField(bool, lambda: True), "created_at": MockPydanticField(datetime, datetime.now), "optional_field": MockPydanticField( Optional[str], lambda: None ), } class Config: arbitrary_types_allowed = True id: int name: str is_active: bool created_at: datetime optional_field: Optional[str] = None def __init__(self, **kwargs): for name, value in kwargs.items(): setattr(self, name, value) class DjangoQuerySet(list): """Mimicking Django QuerySet class.""" def __init__(self, instance: Union["Article", "User"]) -> None: super().__init__() self.instance = instance def first(self) -> Union["Article", "User"]: return self.instance class DjangoManager: """Mimicking Django Manager class.""" def __init__(self, instance: Union["Article", "User"]) -> None: self.instance = instance def filter(self, *args, **kwargs) -> "DjangoQuerySet": return DjangoQuerySet(instance=self.instance) @dataclass(frozen=True) class Group: id: int name: str @dataclass class User: """User model.""" id: int username: str first_name: str last_name: str email: str date_joined: datetime = field(default_factory=datetime.utcnow) last_login: Optional[datetime] = None password: Optional[str] = None is_superuser: bool = False is_staff: bool = False is_active: bool = True groups: Set[Group] = field(default_factory=set) def save(self, *args, **kwargs): """Mimicking Django's Mode save method.""" self.save_called = True # noqa def set_password(self, password: str) -> None: self.password = xor_transform(password) @classproperty def objects(cls): # noqa: N805 """Mimicking Django's Manager behaviour.""" return DjangoManager( instance=fill_dataclass(cls), # type: ignore ) @dataclass class Article: id: int title: str slug: str content: str headline: str category: str pages: int auto_minutes_to_read: int author: User image: Optional[str] = ( None # Use str to represent the image path or URL ) pub_date: date = field(default_factory=date.today) safe_for_work: bool = False minutes_to_read: int = 5 def save(self, *args, **kwargs): """Mimicking Django's Mode save method.""" self.save_called = True # noqa @classproperty def objects(cls): # noqa: N805 """Mimicking Django's Manager behaviour.""" return DjangoManager( instance=fill_dataclass(cls), # type: ignore ) with ( self.subTest("fill_pydantic_model on dataclass"), self.assertRaises(ValueError), ): _article = fill_pydantic_model(Article) with self.subTest("fill_pydantic_model"): _obj = fill_pydantic_model(MockPydanticModel) with self.subTest("fill_dataclass"): _article = fill_dataclass(Article) # **************************** # *********** Other ********** # **************************** base_dir = Path(__file__).resolve().parent.parent media_root = base_dir / "media" storage = FileSystemStorage(root_path=media_root, rel_path="tmp") # **************************** # ******* ModelFactory ******* # **************************** def set_password(user: Any, password: str) -> None: user.set_password(password) def add_to_group(user: Any, name: str) -> None: group = GroupFactory(name=name) user.groups.add(group) categories = ( "art", "technology", "literature", ) class GroupFactory(ModelFactory): id = FACTORY.pyint() # type: ignore name = FACTORY.word() # type: ignore class Meta: model = Group get_or_create = ("name",) class UserFactory(ModelFactory): id = FACTORY.pyint() # type: ignore username = FACTORY.username() # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = FACTORY.email() # type: ignore last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore date_joined = FACTORY.date_time() # type: ignore password = PreSave(set_password, password="test1234") group = PostSave(add_to_group, name="TestGroup1234") class Meta: model = User @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True def set_auto_minutes_to_read(data): data["auto_minutes_to_read"] = data["pages"] class ArticleFactory(ModelFactory): id = FACTORY.pyint() # type: ignore title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = LazyAttribute(lambda o: o.content[:25]) category = LazyFunction(partial(random.choice, categories)) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore auto_minutes_to_read = PreInit(set_auto_minutes_to_read) image = FACTORY.png_file(storage=storage) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint( # type: ignore min_value=1, max_value=10 ) author = SubFactory(UserFactory) class Meta: model = Article with self.subTest("ModelFactory"): _article = ArticleFactory() # Testing SubFactory self.assertIsInstance(_article.author, User) self.assertIsInstance(_article.author.id, int) self.assertIsInstance( _article.author.is_staff, bool, ) self.assertIsInstance( _article.author.date_joined, datetime, ) # Testing LazyFunction self.assertIn(_article.category, categories) # Testing LazyAttribute self.assertIn(_article.headline, _article.content) # Testing PreInit self.assertEqual(_article.pages, _article.auto_minutes_to_read) # Testing Factory self.assertIsInstance(_article.id, int) self.assertIsInstance(_article.slug, str) # Testing hooks _user = _article.author self.assertTrue( hasattr(_user, "_pre_save_called") and _user._pre_save_called ) self.assertTrue( hasattr(_user, "_post_save_called") and _user._post_save_called ) # Testing get_or_create for Article model _article = ArticleFactory(id=1) self.assertIsInstance(_article, Article) self.assertEqual(_article.id, 1) # Testing traits _admin_user = UserFactory(is_admin_user=True) self.assertTrue( _admin_user.is_staff and _admin_user.is_superuser and _admin_user.is_active ) # Testing PreSave self.assertEqual(xor_transform(str(_user.password)), "test1234") _user = UserFactory( password=PreSave(set_password, password="1234test") ) self.assertEqual(xor_transform(str(_user.password)), "1234test") # Testing PostSave self.assertEqual(list(_user.groups)[0].name, "TestGroup1234") _user = UserFactory( group=PostSave(add_to_group, name="1234TestGroup") ) self.assertEqual(list(_user.groups)[0].name, "1234TestGroup") # ********************************** # ******* DjangoModelFactory ******* # ********************************** class DjangoUserFactory(DjangoModelFactory): id = FACTORY.pyint() # type: ignore username = FACTORY.username() # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = FACTORY.email() # type: ignore last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore date_joined = FACTORY.date_time() # type: ignore password = PreSave(set_password, password="jest1234") group = PostSave(add_to_group, name="JestGroup1234") class Meta: model = User get_or_create = ("username",) @trait def is_admin_user(self, instance: User) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True class DjangoArticleFactory(DjangoModelFactory): id = FACTORY.pyint() # type: ignore title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = LazyAttribute(lambda o: o.content[:25]) category = LazyFunction(partial(random.choice, categories)) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore auto_minutes_to_read = PreInit(set_auto_minutes_to_read) image = FACTORY.png_file(storage=storage) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint( # type: ignore min_value=1, max_value=10, ) author = SubFactory(DjangoUserFactory) class Meta: model = Article @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True with self.subTest("DjangoModelFactory"): _django_article = DjangoArticleFactory(author__username="admin") # Testing SubFactory self.assertIsInstance(_django_article.author, User) self.assertIsInstance( _django_article.author.id, # type: ignore int, ) self.assertIsInstance( _django_article.author.is_staff, # type: ignore bool, ) self.assertIsInstance( _django_article.author.date_joined, # type: ignore datetime, ) # Since we're mimicking Django's behaviour, the following line would # fail on test, however would pass when testing against real Django # model (as done in the examples). # self.assertEqual(django_article.author.username, "admin") # Testing Factory self.assertIsInstance(_django_article.id, int) self.assertIsInstance(_django_article.slug, str) # Testing PreInit self.assertEqual( _django_article.pages, _django_article.auto_minutes_to_read, ) # Testing hooks self.assertTrue( hasattr(_django_article, "_pre_save_called") and _django_article._pre_save_called ) self.assertTrue( hasattr(_django_article, "_post_save_called") and _django_article._post_save_called ) # Testing batch creation _django_articles = DjangoArticleFactory.create_batch(5) self.assertEqual(len(_django_articles), 5) self.assertIsInstance(_django_articles[0], Article) # Testing get_or_create for Article model _django_article = DjangoArticleFactory(id=1) self.assertIsInstance(_django_article, Article) # Testing traits _django_admin_user = DjangoUserFactory(is_admin_user=True) self.assertTrue( _django_admin_user.is_staff and _django_admin_user.is_superuser and _django_admin_user.is_active ) # Testing PreSave _django_user = DjangoUserFactory() self.assertEqual( xor_transform(str(_django_user.password)), "jest1234", ) _django_user = DjangoUserFactory( password=PreSave(set_password, password="1234jest") ) self.assertEqual( xor_transform(str(_django_user.password)), "1234jest", ) # Testing PostSave self.assertEqual( list(_django_user.groups)[0].name, # type: ignore "JestGroup1234", ) _django_user = DjangoUserFactory( group=PostSave(add_to_group, name="1234JestGroup") ) self.assertEqual( list(_django_user.groups)[0].name, # type: ignore "1234JestGroup", ) # ********************************** # ****** TortoiseModelFactory ****** # ********************************** class TortoiseQuerySet(list): """Mimicking Tortoise QuerySet class.""" return_instance_on_query_first: bool = False def __init__( self, instance: Union["TortoiseArticle", "TortoiseUser"], ) -> None: super().__init__() self.instance = instance async def first( self, ) -> Optional[Union["TortoiseArticle", "TortoiseUser"]]: if not self.return_instance_on_query_first: return None return self.instance @dataclass(frozen=True) class TortoiseGroup: id: int name: str @classmethod def filter(cls, *args, **kwargs) -> "TortoiseQuerySet": return TortoiseQuerySet(instance=fill_dataclass(cls)) async def save(self, *args, **kwargs): """Mimicking Django's Mode save method.""" @dataclass class TortoiseUser: """User model.""" id: int username: str first_name: str last_name: str email: str date_joined: datetime = field(default_factory=datetime.utcnow) last_login: Optional[datetime] = None password: Optional[str] = None is_superuser: bool = False is_staff: bool = False is_active: bool = True groups: Set[TortoiseGroup] = field(default_factory=set) def set_password(self, password: str) -> None: self.password = xor_transform(password) @classmethod def filter(cls, *args, **kwargs) -> "TortoiseQuerySet": return TortoiseQuerySet(instance=fill_dataclass(cls)) async def save(self, *args, **kwargs): """Mimicking Django's Mode save method.""" self.save_called = True # noqa @dataclass class TortoiseArticle: id: int title: str slug: str content: str headline: str category: str pages: int auto_minutes_to_read: int author: TortoiseUser image: Optional[str] = ( None # Use str to represent the image path or URL ) pub_date: date = field(default_factory=date.today) safe_for_work: bool = False minutes_to_read: int = 5 @classmethod def filter(cls, *args, **kwargs) -> "TortoiseQuerySet": return TortoiseQuerySet(instance=fill_dataclass(cls)) async def save(self, *args, **kwargs): """Mimicking Django's Mode save method.""" self.save_called = True # noqa def add_to_tortoise_group(user: Any, name: str) -> None: group = TortoiseGroupFactory(name=name) user.groups.add(group) class TortoiseGroupFactory(TortoiseModelFactory): id = FACTORY.pyint() # type: ignore name = FACTORY.word() # type: ignore class Meta: model = TortoiseGroup get_or_create = ("name",) class TortoiseUserFactory(TortoiseModelFactory): id = FACTORY.pyint() # type: ignore username = FACTORY.username() # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = FACTORY.email() # type: ignore last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore date_joined = FACTORY.date_time() # type: ignore password = PreSave(set_password, password="tost1234") group = PostSave(add_to_tortoise_group, name="TostGroup1234") class Meta: model = TortoiseUser get_or_create = ("username",) @trait def is_admin_user(self, instance: TortoiseUser) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True class TortoiseArticleFactory(TortoiseModelFactory): id = FACTORY.pyint() # type: ignore title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = LazyAttribute(lambda o: o.content[:25]) category = LazyFunction(partial(random.choice, categories)) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore auto_minutes_to_read = PreInit(set_auto_minutes_to_read) image = FACTORY.png_file(storage=storage) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint( # type: ignore min_value=1, max_value=10, ) author = SubFactory(TortoiseUserFactory) class Meta: model = TortoiseArticle @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True with self.subTest("TortoiseModelFactory"): _tortoise_article = TortoiseArticleFactory(author__username="admin") # Testing SubFactory self.assertIsInstance(_tortoise_article.author, TortoiseUser) self.assertIsInstance( _tortoise_article.author.id, # type: ignore int, ) self.assertIsInstance( _tortoise_article.author.is_staff, # type: ignore bool, ) self.assertIsInstance( _tortoise_article.author.date_joined, # type: ignore datetime, ) # Since we're mimicking Tortoise's behaviour, the following line # would fail on test, however would pass when testing against # real Tortoise model (as done in the examples). # self.assertEqual(tortoise_article.author.username, "admin") # Testing Factory self.assertIsInstance(_tortoise_article.id, int) self.assertIsInstance(_tortoise_article.slug, str) # Testing PreInit self.assertEqual( _tortoise_article.pages, _tortoise_article.auto_minutes_to_read, ) # Testing hooks self.assertTrue( hasattr(_tortoise_article, "_pre_save_called") and _tortoise_article._pre_save_called ) self.assertTrue( hasattr(_tortoise_article, "_post_save_called") and _tortoise_article._post_save_called ) # Testing batch creation _tortoise_articles = TortoiseArticleFactory.create_batch(5) self.assertEqual(len(_tortoise_articles), 5) self.assertIsInstance(_tortoise_articles[0], TortoiseArticle) # Testing get_or_create for Article model _tortoise_article = TortoiseArticleFactory(id=1) self.assertIsInstance(_tortoise_article, TortoiseArticle) # Testing traits _tortoise_admin_user = TortoiseUserFactory(is_admin_user=True) self.assertTrue( _tortoise_admin_user.is_staff and _tortoise_admin_user.is_superuser and _tortoise_admin_user.is_active ) # Testing PreSave _tortoise_user = TortoiseUserFactory() self.assertEqual( xor_transform(str(_tortoise_user.password)), "tost1234", ) _tortoise_user = TortoiseUserFactory( password=PreSave(set_password, password="1234tost") ) self.assertEqual( xor_transform(str(_tortoise_user.password)), "1234tost", ) # Testing PostSave self.assertEqual( list(_tortoise_user.groups)[0].name, # type: ignore "TostGroup1234", ) _tortoise_user = TortoiseUserFactory( group=PostSave(add_to_tortoise_group, name="1234TostGroup") ) self.assertEqual( list(_tortoise_user.groups)[0].name, # type: ignore "1234TostGroup", ) # ********************************** # ** Repeat for another condition ** TortoiseQuerySet.return_instance_on_query_first = True _tortoise_article = TortoiseArticleFactory(author__username="admin") _tortoise_user = TortoiseUserFactory(username="admin") # Testing SubFactory self.assertIsInstance(_tortoise_article.author, TortoiseUser) self.assertIsInstance(_tortoise_article, TortoiseArticle) self.assertIsInstance(_tortoise_user, TortoiseUser) self.assertIsInstance( _tortoise_article.author.id, # type: ignore int, ) self.assertIsInstance( _tortoise_article.author.is_staff, # type: ignore bool, ) self.assertIsInstance( _tortoise_article.author.date_joined, # type: ignore datetime, ) # Since we're mimicking Tortoise's behaviour, the following line # would fail on test, however would pass when testing against # real Tortoise model (as done in the examples). # self.assertEqual(_tortoise_article.author.username, "admin") # Testing Factory self.assertIsInstance(_tortoise_article.id, int) self.assertIsInstance(_tortoise_article.slug, str) self.assertIsInstance(_tortoise_user.id, int) self.assertIsInstance(_tortoise_user.username, str) # Testing hooks # self.assertFalse( # hasattr(_tortoise_article, "_pre_save_called") # ) # self.assertFalse( # hasattr(_tortoise_article, "_post_save_called") # ) # Testing batch creation _tortoise_articles = TortoiseArticleFactory.create_batch(5) self.assertEqual(len(_tortoise_articles), 5) self.assertIsInstance(_tortoise_articles[0], TortoiseArticle) # Testing traits _tortoise_admin_user = TortoiseUserFactory(is_admin_user=True) self.assertTrue( _tortoise_admin_user.is_staff and _tortoise_admin_user.is_superuser and _tortoise_admin_user.is_active ) # ********************************** # ***** SQLAlchemyModelFactory ***** # ********************************** class SQLAlchemySession: return_instance_on_query_first: bool = False def __init__(self) -> None: self.model = None self.instance = None def query(self, model) -> "SQLAlchemySession": self.model = model return self def filter_by(self, **kwargs) -> "SQLAlchemySession": return self def add(self, instance) -> None: self.instance = instance def commit(self) -> None: pass def first(self): if not self.return_instance_on_query_first: return None return fill_dataclass(self.model) # type: ignore def get_sqlalchemy_session(): return SQLAlchemySession() @dataclass(frozen=True) class SQLAlchemyGroup: id: int name: str @dataclass class SQLAlchemyUser: """User model.""" id: int username: str first_name: str last_name: str email: str date_joined: datetime = field(default_factory=datetime.utcnow) last_login: Optional[datetime] = None password: Optional[str] = None is_superuser: bool = False is_staff: bool = False is_active: bool = True groups: Set[SQLAlchemyGroup] = field(default_factory=set) def set_password(self, password: str) -> None: self.password = xor_transform(password) @dataclass class SQLAlchemyArticle: id: int title: str slug: str content: str headline: str category: str pages: int auto_minutes_to_read: int author: SQLAlchemyUser image: Optional[str] = ( None # Use str to represent the image path or URL ) pub_date: date = field(default_factory=date.today) safe_for_work: bool = False minutes_to_read: int = 5 def add_to_sqlalchemy_group(user: Any, name: str) -> None: group = SQLAlchemyGroupFactory(name=name) user.groups.add(group) class SQLAlchemyGroupFactory(SQLAlchemyModelFactory): id = FACTORY.pyint() # type: ignore name = FACTORY.word() # type: ignore class Meta: model = SQLAlchemyGroup get_or_create = ("name",) class MetaSQLAlchemy: get_session = get_sqlalchemy_session class SQLAlchemyUserFactory(SQLAlchemyModelFactory): id = FACTORY.pyint() # type: ignore username = FACTORY.username() # type: ignore first_name = FACTORY.first_name() # type: ignore last_name = FACTORY.last_name() # type: ignore email = FACTORY.email() # type: ignore last_login = FACTORY.date_time() # type: ignore is_superuser = False is_staff = False is_active = FACTORY.pybool() # type: ignore date_joined = FACTORY.date_time() # type: ignore password = PreSave(set_password, password="sest1234") group = PostSave(add_to_sqlalchemy_group, name="SestGroup1234") class Meta: model = SQLAlchemyUser get_or_create = ("username",) class MetaSQLAlchemy: get_session = get_sqlalchemy_session @trait def is_admin_user(self, instance: SQLAlchemyUser) -> None: instance.is_superuser = True instance.is_staff = True instance.is_active = True @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True class SQLAlchemyArticleFactory(SQLAlchemyModelFactory): id = FACTORY.pyint() # type: ignore title = FACTORY.sentence() # type: ignore slug = FACTORY.slug() # type: ignore content = FACTORY.text() # type: ignore headline = LazyAttribute(lambda o: o.content[:25]) category = LazyFunction(partial(random.choice, categories)) pages = FACTORY.pyint(min_value=1, max_value=100) # type: ignore auto_minutes_to_read = PreInit(set_auto_minutes_to_read) image = FACTORY.png_file(storage=storage) # type: ignore pub_date = FACTORY.date() # type: ignore safe_for_work = FACTORY.pybool() # type: ignore minutes_to_read = FACTORY.pyint( # type: ignore min_value=1, max_value=10, ) author = SubFactory(SQLAlchemyUserFactory) class Meta: model = SQLAlchemyArticle class MetaSQLAlchemy: get_session = get_sqlalchemy_session @pre_save def _pre_save_method(self, instance): instance._pre_save_called = True @post_save def _post_save_method(self, instance): instance._post_save_called = True with self.subTest("SQLAlchemyModelFactory"): _sqlalchemy_article = SQLAlchemyArticleFactory( author__username="admin" ) # Testing SubFactory self.assertIsInstance(_sqlalchemy_article.author, SQLAlchemyUser) self.assertIsInstance( _sqlalchemy_article.author.id, # type: ignore int, ) self.assertIsInstance( _sqlalchemy_article.author.is_staff, # type: ignore bool, ) self.assertIsInstance( _sqlalchemy_article.author.date_joined, # type: ignore datetime, ) # Since we're mimicking SQLAlchemy's behaviour, the following line # would fail on test, however would pass when testing against real # SQLAlchemy model (as done in the examples). # self.assertEqual(sqlalchemy_article.author.username, "admin") # Testing Factory self.assertIsInstance(_sqlalchemy_article.id, int) self.assertIsInstance(_sqlalchemy_article.slug, str) # Testing PreInit self.assertEqual( _sqlalchemy_article.pages, _sqlalchemy_article.auto_minutes_to_read, ) # Testing hooks self.assertTrue( hasattr(_sqlalchemy_article, "_pre_save_called") and _sqlalchemy_article._pre_save_called ) self.assertTrue( hasattr(_sqlalchemy_article, "_post_save_called") and _sqlalchemy_article._post_save_called ) # Testing batch creation _sqlalchemy_articles = SQLAlchemyArticleFactory.create_batch(5) self.assertEqual(len(_sqlalchemy_articles), 5) self.assertIsInstance(_sqlalchemy_articles[0], SQLAlchemyArticle) # Testing traits _sqlalchemy_admin_user = SQLAlchemyUserFactory(is_admin_user=True) self.assertTrue( _sqlalchemy_admin_user.is_staff and _sqlalchemy_admin_user.is_superuser and _sqlalchemy_admin_user.is_active ) # Testing PreSave _sqlalchemy_user = SQLAlchemyUserFactory() self.assertEqual( xor_transform(str(_sqlalchemy_user.password)), "sest1234" ) _sqlalchemy_user = SQLAlchemyUserFactory( password=PreSave(set_password, password="1234sest") ) self.assertEqual( xor_transform(str(_sqlalchemy_user.password)), "1234sest" ) # Testing PostSave self.assertEqual( list(_sqlalchemy_user.groups)[0].name, # type: ignore "SestGroup1234", ) _sqlalchemy_user = SQLAlchemyUserFactory( group=PostSave(add_to_sqlalchemy_group, name="1234SestGroup") ) self.assertEqual( list(_sqlalchemy_user.groups)[0].name, # type: ignore "1234SestGroup", ) # Repeat SQLAlchemy tests for another condition SQLAlchemySession.return_instance_on_query_first = True _sqlalchemy_article = SQLAlchemyArticleFactory( author__username="admin" ) _sqlalchemy_user = SQLAlchemyUserFactory(username="admin") # Testing SubFactory self.assertIsInstance(_sqlalchemy_article.author, SQLAlchemyUser) self.assertIsInstance(_sqlalchemy_article, SQLAlchemyArticle) self.assertIsInstance(_sqlalchemy_user, SQLAlchemyUser) self.assertIsInstance( _sqlalchemy_article.author.id, # type: ignore int, ) self.assertIsInstance( _sqlalchemy_article.author.is_staff, # type: ignore bool, ) self.assertIsInstance( _sqlalchemy_article.author.date_joined, # type: ignore datetime, ) # Since we're mimicking SQLAlchemy's behaviour, the following line # would fail on test, however would pass when testing against real # SQLAlchemy model (as done in the examples). # self.assertEqual(sqlalchemy_article.author.username, "admin") # Testing Factory self.assertIsInstance(_sqlalchemy_article.id, int) self.assertIsInstance(_sqlalchemy_article.slug, str) self.assertIsInstance(_sqlalchemy_user.id, int) self.assertIsInstance(_sqlalchemy_user.username, str) # Testing hooks self.assertFalse(hasattr(_sqlalchemy_article, "_pre_save_called")) self.assertFalse(hasattr(_sqlalchemy_article, "_post_save_called")) # Testing batch creation _sqlalchemy_articles = SQLAlchemyArticleFactory.create_batch(5) self.assertEqual(len(_sqlalchemy_articles), 5) self.assertIsInstance(_sqlalchemy_articles[0], SQLAlchemyArticle) def test_registry_integration(self) -> None: """Test `add`.""" # Create a TXT file. txt_file_1 = FAKER.txt_file() with self.subTest("Check if `add` works"): # Check if `add` works (the file is in the registry) self.assertIn(txt_file_1, FILE_REGISTRY._registry) with self.subTest("Check if `search` works"): # Check if `search` works res = FILE_REGISTRY.search(str(txt_file_1)) self.assertIsNotNone(res) self.assertEqual(res, txt_file_1) with self.subTest("Check if `remove` by `StringValue` works"): # Check if `remove` by `StringValue`. FILE_REGISTRY.remove(txt_file_1) self.assertNotIn(txt_file_1, FILE_REGISTRY._registry) with self.subTest("Check if `remove` by `str` works"): # Create another TXT file and check if `remove` by `str` works. txt_file_2 = FAKER.txt_file() self.assertIn(txt_file_2, FILE_REGISTRY._registry) FILE_REGISTRY.remove(str(txt_file_2)) self.assertNotIn(txt_file_2, FILE_REGISTRY._registry) with self.subTest("Check if `clean_up` works"): # Check if `clean_up` works txt_file_3 = FAKER.txt_file() txt_file_4 = FAKER.txt_file() txt_file_5 = FAKER.txt_file() self.assertIn(txt_file_3, FILE_REGISTRY._registry) self.assertIn(txt_file_4, FILE_REGISTRY._registry) self.assertIn(txt_file_5, FILE_REGISTRY._registry) FILE_REGISTRY.clean_up() self.assertNotIn(txt_file_3, FILE_REGISTRY._registry) self.assertNotIn(txt_file_4, FILE_REGISTRY._registry) self.assertNotIn(txt_file_5, FILE_REGISTRY._registry) def test_remove_by_string_not_found(self): res = FILE_REGISTRY.remove("i_do_not_exist.ext") self.assertFalse(res) def test_remove_exceptions(self): txt_file = FAKER.txt_file() txt_file.data["storage"].unlink(txt_file) res = FILE_REGISTRY.remove(txt_file) self.assertFalse(res) def test_clean_up_exceptions(self): # Redirect logger output to a string stream log_stream = io.StringIO() handler = logging.StreamHandler(log_stream) LOGGER.addHandler(handler) txt_file = FAKER.txt_file() txt_file.data["storage"].unlink(txt_file) # Clean up registry FILE_REGISTRY.clean_up() # Check the content of the logging output log_output = log_stream.getvalue() self.assertIn( f"Failed to unlink file {txt_file.data['filename']}", log_output, ) # Clean up by removing the handler LOGGER.removeHandler(handler) class TestSlugify(unittest.TestCase): def test_slugify_simple(self): """Test slugify with a simple alphanumeric string.""" self.assertEqual(slugify("HelloWorld"), "helloworld") def test_slugify_spaces(self): """Test slugify with spaces.""" self.assertEqual(slugify("Hello World"), "helloworld") def test_slugify_special_characters(self): """Test slugify with special characters.""" self.assertEqual( slugify("Hello!@#$%^&*()_+World"), "helloworld", ) def test_slugify_numbers(self): """Test slugify with numbers in the string.""" self.assertEqual(slugify("H3llo W0rld123"), "h3llow0rld123") def test_slugify_empty_string(self): """Test slugify with an empty string.""" self.assertEqual(slugify(""), "") def test_slugify_non_english_characters(self): """Test slugify with non-English characters.""" self.assertEqual(slugify("Ողջույն, աշխարհ։"), "") def test_slugify_mixed_characters(self): """Test slugify with a mix of alphanumeric and special characters.""" self.assertEqual(slugify("1234!@#$abcXYZ"), "1234abcxyz") class TestLazyStringTemplate(unittest.TestCase): def setUp(self): # Create a mock faker object with some methods self.mock_faker = MagicMock() self.faker = FAKER self.mock_faker.name.return_value = "John Doe" self.mock_faker.sentence.return_value = "This is a test sentence." self.mock_faker.date.return_value = "2023-01-01" self.mock_faker.custom_method.return_value = "Custom value" def test_simple_placeholder_replacement(self): template = "Hello, {name()}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe!" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.name.assert_called_once() def test_placeholder_with_arguments(self): template = "Sentence: {sentence(nb_words=5)}" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Sentence: This is a test sentence." result = string_template.render() self.assertEqual(result, expected) self.mock_faker.sentence.assert_called_once_with(nb_words=5) def test_multiple_placeholders(self): template = ( "Name: {name()}\n" "Sentence: {sentence(nb_words=10)}\n" "Date: {date(start_date='-7d')}\n" "Custom: {custom_method(param='value')}" ) string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = ( "Name: John Doe\n" "Sentence: This is a test sentence.\n" "Date: 2023-01-01\n" "Custom: Custom value" ) result = string_template.render() self.assertEqual(result, expected) self.mock_faker.name.assert_called_once() self.mock_faker.sentence.assert_called_once_with(nb_words=10) self.mock_faker.date.assert_called_once_with(start_date="-7d") self.mock_faker.custom_method.assert_called_once_with(param="value") def test_wrapping_functionality(self): template = "This is a long sentence that needs to be wrapped." string_template = LazyStringTemplate( template, wrap_chars_after=10, faker=self.mock_faker ) expected = "This is a\nlong\nsentence\nthat needs\nto be\nwrapped." result = string_template.render() self.assertEqual(result, expected) def test_no_wrapping_when_not_specified(self): template = "This is a long sentence that does not need to be wrapped." string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "This is a long sentence that does not need to be wrapped." result = string_template.render() self.assertEqual(result, expected) def test_missing_method_raises_attribute_error(self): template = "Hello, {nonexistent_method()}!" string_template = LazyStringTemplate(template, faker=self.faker) with self.assertRaises(AttributeError) as context: string_template.render() self.assertIn( "Method 'nonexistent_method' not found", str(context.exception) ) def test_argument_parsing_error_raises_value_error(self): template = "Date: {date(start_date='-7d' missing_comma)}" string_template = LazyStringTemplate(template, faker=self.mock_faker) with self.assertRaises(ValueError) as context: string_template.render() self.assertIn( "Error parsing arguments for 'date'", str(context.exception) ) self.mock_faker.date.assert_not_called() def test_method_call_error_raises_value_error(self): # Configure the mock to raise an exception when called self.mock_faker.name.side_effect = Exception("Method error") template = "Hello, {name()}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) with self.assertRaises(ValueError) as context: string_template.render() self.assertIn("Error calling method 'name'", str(context.exception)) self.mock_faker.name.assert_called_once() def test_no_placeholders(self): template = "This string has no placeholders." string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "This string has no placeholders." result = string_template.render() self.assertEqual(result, expected) # No faker methods should be called self.mock_faker.assert_not_called() def test_str_method(self): template = "Hello, {name()}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe!" result = str(string_template) self.assertEqual(result, expected) def test_repr_method(self): template = "Hello, {name()}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe!" result = repr(string_template) self.assertEqual(result, expected) def test_complex_argument_parsing(self): # Test with multiple arguments and different types template = "Custom: {custom_method(param1='value1', param2=123)}" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Custom: Custom value" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.custom_method.assert_called_once_with( param1="value1", param2=123 ) def test_nested_placeholders(self): # Although nested placeholders are not supported, ensure they are # handled gracefully. template = "Nested: {{name()}}" string_template = LazyStringTemplate(template, faker=self.mock_faker) # The regex should match {name()}, so {{name()}} becomes {John Doe} expected = "Nested: {John Doe}" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.name.assert_called_once() def test_escape_braces(self): # Test that escaped braces are handled correctly template = "Escaped braces: \\{name()\\}" string_template = LazyStringTemplate(template, faker=self.faker) expected = "Escaped braces: \\{name()\\}" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.name.assert_not_called() def test_placeholder_with_no_parentheses(self): # Test that placeholders without parentheses are handled (assuming # they require parentheses). template = "Hello, {name}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) # The regex expects parentheses, so {name} should remain unchanged expected = "Hello, John Doe!" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.name.assert_called() def test_placeholder_with_empty_arguments(self): # Test placeholders with empty parentheses template = "Hello, {name()} and {sentence()}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe and This is a test sentence.!" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.name.assert_called_once() self.mock_faker.sentence.assert_called_once() def test_placeholder_with_spaces_in_arguments(self): # Test placeholders where arguments contain spaces template = ( "Date: {date(start_date = '2020-01-01', end_date = '2020-12-31')}" ) string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Date: 2023-01-01" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.date.assert_called_once_with( start_date="2020-01-01", end_date="2020-12-31" ) def test_placeholder_with_numeric_method_name(self): # Assuming method names are purely alphabetic, but testing with # numeric characters. template = "Numeric method: {method123()}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) self.mock_faker.method123.return_value = "Numeric method" expected = "Numeric method: Numeric method!" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.method123.assert_called_once() def test_placeholder_with_underscores_in_method_name(self): # Test method names with underscores template = "Underscore method: {custom_method()}!" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Underscore method: Custom value!" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.custom_method.assert_called_once() def test_placeholder_with_boolean_arguments(self): # Test placeholders with boolean arguments self.mock_faker.boolean_method.return_value = "Boolean result" template = "Boolean: {boolean_method(flag=True)}" string_template = LazyStringTemplate(template, faker=self.mock_faker) expected = "Boolean: Boolean result" result = string_template.render() self.assertEqual(result, expected) self.mock_faker.boolean_method.assert_called_once_with(flag=True) class TestStringTemplate(unittest.TestCase): def setUp(self): # Create a mock faker object with some methods self.mock_faker = MagicMock() self.faker = FAKER self.mock_faker.name.return_value = "John Doe" self.mock_faker.sentence.return_value = "This is a test sentence." self.mock_faker.date.return_value = "2023-01-01" self.mock_faker.custom_method.return_value = "Custom value" self.mock_faker.method123.return_value = "Numeric method" self.mock_faker.boolean_method.return_value = "Boolean result" def test_instance_is_str(self): template = "Hello, {name()}!" string_template = StringTemplate(template, faker=self.mock_faker) self.assertIsInstance(string_template, str) self.assertIsInstance(string_template, StringTemplate) self.assertEqual(string_template, "Hello, John Doe!") def test_simple_placeholder_replacement(self): template = "Hello, {name()}!" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe!" self.assertEqual(string_template, expected) self.mock_faker.name.assert_called_once() def test_placeholder_with_arguments(self): template = "Sentence: {sentence(nb_words=5)}" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Sentence: This is a test sentence." self.assertEqual(string_template, expected) self.mock_faker.sentence.assert_called_once_with(nb_words=5) def test_multiple_placeholders(self): template = ( "Name: {name()}\n" "Sentence: {sentence(nb_words=10)}\n" "Date: {date(start_date='-7d')}\n" "Custom: {custom_method(param='value')}" ) string_template = StringTemplate(template, faker=self.mock_faker) expected = ( "Name: John Doe\n" "Sentence: This is a test sentence.\n" "Date: 2023-01-01\n" "Custom: Custom value" ) self.assertEqual(string_template, expected) self.mock_faker.name.assert_called_once() self.mock_faker.sentence.assert_called_once_with(nb_words=10) self.mock_faker.date.assert_called_once_with(start_date="-7d") self.mock_faker.custom_method.assert_called_once_with(param="value") def test_wrapping_functionality(self): template = "This is a long sentence that needs to be wrapped." string_template = StringTemplate( template, wrap_chars_after=10, faker=self.mock_faker, ) expected = "This is a\nlong\nsentence\nthat needs\nto be\nwrapped." self.assertEqual(string_template, expected) def test_no_wrapping_when_not_specified(self): template = "This is a long sentence that does not need to be wrapped." string_template = StringTemplate(template, faker=self.mock_faker) expected = "This is a long sentence that does not need to be wrapped." self.assertEqual(string_template, expected) # No faker methods should be called self.mock_faker.assert_not_called() def test_missing_method_raises_attribute_error(self): template = "Hello, {nonexistent_method()}!" with self.assertRaises(AttributeError) as context: StringTemplate(template, faker=self.faker) self.assertIn( "Method 'nonexistent_method' not found", str(context.exception), ) def test_argument_parsing_error_raises_value_error(self): template = "Date: {date(start_date='-7d' missing_comma)}" with self.assertRaises(ValueError) as context: StringTemplate(template, faker=self.mock_faker) self.assertIn( "Error parsing arguments for 'date'", str(context.exception), ) self.mock_faker.date.assert_not_called() def test_method_call_error_raises_value_error(self): # Configure the mock to raise an exception when called self.mock_faker.name.side_effect = Exception("Method error") template = "Hello, {name()}!" with self.assertRaises(ValueError) as context: StringTemplate(template, faker=self.mock_faker) self.assertIn("Error calling method 'name'", str(context.exception)) self.mock_faker.name.assert_called_once() def test_no_placeholders(self): template = "This string has no placeholders." string_template = StringTemplate(template, faker=self.mock_faker) expected = "This string has no placeholders." self.assertEqual(string_template, expected) # No faker methods should be called self.mock_faker.assert_not_called() def test_str_method(self): template = "Hello, {name()}!" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe!" result = str(string_template) self.assertEqual(result, expected) def test_repr_method(self): template = "Hello, {name()}!" string_template = StringTemplate(template, faker=self.mock_faker) expected = "'Hello, John Doe!'" result = repr(string_template) self.assertEqual(result, expected) def test_complex_argument_parsing(self): # Test with multiple arguments and different types template = "Custom: {custom_method(param1='value1', param2=123)}" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Custom: Custom value" self.assertEqual(string_template, expected) self.mock_faker.custom_method.assert_called_once_with( param1="value1", param2=123 ) def test_nested_placeholders(self): # Although nested placeholders are not supported, ensure they are # handled gracefully. template = "Nested: {{name()}}" string_template = StringTemplate(template, faker=self.mock_faker) # The regex should match {name()}, so {{name()}} becomes {John Doe} expected = "Nested: {John Doe}" self.assertEqual(string_template, expected) self.mock_faker.name.assert_called_once() def test_escape_braces(self): # Test that escaped braces are handled correctly template = "Escaped braces: \\{name()\\}" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Escaped braces: \\{name()\\}" self.assertEqual(string_template, expected) self.mock_faker.name.assert_not_called() def test_placeholder_with_no_parentheses(self): # Test that placeholders without parentheses are handled (assuming # they require parentheses). template = "Hello, {name}!" string_template = StringTemplate(template, faker=self.mock_faker) # The regex expects parentheses, so {name} should remain unchanged expected = "Hello, John Doe!" self.assertEqual(string_template, expected) self.mock_faker.assert_not_called() def test_placeholder_with_empty_arguments(self): # Test placeholders with empty parentheses template = "Hello, {name()} and {sentence()}!" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe and This is a test sentence.!" self.assertEqual(string_template, expected) self.mock_faker.name.assert_called_once() self.mock_faker.sentence.assert_called_once() def test_placeholder_with_spaces_in_arguments(self): # Test placeholders where arguments contain spaces template = ( "Date: {date(start_date = '2020-01-01', end_date = '2020-12-31')}" ) string_template = StringTemplate(template, faker=self.mock_faker) expected = "Date: 2023-01-01" self.assertEqual(string_template, expected) self.mock_faker.date.assert_called_once_with( start_date="2020-01-01", end_date="2020-12-31" ) def test_placeholder_with_numeric_method_name(self): # Assuming method names are purely alphabetic, but testing with # numeric characters. template = "Numeric method: {method123()}!" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Numeric method: Numeric method!" self.assertEqual(string_template, expected) self.mock_faker.method123.assert_called_once() def test_placeholder_with_underscores_in_method_name(self): # Test method names with underscores template = "Underscore method: {custom_method()}!" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Underscore method: Custom value!" self.assertEqual(string_template, expected) self.mock_faker.custom_method.assert_called_once() def test_placeholder_with_boolean_arguments(self): # Test placeholders with boolean arguments template = "Boolean: {boolean_method(flag=True)}" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Boolean: Boolean result" self.assertEqual(string_template, expected) self.mock_faker.boolean_method.assert_called_once_with(flag=True) def test_join_with_string_template(self): # Test that StringTemplate can be used directly with join templates = [ StringTemplate("Hello, {name()}!", faker=self.mock_faker), StringTemplate("Welcome, {name()}!", faker=self.mock_faker), StringTemplate("Goodbye, {name()}!", faker=self.mock_faker), ] expected = ( "Hello, John Doe!\n---\nWelcome, John Doe!\n---\nGoodbye, John Doe!" ) joined_string = "\n---\n".join(templates) self.assertEqual(joined_string, expected) self.mock_faker.name.assert_called_with() self.assertEqual(self.mock_faker.name.call_count, 3) def test_large_number_of_placeholders(self): # Test performance and correctness with a large number of placeholders template = "User {name()} has email {email()}." * 1000 self.mock_faker.email.return_value = "john.doe@example.com" string_template = StringTemplate(template, faker=self.mock_faker) expected = "User John Doe has email john.doe@example.com." * 1000 self.assertEqual(string_template, expected) self.assertEqual(self.mock_faker.name.call_count, 1000) self.assertEqual(self.mock_faker.email.call_count, 1000) def test_join_with_no_templates(self): # Test joining an empty list templates = [] expected = "" joined_string = "\n---\n".join(templates) self.assertEqual(joined_string, expected) def test_join_with_single_template(self): # Test joining a single template template = "Hello, {name()}!" string_template = StringTemplate(template, faker=self.mock_faker) expected = "Hello, John Doe!" joined_string = "\n---\n".join([string_template]) self.assertEqual(joined_string, expected) self.mock_faker.name.assert_called_once() fake.py-0.11.9/fakepy/000077500000000000000000000000001510566137200144245ustar00rootroot00000000000000fake.py-0.11.9/fakepy/__init__.py000066400000000000000000000000351510566137200165330ustar00rootroot00000000000000# from fake import * # noqa fake.py-0.11.9/pyproject.toml000066400000000000000000000124751510566137200160720ustar00rootroot00000000000000[project] name = "fake.py" description = "Minimalistic, standalone alternative fake data generator with no dependencies." readme = "README.rst" version = "0.11.9" dependencies = [] authors = [ {name = "Artur Barseghyan", email = "artur.barseghyan@gmail.com"}, ] maintainers = [ {name = "Artur Barseghyan", email = "artur.barseghyan@gmail.com"}, ] license = "MIT" classifiers = [ "Development Status :: 4 - Beta", "Intended Audience :: Developers", "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Programming Language :: Python :: 3.13", "Programming Language :: Python :: 3.14", "Programming Language :: Python :: 3.9", "Programming Language :: Python", "Topic :: Software Development :: Testing", "Topic :: Software Development", ] keywords = ["fake data", "test data"] [project.urls] Homepage = "https://github.com/barseghyanartur/fake.py/" Issues = "https://github.com/barseghyanartur/fake.py/issues" Documentation = "https://fakepy.readthedocs.io/" Repository = "https://github.com/barseghyanartur/fake.py/" Changelog = "https://fakepy.readthedocs.io/en/latest/changelog.html" [project.optional-dependencies] all = ["fake.py[dev,test,docs]"] dev = [ "build", "detect-secrets", "doc8", "ipython", "mypy", "pkginfo", "pydoclint", "ruff", "twine", "uv", "wheel", ] test = [ "django", "pytest<9.0", "pytest-cov", "pytest-django", "pytest-codeblock", ] docs = [ "sphinx<6.0", "sphinx-autobuild", "sphinx-rtd-theme>=1.3.0", "sphinx-no-pragma", ] [project.scripts] fake-py = "fake:main" [tool.setuptools] py-modules = ["fake"] [tool.setuptools.packages.find] where = ["."] include = ["fakepy"] exclude = [".github", "docs*", "examples*"] # Build system information below. [build-system] requires = ["setuptools>=41.0", "setuptools-scm", "wheel"] build-backend = "setuptools.build_meta" [tool.ruff] line-length = 80 # Enable Pyflakes `E` and `F` codes by default. lint.select = [ # "ANN", # Annotations: missing (return) types "B", # Bugbear: common bug patterns or design problems "C4", # Complexity: McCabe complexity checker "E", # Pycodesyle: Style guide enforcement "F", # Pyflakes: Source files errors "G", # Logging format: Basic logging format errors "I", # Isort: import sorting "ISC", # Naming: Variable naming convention "INP", # Implicit namespace packages: Check if __init__.py is present "N", # Naming: Variable naming convention "PERF", # Perflint: Performance linting "Q", "SIM", # Simplify: Helps simplify your code "TD", # TO DO: Format TO DO comments ] lint.ignore = [ "G004", # Allow use of f-string in logging "ISC003", # Allow explicitly concatenated strings # "N805", # Allow first argument of a method be named other than `self` "TD002", # Allow to do without author "TD003", # Allow to do without URL ] # Enable autofix for formatting and import sorting fix = true src = [ "examples/customisation", "examples/dataclasses", "examples/django", "examples/hypothesis", "examples/lazyfuzzy", "examples/pydantic", "examples/sqlalchemy", "examples/sqlmodel", "examples/tortoise", ] # Exclude a variety of commonly ignored directories. exclude = [ ".bzr", ".direnv", ".eggs", ".git", ".hg", ".mypy_cache", ".nox", ".pants.d", ".ruff_cache", ".svn", ".tox", ".venv", "__pypackages__", "_build", "buck-out", "build", "dist", "node_modules", "venv", "docs", ] # Allow unused variables when underscore-prefixed. lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" # Assume Python 3.9. target-version = "py39" [tool.ruff.lint.per-file-ignores] "conftest.py" = [ "PERF203" # Allow `try`-`except` within a loop incurs performance overhead ] [tool.ruff.lint.isort] known-first-party = [ "address", "article", "band", "config", "data", "fake_address", "fake_band", "override_default_data", ] known-third-party = [] [tool.doc8] ignore-path = [ "docs/requirements.txt", "fake.py.egg-info/SOURCES.txt", ] [tool.pytest.ini_options] addopts = [ "-ra", "-vvv", "-q", "--cov=fake", "--ignore=.tox", "--ignore=requirements", "--ignore=release", "--ignore=examples", "--ignore=tmp", "--cov-report=html", "--cov-report=term", "--cov-report=annotate", "--cov-append", "--capture=no", ] testpaths = [ "fake.py", "__copy_fake.py", "*.rst", "**/*.rst", "docs/test_docs.py", ] pythonpath = [ "examples/django", ] norecursedirs = [ ".git", "examples", ] DJANGO_SETTINGS_MODULE = "blog.settings" [tool.coverage.run] relative_files = true omit = [ ".tox/*", ] [tool.coverage.report] show_missing = true exclude_lines = [ "pragma: no cover", "@overload", ] [tool.mypy] check_untyped_defs = true warn_unused_ignores = true warn_redundant_casts = true warn_unused_configs = true [tool.pydoclint] style = 'sphinx' exclude = '\.git|\.tox|tests/data|__copy_fake\.py' require-return-section-when-returning-nothing = false allow-init-docstring = true arg-type-hints-in-docstring = false fake.py-0.11.9/tox.ini000066400000000000000000000043601510566137200144630ustar00rootroot00000000000000[tox] envlist = py{39,310,311,312,313} py{39,310,311,312,313}-{customisation,dataclasses,django,hypothesis,lazyfuzzy,pydantic,sqlalchemy,sqlmodel,tortoise} skip_build = True [testenv] passenv = * allowlist_externals=* commands = cd {toxinidir} && {envpython} -m pip install -e .[all] {envpython} -m pytest -vrx [testenv:py{39,310,311,312,313}-customisation] changedir = examples/customisation commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} manage.py test [testenv:py{39,310,311,312,313}-dataclasses] changedir = examples/dataclasses commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} manage.py test [testenv:py{39,310,311,312,313}-django] changedir = examples/django commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} -m pip install -r requirements.in {envpython} manage.py test [testenv:py{39,310,311,312,313}-hypothesis] changedir = examples/hypothesis commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} -m pip install -r requirements.in {envpython} manage.py test [testenv:py{39,310,311,312,313}-lazyfuzzy] changedir = examples/lazyfuzzy commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} manage.py test [testenv:py{39,310,311,312,313}-pydantic] changedir = examples/pydantic commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} -m pip install -r requirements.in {envpython} manage.py test [testenv:py{39,310,311,312,313}-sqlalchemy] changedir = examples/sqlalchemy commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} -m pip install -r requirements.in {envpython} manage.py test [testenv:py{39,310,311,312,313}-sqlmodel] changedir = examples/sqlmodel commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} -m pip install -r requirements.in {envpython} manage.py test [testenv:py{39,310,311,312,313}-tortoise] changedir = examples/tortoise commands = sh -c 'cd {toxinidir} && {envpython} -m pip install -e .[all]' {envpython} -m pip install -r requirements.in {envpython} manage.py test