pax_global_header00006660000000000000000000000064150444162620014516gustar00rootroot0000000000000052 comment=75efebf195ba1a7102e1e2e6e81d7a8a75998719 time-machine-2.17.0/000077500000000000000000000000001504441626200141455ustar00rootroot00000000000000time-machine-2.17.0/.editorconfig000066400000000000000000000003451504441626200166240ustar00rootroot00000000000000# http://editorconfig.org root = true [*] indent_style = space indent_size = 2 trim_trailing_whitespace = true insert_final_newline = true charset = utf-8 end_of_line = lf [*.py] indent_size = 4 [Makefile] indent_style = tab time-machine-2.17.0/.github/000077500000000000000000000000001504441626200155055ustar00rootroot00000000000000time-machine-2.17.0/.github/CODE_OF_CONDUCT.md000066400000000000000000000001311504441626200202770ustar00rootroot00000000000000This project follows [Django's Code of Conduct](https://www.djangoproject.com/conduct/). time-machine-2.17.0/.github/FUNDING.yml000066400000000000000000000001231504441626200173160ustar00rootroot00000000000000github: adamchainz tidelift: pypi/time-machine custom: - "https://adamj.eu/books/" time-machine-2.17.0/.github/ISSUE_TEMPLATE/000077500000000000000000000000001504441626200176705ustar00rootroot00000000000000time-machine-2.17.0/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000000341504441626200216550ustar00rootroot00000000000000blank_issues_enabled: false time-machine-2.17.0/.github/ISSUE_TEMPLATE/feature-request.yml000066400000000000000000000004111504441626200235300ustar00rootroot00000000000000name: Feature Request description: Request an enhancement or new feature. body: - type: textarea id: description attributes: label: Description description: Please describe your feature request with appropriate detail. validations: required: true time-machine-2.17.0/.github/ISSUE_TEMPLATE/issue.yml000066400000000000000000000015371504441626200215510ustar00rootroot00000000000000name: Issue description: File an issue body: - type: input id: python_version attributes: label: Python Version description: Which version of Python were you using? placeholder: 3.9.0 validations: required: false - type: input id: pytest_version attributes: label: pytest Version description: Which version of pytest were you using (if any)? placeholder: 6.2.4 validations: required: false - type: input id: package_version attributes: label: Package Version description: Which version of this package were you using? If not the latest version, please check this issue has not since been resolved. placeholder: 1.0.0 validations: required: false - type: textarea id: description attributes: label: Description description: Please describe your issue. validations: required: true time-machine-2.17.0/.github/SECURITY.md000066400000000000000000000001011504441626200172660ustar00rootroot00000000000000Please report security issues directly over email to me@adamj.eu time-machine-2.17.0/.github/dependabot.yml000066400000000000000000000002471504441626200203400ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: github-actions directory: "/" groups: "GitHub Actions": patterns: - "*" schedule: interval: monthly time-machine-2.17.0/.github/workflows/000077500000000000000000000000001504441626200175425ustar00rootroot00000000000000time-machine-2.17.0/.github/workflows/main.yml000066400000000000000000000074141504441626200212170ustar00rootroot00000000000000name: CI on: push: branches: - main tags: - '**' pull_request: concurrency: group: ${{ github.head_ref || github.run_id }} cancel-in-progress: true jobs: tests: name: Python ${{ matrix.python-version }} runs-on: ubuntu-24.04 strategy: matrix: python-version: - '3.9' - '3.10' - '3.11' - '3.12' - '3.13' - '3.13t' - '3.14' - '3.14t' steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} allow-prereleases: true - name: Install uv uses: astral-sh/setup-uv@v6 with: enable-cache: true - name: Run tox targets for ${{ matrix.python-version }} run: uvx --with tox-uv tox run -f py$(echo ${{ matrix.python-version }} | tr -d .) - name: Upload coverage data uses: actions/upload-artifact@v4 with: name: coverage-data-${{ matrix.python-version }} path: '${{ github.workspace }}/.coverage.*' include-hidden-files: true if-no-files-found: error coverage: name: Coverage runs-on: ubuntu-24.04 needs: tests steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: python-version: '3.13' - name: Install uv uses: astral-sh/setup-uv@v6 - name: Install dependencies run: uv pip install --system coverage[toml] - name: Download data uses: actions/download-artifact@v4 with: path: ${{ github.workspace }} pattern: coverage-data-* merge-multiple: true - name: Combine coverage and fail if it's <100% run: | python -m coverage combine python -m coverage html --skip-covered --skip-empty python -m coverage report --fail-under=100 echo "## Coverage summary" >> $GITHUB_STEP_SUMMARY python -m coverage report --format=markdown >> $GITHUB_STEP_SUMMARY - name: Upload HTML report if: ${{ failure() }} uses: actions/upload-artifact@v4 with: name: html-report path: htmlcov build: name: Build wheels on ${{ matrix.os }} if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'Build') strategy: matrix: os: - linux - macos - windows runs-on: ${{ (matrix.os == 'linux' && 'ubuntu-24.04') || (matrix.os == 'macos' && 'macos-15') || (matrix.os == 'windows' && 'windows-2022') || 'unknown' }} steps: - uses: actions/checkout@v4 - uses: astral-sh/setup-uv@v6 - name: Set up QEMU uses: docker/setup-qemu-action@v3 if: matrix.os == 'linux' with: platforms: all - name: Build sdist if: ${{ matrix.os == 'linux' }} run: uv build --sdist - name: Build wheels run: uvx --from cibuildwheel==3.1.2 cibuildwheel --output-dir dist - run: ${{ (matrix.os == 'windows' && 'dir') || 'ls -lh' }} dist/ - uses: actions/upload-artifact@v4 with: name: dist-${{ matrix.os }} path: dist release: needs: [coverage, build] if: success() && startsWith(github.ref, 'refs/tags/') runs-on: ubuntu-24.04 environment: release permissions: contents: read id-token: write steps: - uses: actions/checkout@v4 - name: get dist artifacts uses: actions/download-artifact@v4 with: merge-multiple: true pattern: dist-* path: dist - uses: pypa/gh-action-pypi-publish@release/v1 time-machine-2.17.0/.gitignore000066400000000000000000000001211504441626200161270ustar00rootroot00000000000000*.egg-info/ *.pyc *.so /.coverage /.coverage.* /.tox /build/ /dist/ /wheelhouse/ time-machine-2.17.0/.pre-commit-config.yaml000066400000000000000000000032351504441626200204310ustar00rootroot00000000000000ci: autoupdate_schedule: monthly default_language_version: python: python3.13 repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: cef0300fd0fc4d2a87a85fa2093c6b283ea36f4b # frozen: v5.0.0 hooks: - id: check-added-large-files - id: check-case-conflict - id: check-json - id: check-merge-conflict - id: check-symlinks - id: check-toml - id: end-of-file-fixer - id: trailing-whitespace - repo: https://github.com/crate-ci/typos rev: 8d96c408b0dca5cc2e5b125482e8aabe5473e153 # frozen: v1 hooks: - id: typos - repo: https://github.com/tox-dev/pyproject-fmt rev: 8184a5b72f4a8fcd003b041ecb04c41a9f34fd2b # frozen: v2.6.0 hooks: - id: pyproject-fmt additional_dependencies: ["tox>=4.9"] - repo: https://github.com/tox-dev/tox-ini-fmt rev: 4e2cb0e98735e1a57a027d9440b91663e31d10b0 # frozen: 1.6.0 hooks: - id: tox-ini-fmt - repo: https://github.com/rstcheck/rstcheck rev: 27258fde1ee7d3b1e6a7bbc58f4c7b1dd0e719e5 # frozen: v6.2.5 hooks: - id: rstcheck additional_dependencies: - sphinx==8.1.3 - tomli==2.0.1 - repo: https://github.com/adamchainz/blacken-docs rev: 78a9dcbecf4f755f65d1f3dec556bc249d723600 # frozen: 1.19.1 hooks: - id: blacken-docs additional_dependencies: - black==25.1.0 - repo: https://github.com/astral-sh/ruff-pre-commit rev: 4cbc74d53fe5634e58e0e65db7d28939c9cec3f7 # frozen: v0.12.7 hooks: - id: ruff-check args: [ --fix ] - id: ruff-format - repo: https://github.com/pre-commit/mirrors-mypy rev: 412de98d50e846f31ea6f4b0ad036f2c24a7a024 # frozen: v1.17.1 hooks: - id: mypy additional_dependencies: - pytest==7.1.2 - types-python-dateutil time-machine-2.17.0/.readthedocs.yaml000066400000000000000000000011071504441626200173730ustar00rootroot00000000000000# .readthedocs.yml # Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details version: 2 build: os: ubuntu-24.04 tools: python: "3.13" jobs: pre_create_environment: - asdf plugin add uv - asdf install uv latest - asdf global uv latest create_environment: - uv venv "${READTHEDOCS_VIRTUALENV_PATH}" install: - UV_PROJECT_ENVIRONMENT="${READTHEDOCS_VIRTUALENV_PATH}" uv sync --frozen --group docs sphinx: configuration: docs/conf.py fail_on_warning: true formats: all time-machine-2.17.0/.typos.toml000066400000000000000000000004131504441626200162740ustar00rootroot00000000000000# Configuration file for 'typos' tool # https://github.com/crate-ci/typos [default] extend-ignore-re = [ # Single line ignore comments "(?Rm)^.*(#|//)\\s*typos: ignore$", # Multi-line ignore comments "(?s)(#|//)\\s*typos: off.*?\\n\\s*(#|//)\\s*typos: on" ] time-machine-2.17.0/CHANGELOG.rst000066400000000000000000000001011504441626200161560ustar00rootroot00000000000000See https://time-machine.readthedocs.io/en/latest/changelog.html time-machine-2.17.0/HISTORY.rst000066400000000000000000000001071504441626200160360ustar00rootroot00000000000000See https://github.com/adamchainz/time-machine/blob/main/CHANGELOG.rst time-machine-2.17.0/LICENSE000066400000000000000000000020551504441626200151540ustar00rootroot00000000000000MIT License Copyright (c) 2020 Adam Johnson 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. time-machine-2.17.0/MANIFEST.in000066400000000000000000000001631504441626200157030ustar00rootroot00000000000000prune tests include CHANGELOG.rst include LICENSE include pyproject.toml include README.rst include src/*/py.typed time-machine-2.17.0/README.rst000066400000000000000000000023221504441626200156330ustar00rootroot00000000000000============ time-machine ============ .. image:: https://img.shields.io/readthedocs/time-machine?style=for-the-badge :target: https://time-machine.readthedocs.io/en/latest/ .. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/time-machine/main.yml.svg?branch=main&style=for-the-badge :target: https://github.com/adamchainz/time-machine/actions?workflow=CI .. image:: https://img.shields.io/badge/Coverage-100%25-success?style=for-the-badge :target: https://github.com/adamchainz/time-machine/actions?workflow=CI .. image:: https://img.shields.io/pypi/v/time-machine.svg?style=for-the-badge :target: https://pypi.org/project/time-machine/ .. image:: https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge :target: https://github.com/psf/black .. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge :target: https://github.com/pre-commit/pre-commit :alt: pre-commit ---- .. figure:: https://raw.githubusercontent.com/adamchainz/time-machine/main/docs/_static/logo.svg :alt: time-machine logo :align: center Documentation ============= Please see https://time-machine.readthedocs.io/. time-machine-2.17.0/docs/000077500000000000000000000000001504441626200150755ustar00rootroot00000000000000time-machine-2.17.0/docs/.gitignore000066400000000000000000000000111504441626200170550ustar00rootroot00000000000000/_build/ time-machine-2.17.0/docs/Makefile000066400000000000000000000011771504441626200165430ustar00rootroot00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= "-W" 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) time-machine-2.17.0/docs/_static/000077500000000000000000000000001504441626200165235ustar00rootroot00000000000000time-machine-2.17.0/docs/_static/logo.svg000066400000000000000000000532101504441626200202050ustar00rootroot00000000000000 time-machine-2.17.0/docs/changelog.rst000066400000000000000000000172121504441626200175610ustar00rootroot00000000000000========= Changelog ========= 2.17.0 (2025-08-05) ------------------- * Include wheels for Python 3.14. Thanks to Edgar Ramírez Mondragón in `PR #521 `__. * Support free-threaded Python. Thanks to Javier Buzzi in `PR #500 `__. * Add a new CLI for migrating code from freezegun to time-machine. Install with ``pip install time-machine[cli]`` and run with ``python -m time_machine migrate``. See more :ref:`in the documentation `. * Move the documentation to `Read the Docs `__, and add a retro-futuristic logo. 2.16.0 (2024-10-08) ------------------- * Drop Python 3.8 support. 2.15.0 (2024-08-06) ------------------- * Include wheels for Python 3.13. 2.14.2 (2024-06-29) ------------------- * Fix ``SystemError`` on Python 3.13 and Windows when starting time travelling. Thanks to Bernát Gábor for the report in `Issue #456 `__. 2.14.1 (2024-03-22) ------------------- * Fix segmentation fault when the first ``travel()`` call in a process uses a ``timedelta``. Thanks to Marcin Sulikowski for the report in `Issue #431 `__. 2.14.0 (2024-03-03) ------------------- * Fix ``utcfromtimestamp()`` warning on Python 3.12+. Thanks to Konstantin Baikov in `PR #424 `__. * Fix class decorator for classmethod overrides. Thanks to Pavel Bitiukov for the reproducer in `PR #404 `__. * Avoid calling deprecated ``uuid._load_system_functions()`` on Python 3.9+. Thanks to Nikita Sobolev for the ping in `CPython Issue #113308 `__. * Support Python 3.13 alpha 4. Thanks to Miro Hrončok in `PR #409 `__. 2.13.0 (2023-09-19) ------------------- * Add support for ``datetime.timedelta`` to ``time_machine.travel()``. Thanks to Nate Dudenhoeffer in `PR #298 `__. * Fix documentation about using local time for naive date(time) strings. Thanks to Stefaan Lippens in `PR #306 `__. * Add ``shift()`` method to the ``time_machine`` pytest fixture. Thanks to Stefaan Lippens in `PR #312 `__. * Mock ``time.monotonic()`` and ``time.monotonic_ns()``. They return the values of ``time.time()`` and ``time.time_ns()`` respectively, rather than real monotonic clocks. Thanks to Anthony Sottile in `PR #382 `__. 2.12.0 (2023-08-14) ------------------- * Include wheels for Python 3.12. 2.11.0 (2023-07-10) ------------------- * Drop Python 3.7 support. 2.10.0 (2023-06-16) ------------------- * Support Python 3.12. 2.9.0 (2022-12-31) ------------------ * Build Windows ARM64 wheels. * Explicitly error when attempting to install on PyPy. Thanks to Michał Górny in `PR #315 `__. 2.8.2 (2022-09-29) ------------------ * Improve type hints for ``time_machine.travel()`` to preserve the types of the wrapped function/coroutine/class. 2.8.1 (2022-08-16) ------------------ * Actually build Python 3.11 wheels. 2.8.0 (2022-08-15) ------------------ * Build Python 3.11 wheels. 2.7.1 (2022-06-24) ------------------ * Fix usage of ``ZoneInfo`` from the ``backports.zoneinfo`` package. This makes ``ZoneInfo`` support work for Python < 3.9. 2.7.0 (2022-05-11) ------------------ * Support Python 3.11 (no wheels yet, they will only be available when Python 3.11 is RC when the ABI is stable). 2.6.0 (2022-01-10) ------------------ * Drop Python 3.6 support. 2.5.0 (2021-12-14) ------------------ * Add ``time_machine.escape_hatch``, which provides functions to bypass time-machine. Thanks to Matt Pegler for the feature request in `Issue #206 `__. 2.4.1 (2021-11-27) ------------------ * Build musllinux wheels. 2.4.0 (2021-09-01) ------------------ * Support Python 3.10. 2.3.1 (2021-07-13) ------------------ * Build universal2 wheels for Python 3.8 on macOS. 2.3.0 (2021-07-05) ------------------ * Allow passing ``tick`` to ``Coordinates.move_to()`` and the pytest fixture’s ``time_machine.move_to()``. This allows freezing or unfreezing of time when travelling. 2.2.0 (2021-07-02) ------------------ * Include type hints. * Convert C module to use PEP 489 multi-phase extension module initialization. This makes the module ready for Python sub-interpreters. * Release now includes a universal2 wheel for Python 3.9 on macOS, to work on Apple Silicon. * Stop distributing tests to reduce package size. Tests are not intended to be run outside of the tox setup in the repository. Repackagers can use GitHub's tarballs per tag. 2.1.0 (2021-02-19) ------------------ * Release now includes wheels for ARM on Linux. 2.0.1 (2021-01-18) ------------------ * Prevent ``ImportError`` on Windows where ``time.tzset()`` is unavailable. 2.0.0 (2021-01-17) ------------------ * Release now includes wheels for Windows and macOS. * Move internal calculations to use nanoseconds, avoiding a loss of precision. * After a call to ``move_to()``, the first function call to retrieve the current time will return exactly the destination time, copying the behaviour of the first call to ``travel()``. * Add the ability to shift timezone by passing in a ``ZoneInfo`` timezone. * Remove ``tz_offset`` argument. This was incorrectly copied from ``freezegun``. Use the new timezone mocking with ``ZoneInfo`` instead. * Add pytest plugin and fixture ``time_machine``. * Work with Windows’ different epoch. 1.3.0 (2020-12-12) ------------------ * Support Python 3.9. * Move license from ISC to MIT License. 1.2.1 (2020-08-29) ------------------ * Correctly return naive datetimes from ``datetime.utcnow()`` whilst time travelling. Thanks to Søren Pilgård and Bart Van Loon for the report in `Issue #52 `__. 1.2.0 (2020-07-08) ------------------ * Add ``move_to()`` method to move to a different time whilst travelling. This is based on freezegun's ``move_to()`` method. 1.1.1 (2020-06-22) ------------------ * Move C-level ``clock_gettime()`` and ``clock_gettime_ns()`` checks to runtime to allow distribution of macOS wheels. 1.1.0 (2020-06-08) ------------------ * Add ``shift()`` method to move forward in time by a delta whilst travelling. This is based on freezegun's ``tick()`` method. Thanks to Alex Subbotin for the feature in `PR #27 `__. * Fix to work when either ``clock_gettime()`` or ``CLOCK_REALTIME`` is not present. This happens on some Unix platforms, for example on macOS with the official Python.org installer, which is compiled against macOS 10.9. Thanks to Daniel Crowe for the fix in `PR #30 `__. 1.0.1 (2020-05-29) ------------------ * Fix ``datetime.now()`` behaviour with the ``tz`` argument when not time-travelling. 1.0.0 (2020-05-29) ------------------ * First non-beta release. * Added support for ``tz_offset`` argument. * ``tick=True`` will only start time ticking after the first method return that retrieves the current time. * Added nestability of ``travel()``. * Support for ``time.time_ns()`` and ``time.clock_gettime_ns()``. 1.0.0b1 (2020-05-04) -------------------- * First release on PyPI. time-machine-2.17.0/docs/comparison.rst000066400000000000000000000101601504441626200177770ustar00rootroot00000000000000========== Comparison ========== There are some prior libraries that try to achieve the same thing, with their own strengths and weaknesses. Here's a quick comparison. unittest.mock ------------- The standard library's `unittest.mock `__ can be used to target imports of ``datetime`` and ``time`` to change the returned value for current time. Unfortunately, this is fragile as it only affects the import location the mock targets. Therefore, if you have several modules in a call tree requesting the date/time, you need several mocks. This is a general problem with unittest.mock - see `Why Your Mock Doesn't Work `__. It's also impossible to mock certain references, such as function default arguments: .. code-block:: python def update_books(_now=time.time): # set as default argument so faster lookup for book in books: ... Although such references are rare, they are occasionally used to optimize highly repeated loops. freezegun --------- Steve Pulec's `freezegun `__ library is a popular solution. It provides a clear API which was much of the inspiration for time-machine. The main drawback is its slow implementation. It essentially does a find-and-replace mock of all the places that the ``datetime`` and ``time`` modules have been imported. This gets around the problems with using unittest.mock, but it means the time it takes to do the mocking is proportional to the number of loaded modules. In large projects, this can take several seconds, an impractical overhead for an individual test. It's also not a perfect search, since it searches only module-level imports. Such imports are definitely the most common way projects use date and time functions, but they're not the only way. freezegun won’t find functions that have been “hidden” inside arbitrary objects, such as class-level attributes. It also can't affect C extensions that call the standard library functions, including (I believe) Cython-ized Python code. python-libfaketime ------------------ Simon Weber's `python-libfaketime `__ wraps the `libfaketime `__ library. libfaketime replaces all the C-level system calls for the current time with its own wrappers. It's therefore a "perfect" mock for the current process, affecting every single point the current time might be fetched, and performs much faster than freezegun. Unfortunately python-libfaketime comes with the limitations of ``LD_PRELOAD``. This is a mechanism to replace system libraries for a program as it loads (`explanation `__). This causes two issues in particular when you use python-libfaketime. First, ``LD_PRELOAD`` is only available on Unix platforms, which prevents you from using it on Windows. Second, you have to help manage ``LD_PRELOAD``. You either use python-libfaketime's ``reexec_if_needed()`` function, which restarts (*re-execs*) your test process while loading, or manually manage the ``LD_PRELOAD`` environment variable. Neither is ideal. Re-execing breaks anything that might wrap your test process, such as profilers, debuggers, and IDE test runners. Manually managing the environment variable is a bit of overhead, and must be done for each environment you run your tests in, including each developer's machine. time-machine ------------ time-machine is intended to combine the advantages of freezegun and libfaketime. It works without ``LD_PRELOAD`` but still mocks the standard library functions everywhere they may be referenced. Its weak point is that other libraries using date/time system calls won't be mocked. Thankfully this is rare. It's also possible such python libraries can be added to the set mocked by time-machine. One drawback is that it only works with CPython, so can't be used with other Python interpreters like PyPy. However it may possible to extend it to support other interpreters through different mocking mechanisms. time-machine-2.17.0/docs/conf.py000066400000000000000000000047731504441626200164070ustar00rootroot00000000000000# Configuration file for the Sphinx documentation builder. # # This file only contains a selection of the most common options. For a full # list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html from __future__ import annotations import os import sys from pathlib import Path import tomllib # -- Path setup -------------------------------------------------------------- here = Path(__file__).parent.resolve() sys.path.insert(0, str(here / ".." / "src")) # -- Project information ----------------------------------------------------- with (here / ".." / "pyproject.toml").open("rb") as fp: pyproject_toml_data = tomllib.load(fp) project = pyproject_toml_data["project"]["name"] copyright = "2020 Adam Johnson" author = "Adam Johnson" # The version info for the project you're documenting, acts as replacement # for |version| and |release|, also used in various other places throughout # the built documents. version = pyproject_toml_data["project"]["version"] release = version # -- General configuration --------------------------------------------------- # 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", "sphinx_copybutton", ] if os.environ.get("READTHEDOCS") == "True": extensions.append("sphinx_build_compatibility.extension") # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = [ ".venv", "_build", ] autodoc_typehints = "description" # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_logo = "_static/logo.svg" html_theme = "furo" html_theme_options = { "dark_css_variables": { "admonition-font-size": "100%", "admonition-title-font-size": "100%", }, "light_css_variables": { "admonition-font-size": "100%", "admonition-title-font-size": "100%", }, } # -- Options for LaTeX output ------------------------------------------ # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass # [howto/manual]). latex_documents = [ ( "index", "time-machine.tex", "time-machine Documentation", "Adam Johnson", "manual", ), ] time-machine-2.17.0/docs/index.rst000066400000000000000000000023731504441626200167430ustar00rootroot00000000000000time-machine documentation ========================== *Travel through time in your tests.* A quick example: .. code-block:: python import datetime as dt from zoneinfo import ZoneInfo import time_machine hill_valley_tz = ZoneInfo("America/Los_Angeles") @time_machine.travel(dt.datetime(1985, 10, 26, 1, 24, tzinfo=hill_valley_tz)) def test_delorean(): assert dt.date.today().isoformat() == "1985-10-26" For a bit of background, see `the introductory blog post `__ and `the benchmark blog post `__. ---- **Testing a Django project?** Check out my book `Speed Up Your Django Tests `__ which covers loads of ways to write faster, more accurate tests. I created time-machine whilst writing the book. ---- time-machine is a tool for mocking the time in tests. To get started, see :doc:`installation`, :doc:`usage`, and :doc:`pytest_plugin`. If you’re coming from freezegun or libfaketime, see :doc:`comparison` and :doc:`migration`. .. toctree:: :maxdepth: 1 :caption: Contents: installation usage pytest_plugin changelog comparison migration time-machine-2.17.0/docs/installation.rst000066400000000000000000000005431504441626200203320ustar00rootroot00000000000000============ Installation ============ Requirements ------------ Python 3.9 to 3.14 supported, including free-threaded variants from Python 3.13 onwards. Only CPython is supported at this time because time-machine directly hooks into the C-level API. Installation ------------ Use **pip**: .. code-block:: sh python -m pip install time-machine time-machine-2.17.0/docs/migration.rst000066400000000000000000000071171504441626200176260ustar00rootroot00000000000000======================================= Migrating from freezegun or libfaketime ======================================= freezegun has a useful API, and python-libfaketime copies some of it, with a different function name. time-machine also copies some of freezegun's API, in ``travel()``\'s ``destination``, and ``tick`` arguments, and the ``shift()`` method. There are a few differences: * time-machine's ``tick`` argument defaults to ``True``, because code tends to make the (reasonable) assumption that time progresses whilst running, and should normally be tested as such. Testing with time frozen can make it easy to write exact assertions, but it's quite artificial. Write assertions against time ranges, rather than against exact values. * freezegun interprets dates and naive datetimes in the local time zone (including those parsed from strings with ``dateutil``). This means tests can pass when run in one time zone and fail in another. time-machine instead interprets dates and naive datetimes in UTC so they are fixed points in time. Provide time zones where required. * freezegun's ``tick()`` method has been implemented as ``shift()``, to avoid confusion with the ``tick`` argument. It also requires an explicit delta rather than defaulting to 1 second. * freezegun's ``tz_offset`` argument is not supported, since it only partially mocks the current time zone. Time zones are more complicated than a single offset from UTC, and freezegun only uses the offset in ``time.localtime()``. Instead, time-machine will mock the current time zone if you give it a ``datetime`` with a ``ZoneInfo`` timezone. Some features aren't supported like the ``auto_tick_seconds`` argument. These may be added in a future release. If you are only fairly simple function calls, you should be able to migrate by replacing calls to ``freezegun.freeze_time()`` and ``libfaketime.fake_time()`` with ``time_machine.travel()``. .. _migration-cli: Migration CLI ============= time-machine comes with a command-line interface to help you migrate from freezegun. It performs partial replacements on your code to update it to use time-machine's API. It may leave your code in a broken state, for example where an import of ``freezegun`` has been replaced but calls using it remain—it’s recommended you have a good linting setup to find these, and then you can manually fix them up. To run the tool, first install time-machine with its ``cli`` extra: .. code-block:: console $ python -m pip install time-machine[cli] Then run the ``migrate`` subcommand of the module on target files: .. code-block:: console $ python -m time_machine migrate example/tests.py Rewriting example/tests.py The tool edits files in place, reporting those that it changes. It’s recommended you start from a clean, committed state in your version control system, so you can easily revert any broken changes. To run the tool against all files from your Git repository, follow `this blog post `__. The changes the tool makes are: * ``import freezegun`` -> ``import time_machine`` * ``from freezegun import freeze_time`` -> ``from time_machine import travel`` * In function decorators, class decorators, and context managers: ``freeze_time(...)`` -> ``travel(..., tick=False)``. This change is only applied when ``freeze_time()`` is called with a single positional argument. In context managers, it’s only applied when the result isn’t assigned to a variable with ``as``. The tool is open to extension to cover other compatible changes—PRs welcome! time-machine-2.17.0/docs/pytest_plugin.rst000066400000000000000000000026151504441626200205410ustar00rootroot00000000000000============= pytest plugin ============= time-machine also works as a pytest plugin. It provides a function-scoped fixture called ``time_machine`` with methods ``move_to()`` and ``shift()``, which have the same signature as their equivalents in ``Coordinates``. This can be used to mock your test at different points in time and will automatically be un-mock when the test is torn down. For example: .. code-block:: python import datetime as dt def test_delorean(time_machine): time_machine.move_to(dt.datetime(1985, 10, 26)) assert dt.date.today().isoformat() == "1985-10-26" time_machine.move_to(dt.datetime(2015, 10, 21)) assert dt.date.today().isoformat() == "2015-10-21" time_machine.shift(dt.timedelta(days=1)) assert dt.date.today().isoformat() == "2015-10-22" If you are using pytest test classes, you can apply the fixture to all test methods in a class by adding an autouse fixture: .. code-block:: python import time import pytest class TestSomething: @pytest.fixture(autouse=True) def set_time(self, time_machine): time_machine.move_to(1000.0) def test_one(self): assert int(time.time()) == 1000.0 def test_two(self, time_machine): assert int(time.time()) == 1000.0 time_machine.move_to(2000.0) assert int(time.time()) == 2000.0 time-machine-2.17.0/docs/usage.rst000066400000000000000000000243361504441626200167430ustar00rootroot00000000000000===== Usage ===== This document covers time-machine’s API. .. warning:: Time is a global state. When mocking it, all concurrent threads or asynchronous functions are also affected. Some aren't ready for time to move so rapidly or backwards, and may crash or produce unexpected results. Also beware that other processes are not affected. For example, if you call datetime functions on a database server, they will return the real time. Main API ======== ``travel(destination, *, tick=True)`` ------------------------------------- ``travel()`` is a class that allows time travel, to the datetime specified by ``destination``. It does so by mocking all functions from Python's standard library that return the current date or datetime. It can be used independently, as a function decorator, or as a context manager. ``destination`` specifies the datetime to move to. It may be: * A ``datetime.datetime``. If it is naive, it will be assumed to have the UTC timezone. If it has ``tzinfo`` set to a |zoneinfo-instance|_, the current timezone will also be mocked. * A ``datetime.date``. This will be converted to a UTC datetime with the time 00:00:00. * A ``datetime.timedelta``. This will be interpreted relative to the current time. If already within a ``travel()`` block, the ``shift()`` method is easier to use (documented below). * A ``float`` or ``int`` specifying a `Unix timestamp `__ * A string, which will be parsed with `dateutil.parse `__ and converted to a timestamp. If the result is naive, it will be assumed to be local time. .. |zoneinfo-instance| replace:: ``zoneinfo.ZoneInfo`` instance .. _zoneinfo-instance: https://docs.python.org/3/library/zoneinfo.html#zoneinfo.ZoneInfo Additionally, you can provide some more complex types: * A generator, in which case ``next()`` will be called on it, with the result treated as above. * A callable, in which case it will be called with no parameters, with the result treated as above. ``tick`` defines whether time continues to "tick" after travelling, or is frozen. If ``True``, the default, successive calls to mocked functions return values increasing by the elapsed real time *since the first call.* So after starting travel to ``0.0`` (the UNIX epoch), the first call to any datetime function will return its representation of ``1970-01-01 00:00:00.000000`` exactly. The following calls "tick," so if a call was made exactly half a second later, it would return ``1970-01-01 00:00:00.500000``. Mocked Functions ^^^^^^^^^^^^^^^^ All datetime functions in the standard library are mocked to move to the destination current datetime: * ``datetime.datetime.now()`` * ``datetime.datetime.utcnow()`` * ``time.clock_gettime()`` (only for ``CLOCK_REALTIME``) * ``time.clock_gettime_ns()`` (only for ``CLOCK_REALTIME``) * ``time.gmtime()`` * ``time.localtime()`` * ``time.monotonic()`` (not a real monotonic clock, returns ``time.time()``) * ``time.monotonic_ns()`` (not a real monotonic clock, returns ``time.time_ns()``) * ``time.strftime()`` * ``time.time()`` * ``time.time_ns()`` The mocking is done at the C layer, replacing the function pointers for these built-ins. Therefore, it automatically affects everywhere those functions have been imported, unlike use of ``unittest.mock.patch()``. Usage with ``start()`` / ``stop()`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ To use independently, create an instance, use ``start()`` to move to the destination time, and ``stop()`` to move back. For example: .. code-block:: python import datetime as dt import time_machine traveller = time_machine.travel(dt.datetime(1985, 10, 26)) traveller.start() # It's the past! assert dt.date.today() == dt.date(1985, 10, 26) traveller.stop() # We've gone back to the future! assert dt.date.today() > dt.date(2020, 4, 29) ``travel()`` instances are nestable, but you'll need to be careful when manually managing to call their ``stop()`` methods in the correct order, even when exceptions occur. It's recommended to use the decorator or context manager forms instead, to take advantage of Python features to do this. Function Decorator ^^^^^^^^^^^^^^^^^^ When used as a function decorator, time is mocked during the wrapped function's duration: .. code-block:: python import time import time_machine @time_machine.travel("1970-01-01 00:00 +0000") def test_in_the_deep_past(): assert 0.0 < time.time() < 1.0 You can also decorate asynchronous functions (coroutines): .. code-block:: python import time import time_machine @time_machine.travel("1970-01-01 00:00 +0000") async def test_in_the_deep_past(): assert 0.0 < time.time() < 1.0 Beware: time is a *global* state - `see below <#caveats>`__. Context Manager ^^^^^^^^^^^^^^^ When used as a context manager, time is mocked during the ``with`` block: .. code-block:: python import time import time_machine def test_in_the_deep_past(): with time_machine.travel(0.0): assert 0.0 < time.time() < 1.0 Class Decorator ^^^^^^^^^^^^^^^ Only ``unittest.TestCase`` subclasses are supported. When applied as a class decorator to such classes, time is mocked from the start of ``setUpClass()`` to the end of ``tearDownClass()``: .. code-block:: python import time import time_machine import unittest @time_machine.travel(0.0) class DeepPastTests(TestCase): def test_in_the_deep_past(self): assert 0.0 < time.time() < 1.0 Note this is different to ``unittest.mock.patch()``\'s behaviour, which is to mock only during the test methods. For pytest-style test classes, see the pattern `documented below <#pytest-plugin>`__. Timezone mocking ^^^^^^^^^^^^^^^^ If the ``destination`` passed to ``time_machine.travel()`` or ``Coordinates.move_to()`` has its ``tzinfo`` set to a |zoneinfo-instance2|_, the current timezone will be mocked. This will be done by calling |time-tzset|_, so it is only available on Unix. .. |zoneinfo-instance2| replace:: ``zoneinfo.ZoneInfo`` instance .. _zoneinfo-instance2: https://docs.python.org/3/library/zoneinfo.html#zoneinfo.ZoneInfo .. |time-tzset| replace:: ``time.tzset()`` .. _time-tzset: https://docs.python.org/3/library/time.html#time.tzset ``time.tzset()`` changes the ``time`` module’s `timezone constants `__ and features that rely on those, such as ``time.localtime()``. It won’t affect other concepts of “the current timezone”, such as Django’s (which can be changed with its |timezone-override|_). .. |timezone-override| replace:: ``timezone.override()`` .. _timezone-override: https://docs.djangoproject.com/en/stable/ref/utils/#django.utils.timezone.override Here’s a worked example changing the current timezone: .. code-block:: python import datetime as dt import time from zoneinfo import ZoneInfo import time_machine hill_valley_tz = ZoneInfo("America/Los_Angeles") @time_machine.travel(dt.datetime(2015, 10, 21, 16, 29, tzinfo=hill_valley_tz)) def test_hoverboard_era(): assert time.tzname == ("PST", "PDT") now = dt.datetime.now() assert (now.hour, now.minute) == (16, 29) ``Coordinates`` --------------- The ``start()`` method and entry of the context manager both return a ``Coordinates`` object that corresponds to the given "trip" in time. This has a couple methods that can be used to travel to other times. ``move_to(destination, tick=None)`` ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``move_to()`` moves the current time to a new destination. ``destination`` may be any of the types supported by ``travel``. ``tick`` may be set to a boolean, to change the ``tick`` flag of ``travel``. For example: .. code-block:: python import datetime as dt import time import time_machine with time_machine.travel(0, tick=False) as traveller: assert time.time() == 0 traveller.move_to(234) assert time.time() == 234 ``shift(delta)`` ^^^^^^^^^^^^^^^^ ``shift()`` takes one argument, ``delta``, which moves the current time by the given offset. ``delta`` may be a ``timedelta`` or a number of seconds, which will be added to destination. It may be negative, in which case time will move to an earlier point. For example: .. code-block:: python import datetime as dt import time import time_machine with time_machine.travel(0, tick=False) as traveller: assert time.time() == 0 traveller.shift(dt.timedelta(seconds=100)) assert time.time() == 100 traveller.shift(-dt.timedelta(seconds=10)) assert time.time() == 90 Escape hatch API ================ ``escape_hatch`` ---------------- The ``escape_hatch`` object provides functions to bypass time-machine, calling the real datetime functions, without any mocking. It also provides a way to check if time-machine is currently time travelling. These capabilities are useful in rare circumstances. For example, if you need to authenticate with an external service during time travel, you may need the real value of ``datetime.now()``. The functions are: * ``escape_hatch.is_travelling() -> bool`` - returns ``True`` if ``time_machine.travel()`` is active, ``False`` otherwise. * ``escape_hatch.datetime.datetime.now()`` - wraps the real ``datetime.datetime.now()``. * ``escape_hatch.datetime.datetime.utcnow()`` - wraps the real ``datetime.datetime.utcnow()``. * ``escape_hatch.time.clock_gettime()`` - wraps the real ``time.clock_gettime()``. * ``escape_hatch.time.clock_gettime_ns()`` - wraps the real ``time.clock_gettime_ns()``. * ``escape_hatch.time.gmtime()`` - wraps the real ``time.gmtime()``. * ``escape_hatch.time.localtime()`` - wraps the real ``time.localtime()``. * ``escape_hatch.time.strftime()`` - wraps the real ``time.strftime()``. * ``escape_hatch.time.time()`` - wraps the real ``time.time()``. * ``escape_hatch.time.time_ns()`` - wraps the real ``time.time_ns()``. For example: .. code-block:: python import time_machine with time_machine.travel(...): if time_machine.escape_hatch.is_travelling(): print("We need to go back to the future!") real_now = time_machine.escape_hatch.datetime.datetime.now() external_authenticate(now=real_now) time-machine-2.17.0/pyproject.toml000066400000000000000000000065631504441626200170730ustar00rootroot00000000000000[build-system] build-backend = "setuptools.build_meta" requires = [ "setuptools>=77", ] [project] name = "time-machine" version = "2.17.0" description = "Travel through time in your tests." readme = "README.rst" keywords = [ "date", "datetime", "mock", "test", "testing", "tests", "time", "warp", ] license = "MIT" license-files = [ "LICENSE" ] authors = [ { name = "Adam Johnson", email = "me@adamj.eu" }, ] requires-python = ">=3.9" classifiers = [ "Development Status :: 5 - Production/Stable", "Framework :: Pytest", "Intended Audience :: Developers", "Natural Language :: English", "Operating System :: OS Independent", "Programming Language :: Python :: 3 :: Only", "Programming Language :: Python :: 3.9", "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", "Typing :: Typed", ] dependencies = [ "python-dateutil", ] optional-dependencies.cli = [ "tokenize-rt", ] urls.Changelog = "https://time-machine.readthedocs.io/en/latest/changelog.html" urls.Documentation = "https://time-machine.readthedocs.io/" urls.Funding = "https://adamj.eu/books/" urls.Repository = "https://github.com/adamchainz/time-machine" entry-points.pytest11.time_machine = "time_machine" [dependency-groups] test = [ "backports-zoneinfo; python_version<'3.9'", "coverage[toml]", "pytest", "pytest-randomly", "python-dateutil", ] docs = [ "furo>=2024.8.6", "sphinx>=7.4.7", "sphinx-build-compatibility", "sphinx-copybutton>=0.5.2", ] [tool.cibuildwheel] build = [ "cp314-*", "cp314t-*", "cp313-*", "cp313t-*", "cp312-*", "cp311-*", "cp310-*", "cp39-*", ] enable = [ # Enable free-threaded wheels on Python 3.13 (where it was experimental) "cpython-freethreading", ] linux.archs = [ "x86_64", "i686", "aarch64" ] macos.archs = [ "x86_64", "universal2" ] windows.archs = [ "AMD64", "x86", "ARM64" ] [tool.ruff] lint.select = [ # flake8-bugbear "B", # flake8-comprehensions "C4", # pycodestyle "E", # Pyflakes errors "F", # isort "I", # flake8-simplify "SIM", # flake8-tidy-imports "TID", # pyupgrade "UP", # Pyflakes warnings "W", ] lint.ignore = [ # flake8-bugbear opinionated rules "B9", # line-too-long "E501", # suppressible-exception "SIM105", # if-else-block-instead-of-if-exp "SIM108", ] lint.extend-safe-fixes = [ # non-pep585-annotation "UP006", ] lint.isort.required-imports = [ "from __future__ import annotations" ] [tool.pyproject-fmt] max_supported_python = "3.14" [tool.pytest.ini_options] addopts = """\ --strict-config --strict-markers """ xfail_strict = true [tool.coverage.run] branch = true parallel = true source = [ "time_machine", "tests", ] [tool.coverage.paths] source = [ "src", ".tox/**/site-packages", ] [tool.coverage.report] show_missing = true [tool.mypy] enable_error_code = [ "ignore-without-code", "redundant-expr", "truthy-bool", ] mypy_path = "src/" namespace_packages = false strict = true warn_unreachable = true [[tool.mypy.overrides]] module = "tests.*" allow_untyped_defs = true [tool.rstcheck] report_level = "ERROR" [tool.uv.sources] sphinx-build-compatibility = { git = "https://github.com/readthedocs/sphinx-build-compatibility", rev = "4f304bd4562cdc96316f4fec82b264ca379d23e0" } time-machine-2.17.0/setup.py000066400000000000000000000005651504441626200156650ustar00rootroot00000000000000from __future__ import annotations import sys from setuptools import Extension, setup if hasattr(sys, "pypy_version_info"): raise RuntimeError( "PyPy is not currently supported by time-machine, see " "https://github.com/adamchainz/time-machine/issues/305" ) setup(ext_modules=[Extension(name="_time_machine", sources=["src/_time_machine.c"])]) time-machine-2.17.0/src/000077500000000000000000000000001504441626200147345ustar00rootroot00000000000000time-machine-2.17.0/src/_time_machine.c000066400000000000000000000411211504441626200176600ustar00rootroot00000000000000#include "Python.h" #include #include // Module state typedef struct { #if PY_VERSION_HEX >= 0x030d00a4 PyCFunctionFastWithKeywords original_now; #else _PyCFunctionFastWithKeywords original_now; #endif PyCFunction original_utcnow; PyCFunction original_clock_gettime; PyCFunction original_clock_gettime_ns; PyCFunction original_gmtime; PyCFunction original_localtime; PyCFunction original_monotonic; PyCFunction original_monotonic_ns; PyCFunction original_strftime; PyCFunction original_time; PyCFunction original_time_ns; } _time_machine_state; static inline _time_machine_state* get_time_machine_state(PyObject *module) { void *state = PyModule_GetState(module); assert(state != NULL); return (_time_machine_state *)state; } /* datetime.datetime.now() */ static PyObject* _time_machine_now(PyTypeObject *type, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { PyObject *result = NULL; PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_now = PyObject_GetAttrString(time_machine_module, "now"); result = _PyObject_Vectorcall(time_machine_now, args, nargs, kwnames); Py_DECREF(time_machine_now); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_now(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { _time_machine_state *state = get_time_machine_state(module); PyObject *datetime_module = PyImport_ImportModule("datetime"); PyObject *datetime_class = PyObject_GetAttrString(datetime_module, "datetime"); PyObject* result = state->original_now(datetime_class, args, nargs, kwnames); Py_DECREF(datetime_class); Py_DECREF(datetime_module); return result; } PyDoc_STRVAR(original_now_doc, "original_now() -> datetime\n\ \n\ Call datetime.datetime.now() after patching."); /* datetime.datetime.utcnow() */ static PyObject* _time_machine_utcnow(PyObject *cls, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_utcnow = PyObject_GetAttrString(time_machine_module, "utcnow"); PyObject* result = PyObject_CallObject(time_machine_utcnow, args); Py_DECREF(time_machine_utcnow); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_utcnow(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *datetime_module = PyImport_ImportModule("datetime"); PyObject *datetime_class = PyObject_GetAttrString(datetime_module, "datetime"); PyObject* result = state->original_utcnow(datetime_class, args); Py_DECREF(datetime_class); Py_DECREF(datetime_module); return result; } PyDoc_STRVAR(original_utcnow_doc, "original_utcnow() -> datetime\n\ \n\ Call datetime.datetime.utcnow() after patching."); /* time.clock_gettime() */ static PyObject* _time_machine_clock_gettime(PyObject *self, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_clock_gettime = PyObject_GetAttrString(time_machine_module, "clock_gettime"); #if PY_VERSION_HEX >= 0x030d00a2 PyObject* result = PyObject_CallOneArg(time_machine_clock_gettime, args); #else PyObject* result = PyObject_CallObject(time_machine_clock_gettime, args); #endif Py_DECREF(time_machine_clock_gettime); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_clock_gettime(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_clock_gettime(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_clock_gettime_doc, "original_clock_gettime() -> floating point number\n\ \n\ Call time.clock_gettime() after patching."); /* time.clock_gettime_ns() */ static PyObject* _time_machine_clock_gettime_ns(PyObject *self, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_clock_gettime_ns = PyObject_GetAttrString(time_machine_module, "clock_gettime_ns"); #if PY_VERSION_HEX >= 0x030d00a2 PyObject* result = PyObject_CallOneArg(time_machine_clock_gettime_ns, args); #else PyObject* result = PyObject_CallObject(time_machine_clock_gettime_ns, args); #endif Py_DECREF(time_machine_clock_gettime_ns); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_clock_gettime_ns(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_clock_gettime_ns(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_clock_gettime_ns_doc, "original_clock_gettime_ns() -> int\n\ \n\ Call time.clock_gettime_ns() after patching."); /* time.gmtime() */ static PyObject* _time_machine_gmtime(PyObject *self, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_gmtime = PyObject_GetAttrString(time_machine_module, "gmtime"); PyObject* result = PyObject_CallObject(time_machine_gmtime, args); Py_DECREF(time_machine_gmtime); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_gmtime(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_gmtime(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_gmtime_doc, "original_gmtime() -> floating point number\n\ \n\ Call time.gmtime() after patching."); /* time.localtime() */ static PyObject* _time_machine_localtime(PyObject *self, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_localtime = PyObject_GetAttrString(time_machine_module, "localtime"); PyObject* result = PyObject_CallObject(time_machine_localtime, args); Py_DECREF(time_machine_localtime); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_localtime(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_localtime(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_localtime_doc, "original_localtime() -> floating point number\n\ \n\ Call time.localtime() after patching."); /* time.monotonic() */ static PyObject* _time_machine_original_monotonic(PyObject* module, PyObject* args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_monotonic(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_monotonic_doc, "original_monotonic() -> floating point number\n\ \n\ Call time.monotonic() after patching."); /* time.monotonic_ns() */ static PyObject* _time_machine_original_monotonic_ns(PyObject* module, PyObject* args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_monotonic_ns(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_monotonic_ns_doc, "original_monotonic_ns() -> int\n\ \n\ Call time.monotonic_ns() after patching."); /* time.strftime() */ static PyObject* _time_machine_strftime(PyObject *self, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_strftime = PyObject_GetAttrString(time_machine_module, "strftime"); PyObject* result = PyObject_CallObject(time_machine_strftime, args); Py_DECREF(time_machine_strftime); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_strftime(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_strftime(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_strftime_doc, "original_strftime() -> floating point number\n\ \n\ Call time.strftime() after patching."); /* time.time() */ static PyObject* _time_machine_time(PyObject *self, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_time = PyObject_GetAttrString(time_machine_module, "time"); PyObject* result = PyObject_CallObject(time_machine_time, args); Py_DECREF(time_machine_time); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_time(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_time(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_time_doc, "original_time() -> floating point number\n\ \n\ Call time.time() after patching."); /* time.time_ns() */ static PyObject* _time_machine_time_ns(PyObject *self, PyObject *args) { PyObject *time_machine_module = PyImport_ImportModule("time_machine"); PyObject *time_machine_time_ns = PyObject_GetAttrString(time_machine_module, "time_ns"); PyObject* result = PyObject_CallObject(time_machine_time_ns, args); Py_DECREF(time_machine_time_ns); Py_DECREF(time_machine_module); return result; } static PyObject* _time_machine_original_time_ns(PyObject *module, PyObject *args) { _time_machine_state *state = get_time_machine_state(module); PyObject *time_module = PyImport_ImportModule("time"); PyObject* result = state->original_time_ns(time_module, args); Py_DECREF(time_module); return result; } PyDoc_STRVAR(original_time_ns_doc, "original_time_ns() -> int\n\ \n\ Call time.time_ns() after patching."); static PyObject* _time_machine_patch_if_needed(PyObject *module, PyObject *unused) { _time_machine_state *state = PyModule_GetState(module); if (state == NULL) { return NULL; } if (state->original_time) Py_RETURN_NONE; PyObject *datetime_module = PyImport_ImportModule("datetime"); PyObject *datetime_class = PyObject_GetAttrString(datetime_module, "datetime"); PyCFunctionObject *datetime_datetime_now = (PyCFunctionObject *) PyObject_GetAttrString(datetime_class, "now"); #if PY_VERSION_HEX >= 0x030d00a4 state->original_now = (PyCFunctionFastWithKeywords) datetime_datetime_now->m_ml->ml_meth; #else state->original_now = (_PyCFunctionFastWithKeywords) datetime_datetime_now->m_ml->ml_meth; #endif datetime_datetime_now->m_ml->ml_meth = (PyCFunction) _time_machine_now; Py_DECREF(datetime_datetime_now); PyCFunctionObject *datetime_datetime_utcnow = (PyCFunctionObject *) PyObject_GetAttrString(datetime_class, "utcnow"); state->original_utcnow = datetime_datetime_utcnow->m_ml->ml_meth; datetime_datetime_utcnow->m_ml->ml_meth = _time_machine_utcnow; Py_DECREF(datetime_datetime_utcnow); Py_DECREF(datetime_class); Py_DECREF(datetime_module); PyObject *time_module = PyImport_ImportModule("time"); /* time.clock_gettime(), only available on Unix platforms. */ PyCFunctionObject *time_clock_gettime = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "clock_gettime"); if (time_clock_gettime == NULL) { PyErr_Clear(); } else { state->original_clock_gettime = time_clock_gettime->m_ml->ml_meth; time_clock_gettime->m_ml->ml_meth = _time_machine_clock_gettime; Py_DECREF(time_clock_gettime); } /* time.clock_gettime_ns(), only available on Unix platforms. */ PyCFunctionObject *time_clock_gettime_ns = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "clock_gettime_ns"); if (time_clock_gettime_ns == NULL) { PyErr_Clear(); } else { state->original_clock_gettime_ns = time_clock_gettime_ns->m_ml->ml_meth; time_clock_gettime_ns->m_ml->ml_meth = _time_machine_clock_gettime_ns; Py_DECREF(time_clock_gettime_ns); } PyCFunctionObject *time_gmtime = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "gmtime"); state->original_gmtime = time_gmtime->m_ml->ml_meth; time_gmtime->m_ml->ml_meth = _time_machine_gmtime; Py_DECREF(time_gmtime); PyCFunctionObject *time_localtime = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "localtime"); state->original_localtime = time_localtime->m_ml->ml_meth; time_localtime->m_ml->ml_meth = _time_machine_localtime; Py_DECREF(time_localtime); PyCFunctionObject *time_monotonic = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "monotonic"); state->original_monotonic = time_monotonic->m_ml->ml_meth; time_monotonic->m_ml->ml_meth = _time_machine_time; Py_DECREF(time_monotonic); PyCFunctionObject *time_monotonic_ns = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "monotonic_ns"); state->original_monotonic_ns = time_monotonic_ns->m_ml->ml_meth; time_monotonic_ns->m_ml->ml_meth = _time_machine_time_ns; Py_DECREF(time_monotonic_ns); PyCFunctionObject *time_strftime = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "strftime"); state->original_strftime = time_strftime->m_ml->ml_meth; time_strftime->m_ml->ml_meth = _time_machine_strftime; Py_DECREF(time_strftime); PyCFunctionObject *time_time = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "time"); state->original_time = time_time->m_ml->ml_meth; time_time->m_ml->ml_meth = _time_machine_time; Py_DECREF(time_time); PyCFunctionObject *time_time_ns = (PyCFunctionObject *) PyObject_GetAttrString(time_module, "time_ns"); state->original_time_ns = time_time_ns->m_ml->ml_meth; time_time_ns->m_ml->ml_meth = _time_machine_time_ns; Py_DECREF(time_time_ns); Py_DECREF(time_module); Py_RETURN_NONE; } PyDoc_STRVAR(patch_if_needed_doc, "patch_if_needed() -> None\n\ \n\ Swap in helpers."); PyDoc_STRVAR(module_doc, "_time_machine module"); static PyMethodDef module_functions[] = { {"original_now", (PyCFunction)_time_machine_original_now, METH_FASTCALL|METH_KEYWORDS, original_now_doc}, {"original_utcnow", (PyCFunction)_time_machine_original_utcnow, METH_NOARGS, original_utcnow_doc}, #if PY_VERSION_HEX >= 0x030d00a2 {"original_clock_gettime", (PyCFunction)_time_machine_original_clock_gettime, METH_O, original_clock_gettime_doc}, {"original_clock_gettime_ns", (PyCFunction)_time_machine_original_clock_gettime_ns, METH_O, original_clock_gettime_ns_doc}, #else {"original_clock_gettime", (PyCFunction)_time_machine_original_clock_gettime, METH_VARARGS, original_clock_gettime_doc}, {"original_clock_gettime_ns", (PyCFunction)_time_machine_original_clock_gettime_ns, METH_VARARGS, original_clock_gettime_ns_doc}, #endif {"original_gmtime", (PyCFunction)_time_machine_original_gmtime, METH_VARARGS, original_gmtime_doc}, {"original_localtime", (PyCFunction)_time_machine_original_localtime, METH_VARARGS, original_localtime_doc}, {"original_monotonic", (PyCFunction)_time_machine_original_monotonic, METH_NOARGS, original_monotonic_doc}, {"original_monotonic_ns", (PyCFunction)_time_machine_original_monotonic_ns, METH_NOARGS, original_monotonic_ns_doc}, {"original_strftime", (PyCFunction)_time_machine_original_strftime, METH_VARARGS, original_strftime_doc}, {"original_time", (PyCFunction)_time_machine_original_time, METH_NOARGS, original_time_doc}, {"original_time_ns", (PyCFunction)_time_machine_original_time_ns, METH_NOARGS, original_time_ns_doc}, {"patch_if_needed", (PyCFunction)_time_machine_patch_if_needed, METH_NOARGS, patch_if_needed_doc}, {NULL, NULL} /* sentinel */ }; static PyModuleDef_Slot _time_machine_slots[] = { {0, NULL} }; static struct PyModuleDef _time_machine_module = { PyModuleDef_HEAD_INIT, .m_name = "_time_machine", .m_doc = module_doc, .m_size = sizeof(_time_machine_state), .m_methods = module_functions, .m_slots = _time_machine_slots, .m_traverse = NULL, .m_clear = NULL, .m_free = NULL }; PyMODINIT_FUNC PyInit__time_machine(void) { return PyModuleDef_Init(&_time_machine_module); } time-machine-2.17.0/src/time_machine/000077500000000000000000000000001504441626200173565ustar00rootroot00000000000000time-machine-2.17.0/src/time_machine/__init__.py000066400000000000000000000355261504441626200215020ustar00rootroot00000000000000from __future__ import annotations import datetime as dt import functools import inspect import os import sys import time as time_module import uuid from collections.abc import Awaitable, Generator from collections.abc import Generator as TypingGenerator from time import gmtime as orig_gmtime from time import struct_time from types import TracebackType from typing import Any, Callable, TypeVar, Union, cast, overload from unittest import TestCase, mock from zoneinfo import ZoneInfo import _time_machine from dateutil.parser import parse as parse_datetime # time.clock_gettime and time.CLOCK_REALTIME not always available # e.g. on builds against old macOS = official Python.org installer try: from time import CLOCK_REALTIME except ImportError: # Dummy value that won't compare equal to any value CLOCK_REALTIME = sys.maxsize try: from time import tzset HAVE_TZSET = True except ImportError: # pragma: no cover # Windows HAVE_TZSET = False try: import pytest except ImportError: # pragma: no cover HAVE_PYTEST = False else: HAVE_PYTEST = True NANOSECONDS_PER_SECOND = 1_000_000_000 # Windows' time epoch is not unix epoch but in 1601. This constant helps us # translate to it. _system_epoch = orig_gmtime(0) SYSTEM_EPOCH_TIMESTAMP_NS = int( dt.datetime( _system_epoch.tm_year, _system_epoch.tm_mon, _system_epoch.tm_mday, _system_epoch.tm_hour, _system_epoch.tm_min, _system_epoch.tm_sec, tzinfo=dt.timezone.utc, ).timestamp() * NANOSECONDS_PER_SECOND ) DestinationBaseType = Union[ int, float, dt.datetime, dt.timedelta, dt.date, str, ] DestinationType = Union[ DestinationBaseType, Callable[[], DestinationBaseType], TypingGenerator[DestinationBaseType, None, None], ] _F = TypeVar("_F", bound=Callable[..., Any]) _AF = TypeVar("_AF", bound=Callable[..., Awaitable[Any]]) TestCaseType = TypeVar("TestCaseType", bound=type[TestCase]) # copied from typeshed: _TimeTuple = tuple[int, int, int, int, int, int, int, int, int] def extract_timestamp_tzname( destination: DestinationType, ) -> tuple[float, str | None]: dest: DestinationBaseType if isinstance(destination, Generator): dest = next(destination) elif callable(destination): dest = destination() else: dest = destination timestamp: float tzname: str | None = None if isinstance(dest, int): timestamp = float(dest) elif isinstance(dest, float): timestamp = dest elif isinstance(dest, dt.datetime): if isinstance(dest.tzinfo, ZoneInfo): tzname = dest.tzinfo.key if dest.tzinfo is None: dest = dest.replace(tzinfo=dt.timezone.utc) timestamp = dest.timestamp() elif isinstance(dest, dt.timedelta): timestamp = time_module.time() + dest.total_seconds() elif isinstance(dest, dt.date): timestamp = dt.datetime.combine( dest, dt.time(0, 0), tzinfo=dt.timezone.utc ).timestamp() elif isinstance(dest, str): timestamp = parse_datetime(dest).timestamp() else: raise TypeError(f"Unsupported destination {dest!r}") return timestamp, tzname class Coordinates: def __init__( self, destination_timestamp: float, destination_tzname: str | None, tick: bool, ) -> None: self._destination_timestamp_ns = int( destination_timestamp * NANOSECONDS_PER_SECOND ) self._destination_tzname = destination_tzname self._tick = tick self._requested = False def time(self) -> float: return self.time_ns() / NANOSECONDS_PER_SECOND def time_ns(self) -> int: if not self._tick: return self._destination_timestamp_ns base = SYSTEM_EPOCH_TIMESTAMP_NS + self._destination_timestamp_ns now_ns: int = _time_machine.original_time_ns() if not self._requested: self._requested = True self._real_start_timestamp_ns = now_ns return base return base + (now_ns - self._real_start_timestamp_ns) def shift(self, delta: dt.timedelta | int | float) -> None: if isinstance(delta, dt.timedelta): total_seconds = delta.total_seconds() elif isinstance(delta, (int, float)): total_seconds = delta else: raise TypeError(f"Unsupported type for delta argument: {delta!r}") self._destination_timestamp_ns += int(total_seconds * NANOSECONDS_PER_SECOND) def move_to( self, destination: DestinationType, tick: bool | None = None, ) -> None: self._stop() timestamp, self._destination_tzname = extract_timestamp_tzname(destination) self._destination_timestamp_ns = int(timestamp * NANOSECONDS_PER_SECOND) self._requested = False self._start() if tick is not None: self._tick = tick def _start(self) -> None: if HAVE_TZSET and self._destination_tzname is not None: self._orig_tz = os.environ.get("TZ") os.environ["TZ"] = self._destination_tzname tzset() def _stop(self) -> None: if HAVE_TZSET and self._destination_tzname is not None: if self._orig_tz is None: del os.environ["TZ"] else: os.environ["TZ"] = self._orig_tz tzset() coordinates_stack: list[Coordinates] = [] # During time travel, patch the uuid module's time-based generation function to # None, which makes it use time.time(). Otherwise it makes a system call to # find the current datetime. The time it finds is stored in generated UUID1 # values. uuid_generate_time_attr = "_generate_time_safe" uuid_generate_time_patcher = mock.patch.object(uuid, uuid_generate_time_attr, new=None) uuid_uuid_create_patcher = mock.patch.object(uuid, "_UuidCreate", new=None) class travel: def __init__(self, destination: DestinationType, *, tick: bool = True) -> None: self.destination_timestamp, self.destination_tzname = extract_timestamp_tzname( destination ) self.tick = tick def start(self) -> Coordinates: _time_machine.patch_if_needed() if not coordinates_stack: uuid_generate_time_patcher.start() uuid_uuid_create_patcher.start() coordinates = Coordinates( destination_timestamp=self.destination_timestamp, destination_tzname=self.destination_tzname, tick=self.tick, ) coordinates_stack.append(coordinates) coordinates._start() return coordinates def stop(self) -> None: coordinates_stack.pop()._stop() if not coordinates_stack: uuid_generate_time_patcher.stop() uuid_uuid_create_patcher.stop() def __enter__(self) -> Coordinates: return self.start() def __exit__( self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, ) -> None: self.stop() @overload def __call__(self, wrapped: TestCaseType) -> TestCaseType: # pragma: no cover ... @overload def __call__(self, wrapped: _AF) -> _AF: # pragma: no cover ... @overload def __call__(self, wrapped: _F) -> _F: # pragma: no cover ... # 'Any' below is workaround for Mypy error: # Overloaded function implementation does not accept all possible arguments # of signature def __call__( self, wrapped: TestCaseType | _AF | _F | Any ) -> TestCaseType | _AF | _F | Any: if isinstance(wrapped, type): # Class decorator if not issubclass(wrapped, TestCase): raise TypeError("Can only decorate unittest.TestCase subclasses.") # Modify the setUpClass method orig_setUpClass = wrapped.setUpClass.__func__ # type: ignore[attr-defined] @functools.wraps(orig_setUpClass) def setUpClass(cls: type[TestCase]) -> None: self.__enter__() try: orig_setUpClass(cls) except Exception: self.__exit__(*sys.exc_info()) raise wrapped.setUpClass = classmethod(setUpClass) # type: ignore[assignment] orig_tearDownClass = ( wrapped.tearDownClass.__func__ # type: ignore[attr-defined] ) @functools.wraps(orig_tearDownClass) def tearDownClass(cls: type[TestCase]) -> None: orig_tearDownClass(cls) self.__exit__(None, None, None) wrapped.tearDownClass = classmethod( # type: ignore[assignment] tearDownClass ) return cast(TestCaseType, wrapped) elif inspect.iscoroutinefunction(wrapped): @functools.wraps(wrapped) async def wrapper(*args: Any, **kwargs: Any) -> Any: with self: return await wrapped(*args, **kwargs) return cast(_AF, wrapper) else: assert callable(wrapped) @functools.wraps(wrapped) def wrapper(*args: Any, **kwargs: Any) -> Any: with self: return wrapped(*args, **kwargs) return cast(_F, wrapper) # datetime module def now(tz: dt.tzinfo | None = None) -> dt.datetime: if not coordinates_stack: result: dt.datetime = _time_machine.original_now(tz) return result return dt.datetime.fromtimestamp(time(), tz) def utcnow() -> dt.datetime: if not coordinates_stack: result: dt.datetime = _time_machine.original_utcnow() return result return dt.datetime.fromtimestamp(time(), dt.timezone.utc).replace(tzinfo=None) # time module def clock_gettime(clk_id: int) -> float: if not coordinates_stack or clk_id != CLOCK_REALTIME: result: float = _time_machine.original_clock_gettime(clk_id) return result return time() def clock_gettime_ns(clk_id: int) -> int: if not coordinates_stack or clk_id != CLOCK_REALTIME: result: int = _time_machine.original_clock_gettime_ns(clk_id) return result return time_ns() def gmtime(secs: float | None = None) -> struct_time: result: struct_time if not coordinates_stack or secs is not None: result = _time_machine.original_gmtime(secs) else: result = _time_machine.original_gmtime(coordinates_stack[-1].time()) return result def localtime(secs: float | None = None) -> struct_time: result: struct_time if not coordinates_stack or secs is not None: result = _time_machine.original_localtime(secs) else: result = _time_machine.original_localtime(coordinates_stack[-1].time()) return result def strftime(format: str, t: _TimeTuple | struct_time | None = None) -> str: result: str if t is not None: result = _time_machine.original_strftime(format, t) elif not coordinates_stack: result = _time_machine.original_strftime(format) else: result = _time_machine.original_strftime(format, localtime()) return result def time() -> float: if not coordinates_stack: result: float = _time_machine.original_time() return result return coordinates_stack[-1].time() def time_ns() -> int: if not coordinates_stack: result: int = _time_machine.original_time_ns() return result return coordinates_stack[-1].time_ns() # pytest plugin if HAVE_PYTEST: # pragma: no branch class TimeMachineFixture: traveller: travel | None coordinates: Coordinates | None def __init__(self) -> None: self.traveller = None self.coordinates = None def move_to( self, destination: DestinationType, tick: bool | None = None, ) -> None: if self.traveller is None: if tick is None: tick = True self.traveller = travel(destination, tick=tick) self.coordinates = self.traveller.start() else: assert self.coordinates is not None self.coordinates.move_to(destination, tick=tick) def shift(self, delta: dt.timedelta | int | float) -> None: if self.traveller is None: raise RuntimeError( "Initialize time_machine with move_to() before using shift()." ) assert self.coordinates is not None self.coordinates.shift(delta=delta) def stop(self) -> None: if self.traveller is not None: self.traveller.stop() @pytest.fixture(name="time_machine") def time_machine_fixture() -> TypingGenerator[TimeMachineFixture, None, None]: fixture = TimeMachineFixture() yield fixture fixture.stop() # escape hatch class _EscapeHatchDatetimeDatetime: def now(self, tz: dt.tzinfo | None = None) -> dt.datetime: result: dt.datetime = _time_machine.original_now(tz) return result def utcnow(self) -> dt.datetime: result: dt.datetime = _time_machine.original_utcnow() return result class _EscapeHatchDatetime: def __init__(self) -> None: self.datetime = _EscapeHatchDatetimeDatetime() class _EscapeHatchTime: def clock_gettime(self, clk_id: int) -> float: result: float = _time_machine.original_clock_gettime(clk_id) return result def clock_gettime_ns(self, clk_id: int) -> int: result: int = _time_machine.original_clock_gettime_ns(clk_id) return result def gmtime(self, secs: float | None = None) -> struct_time: result: struct_time = _time_machine.original_gmtime(secs) return result def localtime(self, secs: float | None = None) -> struct_time: result: struct_time = _time_machine.original_localtime(secs) return result def monotonic(self) -> float: result: float = _time_machine.original_monotonic() return result def monotonic_ns(self) -> int: result: int = _time_machine.original_monotonic_ns() return result def strftime(self, format: str, t: _TimeTuple | struct_time | None = None) -> str: result: str if t is not None: result = _time_machine.original_strftime(format, t) else: result = _time_machine.original_strftime(format) return result def time(self) -> float: result: float = _time_machine.original_time() return result def time_ns(self) -> int: result: int = _time_machine.original_time_ns() return result class _EscapeHatch: def __init__(self) -> None: self.datetime = _EscapeHatchDatetime() self.time = _EscapeHatchTime() def is_travelling(self) -> bool: return bool(coordinates_stack) escape_hatch = _EscapeHatch() time-machine-2.17.0/src/time_machine/__main__.py000066400000000000000000000002231504441626200214450ustar00rootroot00000000000000from __future__ import annotations from time_machine.cli import main if __name__ == "__main__": # pragma: no cover raise SystemExit(main()) time-machine-2.17.0/src/time_machine/cli.py000066400000000000000000000263271504441626200205110ustar00rootroot00000000000000from __future__ import annotations import argparse import ast import sys import warnings from collections import defaultdict from collections.abc import Callable, Mapping, Sequence from functools import partial from tokenize_rt import ( UNIMPORTANT_WS, Offset, Token, reversed_enumerate, src_to_tokens, tokens_to_src, ) CODE = "CODE" DEDENT = "DEDENT" def main(argv: Sequence[str] | None = None) -> int: """Main entry point for the migration tool.""" parser = argparse.ArgumentParser() subparsers = parser.add_subparsers( dest="command", help="Available commands", required=True ) migrate_parser = subparsers.add_parser( "migrate", help="Migrate Python files from freezegun to time-machine", ) migrate_parser.add_argument("file", nargs="+") args = parser.parse_args(argv) if args.command == "migrate": return migrate_files(files=args.file) else: # pragma: no cover # Unreachable raise NotImplementedError(f"Command {args.command} does not exist.") def migrate_files(files: list[str]) -> int: returncode = 0 for filename in files: returncode |= migrate_file(filename) return returncode def migrate_file(filename: str) -> int: if filename == "-": contents_bytes = sys.stdin.buffer.read() else: with open(filename, "rb") as fb: contents_bytes = fb.read() try: contents_text_orig = contents_text = contents_bytes.decode() except UnicodeDecodeError: print(f"{filename} is non-utf-8 (not supported)") return 1 contents_text = migrate_contents(contents_text) if filename == "-": print(contents_text, end="") elif contents_text != contents_text_orig: print(f"Rewriting {filename}", file=sys.stderr) with open(filename, "w", encoding="UTF-8", newline="") as f: f.write(contents_text) return contents_text != contents_text_orig def migrate_contents(contents_text: str) -> str: """Migrate a single text from freezegun to time-machine.""" try: ast_obj = ast_parse(contents_text) except SyntaxError: return contents_text callbacks = visit(ast_obj) if not callbacks: return contents_text tokens = src_to_tokens(contents_text) fixup_dedent_tokens(tokens) for i, token in reversed_enumerate(tokens): if not token.src: continue # though this is a defaultdict, by using `.get()` this function's # self time is almost 50% faster for callback in callbacks.get(token.offset, ()): callback(tokens, i) # no types for tokenize-rt return tokens_to_src(tokens) # type: ignore [no-any-return] def ast_parse(contents_text: str) -> ast.Module: # intentionally ignore warnings, we can't do anything about them with warnings.catch_warnings(): warnings.simplefilter("ignore") return ast.parse(contents_text.encode()) def fixup_dedent_tokens(tokens: list[Token]) -> None: # pragma: no cover """For whatever reason the DEDENT / UNIMPORTANT_WS tokens are misordered | if True: | if True: | pass | else: |^ ^- DEDENT |+----UNIMPORTANT_WS """ for i, token in enumerate(tokens): if token.name == UNIMPORTANT_WS and tokens[i + 1].name == DEDENT: tokens[i], tokens[i + 1] = tokens[i + 1], tokens[i] TokenFunc = Callable[[list[Token], int], None] def visit(tree: ast.Module) -> Mapping[Offset, list[TokenFunc]]: """ Visit the AST and return a list of callbacks to apply to the tokens. This is a placeholder function; actual implementation would depend on the specific migration logic. """ ret = defaultdict(list) freezegun_import_seen = False freeze_time_import_seen = False for node in ast.walk(tree): # On Python 3.10+, this would look a lot better with the match statement if isinstance(node, ast.Import): if ( len(node.names) == 1 and (alias := node.names[0]).name == "freezegun" and alias.asname is None ): freezegun_import_seen = True ret[ast_start_offset(node)].append(replace_import) elif isinstance(node, ast.ImportFrom): if ( node.module == "freezegun" and len(node.names) == 1 and (alias := node.names[0]).name == "freeze_time" and alias.asname is None ): freeze_time_import_seen = True ret[ast_start_offset(node)].append( partial(replace_import_from, node=node) ) elif isinstance(node, ast.FunctionDef): for decorator in node.decorator_list: if ( isinstance(decorator, ast.Call) and migratable_call(decorator) and ( ( freezegun_import_seen and isinstance(decorator.func, ast.Attribute) and decorator.func.attr == "freeze_time" and isinstance(decorator.func.value, ast.Name) and decorator.func.value.id == "freezegun" ) or ( freeze_time_import_seen and isinstance(decorator.func, ast.Name) and decorator.func.id == "freeze_time" ) ) ): ret[ast_start_offset(decorator.func)].append( partial(switch_to_travel, node=decorator.func) ) ret[ast_start_offset(decorator)].append( partial(add_tick_false, node=decorator) ) elif isinstance(node, ast.ClassDef): if node.decorator_list and looks_like_unittest_class(node): for decorator in node.decorator_list: if ( isinstance(decorator, ast.Call) and migratable_call(decorator) and ( ( freezegun_import_seen and isinstance(decorator.func, ast.Attribute) and decorator.func.attr == "freeze_time" and isinstance(decorator.func.value, ast.Name) and decorator.func.value.id == "freezegun" ) or ( freeze_time_import_seen and isinstance(decorator.func, ast.Name) and decorator.func.id == "freeze_time" ) ) ): ret[ast_start_offset(decorator.func)].append( partial(switch_to_travel, node=decorator.func) ) ret[ast_start_offset(decorator)].append( partial(add_tick_false, node=decorator) ) elif isinstance(node, ast.With): for item in node.items: context_expr = item.context_expr if ( isinstance(context_expr, ast.Call) and migratable_call(context_expr) and item.optional_vars is None and ( ( freezegun_import_seen and isinstance(context_expr.func, ast.Attribute) and context_expr.func.attr == "freeze_time" and isinstance(context_expr.func.value, ast.Name) and context_expr.func.value.id == "freezegun" ) or ( freeze_time_import_seen and isinstance(context_expr.func, ast.Name) and context_expr.func.id == "freeze_time" ) ) ): ret[ast_start_offset(context_expr.func)].append( partial(switch_to_travel, node=context_expr.func) ) ret[ast_start_offset(context_expr)].append( partial(add_tick_false, node=context_expr) ) return ret # type: ignore [return-value] def migratable_call(node: ast.Call) -> bool: return ( len(node.args) == 1 # We could allow tick being set, as long as we didn't then add it and len(node.keywords) == 0 ) def looks_like_unittest_class(node: ast.ClassDef) -> bool: """ Heuristically determine if a class is a unittest.TestCase subclass. """ for base in node.bases: if ( isinstance(base, ast.Name) and base.id.endswith("TestCase") or ( isinstance(base, ast.Attribute) and isinstance(base.value, ast.Name) and base.value.id == "unittest" and base.attr.endswith("TestCase") ) ): return True for subnode in node.body: if isinstance(subnode, ast.FunctionDef) and subnode.name in ( "setUp", "setUpClass", "tearDown", "tearDownClass", "setUpTestData", ): return True if isinstance(subnode, ast.AsyncFunctionDef) and subnode.name in ( "asyncSetUp", "asyncTearDown", ): return True return False def ast_start_offset(node: ast.alias | ast.expr | ast.keyword | ast.stmt) -> Offset: return Offset(node.lineno, node.col_offset) def replace_import(tokens: list[Token], i: int) -> None: while True: if tokens[i].name == "NAME" and tokens[i].src == "freezegun": break i += 1 tokens[i] = Token(name="NAME", src="time_machine") def replace_import_from(tokens: list[Token], i: int, node: ast.ImportFrom) -> None: j = find_last_token(tokens, i, node=node) tokens[i : j + 1] = [Token(name=CODE, src="import time_machine")] def switch_to_travel( tokens: list[Token], i: int, node: ast.Attribute | ast.Name ) -> None: j = find_last_token(tokens, i, node=node) tokens[i : j + 1] = [Token(name=CODE, src="time_machine.travel")] def add_tick_false(tokens: list[Token], i: int, node: ast.Call) -> None: """ Add `tick=False` to the function call. """ j = find_last_token(tokens, i, node=node) tokens.insert(j, Token(name=CODE, src=", tick=False")) # Token functions def find_last_token( tokens: list[Token], i: int, *, node: ast.expr | ast.keyword | ast.stmt ) -> int: """ Find the last token corresponding to the given ast node. """ while ( tokens[i].line is None or tokens[i].line < node.end_lineno ): # pragma: no cover i += 1 while ( tokens[i].utf8_byte_offset is None or tokens[i].utf8_byte_offset < node.end_col_offset ): i += 1 return i - 1 time-machine-2.17.0/src/time_machine/py.typed000066400000000000000000000000001504441626200210430ustar00rootroot00000000000000time-machine-2.17.0/tests/000077500000000000000000000000001504441626200153075ustar00rootroot00000000000000time-machine-2.17.0/tests/__init__.py000066400000000000000000000000001504441626200174060ustar00rootroot00000000000000time-machine-2.17.0/tests/conftest.py000066400000000000000000000002241504441626200175040ustar00rootroot00000000000000from __future__ import annotations import os import time # Isolate tests from the host machine’s timezone os.environ["TZ"] = "UTC" time.tzset() time-machine-2.17.0/tests/test_cli.py000066400000000000000000000421231504441626200174710ustar00rootroot00000000000000from __future__ import annotations import io import subprocess import sys from textwrap import dedent from unittest import mock import pytest # import __main__ for coverage from time_machine import __main__ # noqa: F401 from time_machine.cli import main, migrate_contents class TestMain: def test_no_subcommand(self, capsys): with pytest.raises(SystemExit) as excinfo: main([]) assert excinfo.value.code == 2 out, err = capsys.readouterr() if sys.version_info >= (3, 14): assert err == ( "usage: python -m pytest [-h] {migrate} ...\n" + "python -m pytest: error: the following arguments are required: command\n" ) else: assert err == ( "usage: __main__.py [-h] {migrate} ...\n" + "__main__.py: error: the following arguments are required: command\n" ) assert out == "" def test_main_help( self, ): with pytest.raises(SystemExit) as excinfo: main(["--help"]) assert excinfo.value.code == 0 def test_main_help_subprocess( self, ): proc = subprocess.run( [sys.executable, "-m", "time_machine", "--help"], check=True, capture_output=True, ) if sys.version_info >= (3, 14): assert proc.stdout.startswith(b"usage: python -m time_machine ") else: assert proc.stdout.startswith(b"usage: __main__.py ") def test_migrate_help_command(self, capsys): with pytest.raises(SystemExit) as excinfo: main(["migrate", "--help"]) assert excinfo.value.code == 0 def test_migrate_no_files(self, capsys): with pytest.raises(SystemExit) as excinfo: main(["migrate"]) assert excinfo.value.code == 2 def test_migrate_empty(self, capsys, tmp_path): path = tmp_path / "example.py" path.write_text("\n") result = main(["migrate", str(path)]) assert result == 0 out, err = capsys.readouterr() assert out == "" assert err == "" assert path.read_text() == "\n" def test_migrate_syntax_error(self, capsys, tmp_path): path = tmp_path / "example.py" path.write_text("def def def\n") result = main(["migrate", str(path)]) assert result == 0 out, err = capsys.readouterr() assert out == "" assert err == "" assert path.read_text() == "def def def\n" def test_migrate_non_utf8(self, capsys, tmp_path): path = tmp_path / "example.py" path.write_bytes("# -*- coding: cp1252 -*-\nx = €\n".encode("cp1252")) result = main(["migrate", str(path)]) assert result == 1 out, err = capsys.readouterr() assert out == f"{path} is non-utf-8 (not supported)\n" assert err == "" def test_migrate_stdin_empty(self, capsys): stdin = io.TextIOWrapper(io.BytesIO(b""), "UTF-8") with mock.patch.object(sys, "stdin", stdin): result = main(["migrate", "-"]) assert result == 0 out, err = capsys.readouterr() assert out == "" assert err == "" def test_migrate_import(self, capsys, tmp_path): path = tmp_path / "example.py" path.write_text("import freezegun\n") result = main(["migrate", str(path)]) assert result == 1 out, err = capsys.readouterr() assert out == "" assert err == f"Rewriting {path}\n" assert path.read_text() == "import time_machine\n" def test_migrate_stdin_import(self, capsys): stdin = io.TextIOWrapper(io.BytesIO(b"import freezegun\n"), "UTF-8") with mock.patch.object(sys, "stdin", stdin): result = main(["migrate", "-"]) assert result == 1 out, err = capsys.readouterr() assert out == "import time_machine\n" assert err == "" def check_noop(given: str) -> None: given = dedent(given) result = migrate_contents(given) assert result == given def check_transformed(given: str, expected: str) -> None: given = dedent(given) expected = dedent(expected) result = migrate_contents(given) assert result == expected class TestMigrateContents: def test_import_unrelated(self): check_noop( "import libfaketime", ) def test_aliased(self): check_noop( "import freezegun as fg", ) def test_import_freezegun(self): check_transformed( "import freezegun", "import time_machine", ) def test_import_from_unrelated(self): check_noop( "from libfaketime import freeze_time", ) def test_import_from_freezegun_aliased(self): check_noop( "from freezegun import freeze_time as ft", ) def test_import_from_freezegun_multiple(self): check_noop( "from freezegun import freeze_time, FakeDate", ) def test_import_from_freezegun(self): check_transformed( "from freezegun import freeze_time", "import time_machine", ) def test_import_from_freezegun_more(self): check_transformed( """ from freezegun import freeze_time pass """, """ import time_machine pass """, ) def test_function_decorator_attr_unrelated(self): check_noop( """ import libfaketime @libfaketime.freeze_time("2023-01-01") def test_function(): pass """, ) def test_function_decorator_attr_not_called(self): check_transformed( """ import freezegun @freezegun.freeze_time def test_function(): pass """, """ import time_machine @freezegun.freeze_time def test_function(): pass """, ) def test_function_decorator_attr(self): check_transformed( """ import freezegun @freezegun.freeze_time("2023-01-01") def test_function(): pass """, """ import time_machine @time_machine.travel("2023-01-01", tick=False) def test_function(): pass """, ) def test_function_decorator_name_unrelated(self): check_noop( """ from libfaketime import freeze_time @freeze_time("2023-01-01") def test_function(): pass """, ) def test_function_decorator_name_not_called(self): check_transformed( """ from freezegun import freeze_time @freeze_time def test_function(): pass """, """ import time_machine @freeze_time def test_function(): pass """, ) def test_function_decorator_name(self): check_transformed( """ from freezegun import freeze_time @freeze_time("2023-01-01") def test_function(): pass """, """ import time_machine @time_machine.travel("2023-01-01", tick=False) def test_function(): pass """, ) def test_class_decorator_attr_unrelated(self): check_noop( """ import libfaketime @libfaketime.freeze_time("2023-01-01") class TestClass: pass """, ) def test_class_decorator_attr_not_called(self): check_transformed( """ import freezegun @freezegun.freeze_time class TestClass: pass """, """ import time_machine @freezegun.freeze_time class TestClass: pass """, ) def test_class_decorator_attr_not_unittest_class(self): check_transformed( """ import freezegun @freezegun.freeze_time("2023-01-01") class TestClass: pass """, """ import time_machine @freezegun.freeze_time("2023-01-01") class TestClass: pass """, ) def test_class_decorator_attr_unittest_class_base_name(self): check_transformed( """ import freezegun from django.test import SimpleTestCase @freezegun.freeze_time("2023-01-01") class TestClass(SimpleTestCase): pass """, """ import time_machine from django.test import SimpleTestCase @time_machine.travel("2023-01-01", tick=False) class TestClass(SimpleTestCase): pass """, ) def test_class_decorator_attr_unittest_class_base_attr(self): check_transformed( """ import freezegun import unittest @freezegun.freeze_time("2023-01-01") class TestClass(unittest.TestCase): pass """, """ import time_machine import unittest @time_machine.travel("2023-01-01", tick=False) class TestClass(unittest.TestCase): pass """, ) def test_class_decorator_attr_unittest_class_method(self): check_transformed( """ import freezegun from testing import TestBase @freezegun.freeze_time("2023-01-01") class TestClass(TestBase): def setUp(self): print("I look like a unittest class!") """, """ import time_machine from testing import TestBase @time_machine.travel("2023-01-01", tick=False) class TestClass(TestBase): def setUp(self): print("I look like a unittest class!") """, ) def test_class_decorator_attr_unittest_class_async_method(self): check_transformed( """ import freezegun from testing import TestBase @freezegun.freeze_time("2023-01-01") class TestClass(TestBase): async def asyncSetUp(self): print("I look like a unittest class!") """, """ import time_machine from testing import TestBase @time_machine.travel("2023-01-01", tick=False) class TestClass(TestBase): async def asyncSetUp(self): print("I look like a unittest class!") """, ) def test_class_decorator_attr_multiple(self): check_transformed( """ import freezegun from testing import TestBase from unittest import mock @freezegun.freeze_time("2023-01-01") @mock.patch("example.connect") class TestClass(TestBase): def setUp(self): print("I look like a unittest class!") """, """ import time_machine from testing import TestBase from unittest import mock @time_machine.travel("2023-01-01", tick=False) @mock.patch("example.connect") class TestClass(TestBase): def setUp(self): print("I look like a unittest class!") """, ) def test_class_decorator_name_unrelated(self): check_noop( """ from libfaketime import freeze_time @freeze_time("2023-01-01") class TestClass: pass """, ) def test_class_decorator_name_not_called(self): check_transformed( """ from freezegun import freeze_time @freeze_time class TestClass: pass """, """ import time_machine @freeze_time class TestClass: pass """, ) def test_class_decorator_name_not_unittest_class(self): check_transformed( """ from freezegun import freeze_time @freeze_time("2023-01-01") class TestClass: pass """, """ import time_machine @freeze_time("2023-01-01") class TestClass: pass """, ) def test_class_decorator_name_unittest_class_base_name(self): check_transformed( """ from freezegun import freeze_time from django.test import SimpleTestCase @freeze_time("2023-01-01") class TestClass(SimpleTestCase): pass """, """ import time_machine from django.test import SimpleTestCase @time_machine.travel("2023-01-01", tick=False) class TestClass(SimpleTestCase): pass """, ) def test_class_decorator_name_unittest_class_base_attr(self): check_transformed( """ from freezegun import freeze_time import unittest @freeze_time("2023-01-01") class TestClass(unittest.TestCase): pass """, """ import time_machine import unittest @time_machine.travel("2023-01-01", tick=False) class TestClass(unittest.TestCase): pass """, ) def test_class_decorator_name_unittest_class_method(self): check_transformed( """ from freezegun import freeze_time from testing import TestBase @freeze_time("2023-01-01") class TestClass(TestBase): def setUp(self): print("I look like a unittest class!") """, """ import time_machine from testing import TestBase @time_machine.travel("2023-01-01", tick=False) class TestClass(TestBase): def setUp(self): print("I look like a unittest class!") """, ) def test_with_attr_unrelated(self): check_noop( """ import libfaketime with libfaketime.freeze_time("2023-01-01"): pass """, ) def test_with_attr_not_called(self): check_transformed( """ import freezegun with freezegun.freeze_time: pass """, """ import time_machine with freezegun.freeze_time: pass """, ) def test_with_attr_as(self): check_transformed( """ import freezegun with freezegun.freeze_time("2023-01-01") as ft: pass """, """ import time_machine with freezegun.freeze_time("2023-01-01") as ft: pass """, ) def test_with_attr(self): check_transformed( """ import freezegun with freezegun.freeze_time("2023-01-01"): pass """, """ import time_machine with time_machine.travel("2023-01-01", tick=False): pass """, ) def test_with_name_unrelated(self): check_noop( """ from libfaketime import freeze_time with freeze_time("2023-01-01"): pass """, ) def test_with_name_not_called(self): check_transformed( """ from freezegun import freeze_time with freeze_time: pass """, """ import time_machine with freeze_time: pass """, ) def test_with_name_as(self): check_transformed( """ from freezegun import freeze_time with freeze_time("2023-01-01") as ft: pass """, """ import time_machine with freeze_time("2023-01-01") as ft: pass """, ) def test_with_name(self): check_transformed( """ from freezegun import freeze_time with freeze_time("2023-01-01"): pass """, """ import time_machine with time_machine.travel("2023-01-01", tick=False): pass """, ) time-machine-2.17.0/tests/test_time_machine.py000066400000000000000000000654361504441626200213600ustar00rootroot00000000000000from __future__ import annotations import asyncio import datetime as dt import os import subprocess import sys import time import typing import uuid from contextlib import contextmanager from importlib.util import module_from_spec, spec_from_file_location from textwrap import dedent from unittest import SkipTest, TestCase, mock from zoneinfo import ZoneInfo import pytest from dateutil import tz import time_machine NANOSECONDS_PER_SECOND = time_machine.NANOSECONDS_PER_SECOND EPOCH_DATETIME = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc) EPOCH = EPOCH_DATETIME.timestamp() EPOCH_PLUS_ONE_YEAR_DATETIME = dt.datetime(1971, 1, 1, tzinfo=dt.timezone.utc) EPOCH_PLUS_ONE_YEAR = EPOCH_PLUS_ONE_YEAR_DATETIME.timestamp() LIBRARY_EPOCH_DATETIME = dt.datetime(2020, 4, 29) # The day this library was made LIBRARY_EPOCH = LIBRARY_EPOCH_DATETIME.timestamp() py_have_clock_gettime = pytest.mark.skipif( not hasattr(time, "clock_gettime"), reason="Doesn't have clock_gettime" ) def sleep_one_cycle(clock: int) -> None: time.sleep(time.clock_getres(clock)) @contextmanager def change_local_timezone(local_tz: str | None) -> typing.Iterator[None]: orig_tz = os.environ["TZ"] if local_tz: os.environ["TZ"] = local_tz else: del os.environ["TZ"] time.tzset() try: yield finally: os.environ["TZ"] = orig_tz time.tzset() @pytest.mark.skipif( not hasattr(time, "CLOCK_REALTIME"), reason="No time.CLOCK_REALTIME" ) def test_import_without_clock_realtime(): orig = time.CLOCK_REALTIME del time.CLOCK_REALTIME try: # Recipe for importing from path as documented in importlib spec = spec_from_file_location( f"{__name__}.time_machine_without_clock_realtime", time_machine.__file__ ) assert spec is not None module = module_from_spec(spec) # typeshed says exec_module does not always exist: spec.loader.exec_module(module) # type: ignore[union-attr] finally: time.CLOCK_REALTIME = orig # No assertions - testing for coverage only # datetime module def test_datetime_now_no_args(): with time_machine.travel(EPOCH): now = dt.datetime.now() assert now.year == 1970 assert now.month == 1 assert now.day == 1 # Not asserting on hour/minute because local timezone could shift it assert now.second == 0 assert now.microsecond == 0 assert dt.datetime.now() >= LIBRARY_EPOCH_DATETIME def test_datetime_now_no_args_no_tick(): with time_machine.travel(EPOCH, tick=False): now = dt.datetime.now() assert now.microsecond == 0 assert dt.datetime.now() >= LIBRARY_EPOCH_DATETIME def test_datetime_now_arg(): with time_machine.travel(EPOCH): now = dt.datetime.now(tz=dt.timezone.utc) assert now.year == 1970 assert now.month == 1 assert now.day == 1 assert dt.datetime.now(dt.timezone.utc) >= LIBRARY_EPOCH_DATETIME.replace( tzinfo=dt.timezone.utc ) def test_datetime_utcnow(): with time_machine.travel(EPOCH): now = dt.datetime.utcnow() assert now.year == 1970 assert now.month == 1 assert now.day == 1 assert now.hour == 0 assert now.minute == 0 assert now.second == 0 assert now.microsecond == 0 assert now.tzinfo is None assert dt.datetime.utcnow() >= LIBRARY_EPOCH_DATETIME def test_datetime_utcnow_no_tick(): with time_machine.travel(EPOCH, tick=False): now = dt.datetime.utcnow() assert now.microsecond == 0 def test_date_today(): with time_machine.travel(EPOCH): today = dt.date.today() assert today.year == 1970 assert today.month == 1 assert today.day == 1 assert dt.datetime.today() >= LIBRARY_EPOCH_DATETIME # time module @py_have_clock_gettime def test_time_clock_gettime_realtime(): with time_machine.travel(EPOCH + 180.0): now = time.clock_gettime(time.CLOCK_REALTIME) assert isinstance(now, float) assert now == EPOCH + 180.0 now = time.clock_gettime(time.CLOCK_REALTIME) assert isinstance(now, float) assert now >= LIBRARY_EPOCH @py_have_clock_gettime def test_time_clock_gettime_monotonic_unaffected(): start = time.clock_gettime(time.CLOCK_MONOTONIC) sleep_one_cycle(time.CLOCK_MONOTONIC) with time_machine.travel(EPOCH + 180.0): frozen = time.clock_gettime(time.CLOCK_MONOTONIC) sleep_one_cycle(time.CLOCK_MONOTONIC) assert isinstance(frozen, float) assert frozen > start now = time.clock_gettime(time.CLOCK_MONOTONIC) assert isinstance(now, float) assert now > frozen @py_have_clock_gettime def test_time_clock_gettime_ns_realtime(): with time_machine.travel(EPOCH + 190.0): first = time.clock_gettime_ns(time.CLOCK_REALTIME) sleep_one_cycle(time.CLOCK_REALTIME) assert isinstance(first, int) assert first == int((EPOCH + 190.0) * NANOSECONDS_PER_SECOND) second = time.clock_gettime_ns(time.CLOCK_REALTIME) assert first < second < int((EPOCH + 191.0) * NANOSECONDS_PER_SECOND) now = time.clock_gettime_ns(time.CLOCK_REALTIME) assert isinstance(now, int) assert now >= int(LIBRARY_EPOCH * NANOSECONDS_PER_SECOND) @py_have_clock_gettime def test_time_clock_gettime_ns_monotonic_unaffected(): start = time.clock_gettime_ns(time.CLOCK_MONOTONIC) sleep_one_cycle(time.CLOCK_MONOTONIC) with time_machine.travel(EPOCH + 190.0): frozen = time.clock_gettime_ns(time.CLOCK_MONOTONIC) sleep_one_cycle(time.CLOCK_MONOTONIC) assert isinstance(frozen, int) assert frozen > start now = time.clock_gettime_ns(time.CLOCK_MONOTONIC) assert isinstance(now, int) assert now > frozen def test_time_gmtime_no_args(): with time_machine.travel(EPOCH): local_time = time.gmtime() assert local_time.tm_year == 1970 assert local_time.tm_mon == 1 assert local_time.tm_mday == 1 now_time = time.gmtime() assert now_time.tm_year >= 2020 def test_time_gmtime_no_args_no_tick(): with time_machine.travel(EPOCH, tick=False): local_time = time.gmtime() assert local_time.tm_sec == 0 def test_time_gmtime_arg(): with time_machine.travel(EPOCH): local_time = time.gmtime(EPOCH_PLUS_ONE_YEAR) assert local_time.tm_year == 1971 assert local_time.tm_mon == 1 assert local_time.tm_mday == 1 def test_time_localtime(): with time_machine.travel(EPOCH): local_time = time.localtime() assert local_time.tm_year == 1970 assert local_time.tm_mon == 1 assert local_time.tm_mday == 1 now_time = time.localtime() assert now_time.tm_year >= 2020 def test_time_localtime_no_tick(): with time_machine.travel(EPOCH, tick=False): local_time = time.localtime() assert local_time.tm_sec == 0 def test_time_localtime_arg(): with time_machine.travel(EPOCH): local_time = time.localtime(EPOCH_PLUS_ONE_YEAR) assert local_time.tm_year == 1971 assert local_time.tm_mon == 1 assert local_time.tm_mday == 1 def test_time_montonic(): with time_machine.travel(EPOCH, tick=False) as t: assert time.monotonic() == EPOCH t.shift(1) assert time.monotonic() == EPOCH + 1 def test_time_monotonic_ns(): with time_machine.travel(EPOCH, tick=False) as t: assert time.monotonic_ns() == int(EPOCH * NANOSECONDS_PER_SECOND) t.shift(1) assert ( time.monotonic_ns() == int(EPOCH * NANOSECONDS_PER_SECOND) + NANOSECONDS_PER_SECOND ) def test_time_strftime_format(): with time_machine.travel(EPOCH): assert time.strftime("%Y-%m-%d") == "1970-01-01" assert int(time.strftime("%Y")) >= 2020 def test_time_strftime_format_no_tick(): with time_machine.travel(EPOCH, tick=False): assert time.strftime("%S") == "00" def test_time_strftime_format_t(): with time_machine.travel(EPOCH): assert ( time.strftime("%Y-%m-%d", time.localtime(EPOCH_PLUS_ONE_YEAR)) == "1971-01-01" ) def test_time_time(): with time_machine.travel(EPOCH): first = time.time() sleep_one_cycle(time.CLOCK_MONOTONIC) assert isinstance(first, float) assert first == EPOCH second = time.time() assert first < second < EPOCH + 1.0 now = time.time() assert isinstance(now, float) assert now >= LIBRARY_EPOCH windows_epoch_in_posix = -11_644_445_222 @mock.patch.object( time_machine, "SYSTEM_EPOCH_TIMESTAMP_NS", (windows_epoch_in_posix * NANOSECONDS_PER_SECOND), ) def test_time_time_windows(): with time_machine.travel(EPOCH): first = time.time() sleep_one_cycle(time.CLOCK_MONOTONIC) assert isinstance(first, float) assert first == windows_epoch_in_posix second = time.time() assert isinstance(second, float) assert windows_epoch_in_posix < second < windows_epoch_in_posix + 1.0 def test_time_time_no_tick(): with time_machine.travel(EPOCH, tick=False): assert time.time() == EPOCH def test_time_time_ns(): with time_machine.travel(EPOCH + 150.0): first = time.time_ns() sleep_one_cycle(time.CLOCK_MONOTONIC) assert isinstance(first, int) assert first == int((EPOCH + 150.0) * NANOSECONDS_PER_SECOND) second = time.time_ns() assert first < second < int((EPOCH + 151.0) * NANOSECONDS_PER_SECOND) now = time.time_ns() assert isinstance(now, int) assert now >= int(LIBRARY_EPOCH * NANOSECONDS_PER_SECOND) def test_time_time_ns_no_tick(): with time_machine.travel(EPOCH, tick=False): assert time.time_ns() == int(EPOCH * NANOSECONDS_PER_SECOND) # all supported forms def test_nestable(): with time_machine.travel(EPOCH + 55.0): assert time.time() == EPOCH + 55.0 with time_machine.travel(EPOCH + 50.0): assert time.time() == EPOCH + 50.0 def test_unsupported_type(): with pytest.raises(TypeError) as excinfo, time_machine.travel([]): # type: ignore[arg-type] pass # pragma: no cover assert excinfo.value.args == ("Unsupported destination []",) def test_exceptions_dont_break_it(): with pytest.raises(ValueError), time_machine.travel(0.0): raise ValueError("Hi") # Unreachable code analysis doesn’t work with raises being caught by # context manager with time_machine.travel(0.0): pass @time_machine.travel(EPOCH_DATETIME + dt.timedelta(seconds=70)) def test_destination_datetime(): assert time.time() == EPOCH + 70.0 @time_machine.travel(EPOCH_DATETIME.replace(tzinfo=tz.gettz("America/Chicago"))) def test_destination_datetime_tzinfo_non_zoneinfo(): assert time.time() == EPOCH + 21600.0 def test_destination_datetime_tzinfo_zoneinfo(): orig_timezone = time.timezone orig_altzone = time.altzone orig_tzname = time.tzname orig_daylight = time.daylight dest = LIBRARY_EPOCH_DATETIME.replace(tzinfo=ZoneInfo("Africa/Addis_Ababa")) with time_machine.travel(dest): assert time.timezone == -3 * 3600 assert time.altzone == -3 * 3600 assert time.tzname == ("EAT", "EAT") assert time.daylight == 0 assert time.localtime() == time.struct_time( ( 2020, 4, 29, 0, 0, 0, 2, 120, 0, ) ) assert time.timezone == orig_timezone assert time.altzone == orig_altzone assert time.tzname == orig_tzname assert time.daylight == orig_daylight def test_destination_datetime_tzinfo_zoneinfo_nested(): orig_tzname = time.tzname dest = LIBRARY_EPOCH_DATETIME.replace(tzinfo=ZoneInfo("Africa/Addis_Ababa")) with time_machine.travel(dest): assert time.tzname == ("EAT", "EAT") dest2 = LIBRARY_EPOCH_DATETIME.replace(tzinfo=ZoneInfo("Pacific/Auckland")) with time_machine.travel(dest2): assert time.tzname == ("NZST", "NZDT") assert time.tzname == ("EAT", "EAT") assert time.tzname == orig_tzname def test_destination_datetime_tzinfo_zoneinfo_no_orig_tz(): with change_local_timezone(None): orig_tzname = time.tzname dest = LIBRARY_EPOCH_DATETIME.replace(tzinfo=ZoneInfo("Africa/Addis_Ababa")) with time_machine.travel(dest): assert time.tzname == ("EAT", "EAT") assert time.tzname == orig_tzname def test_destination_datetime_tzinfo_zoneinfo_windows(): orig_timezone = time.timezone pretend_windows_no_tzset = mock.patch.object(time_machine, "tzset", new=None) mock_have_tzset_false = mock.patch.object(time_machine, "HAVE_TZSET", new=False) dest = LIBRARY_EPOCH_DATETIME.replace(tzinfo=ZoneInfo("Africa/Addis_Ababa")) with pretend_windows_no_tzset, mock_have_tzset_false, time_machine.travel(dest): assert time.timezone == orig_timezone @time_machine.travel(int(EPOCH + 77)) def test_destination_int(): assert time.time() == int(EPOCH + 77) @time_machine.travel(EPOCH_DATETIME.replace(tzinfo=None) + dt.timedelta(seconds=120)) def test_destination_datetime_naive(): assert time.time() == EPOCH + 120.0 @time_machine.travel(EPOCH_DATETIME.date()) def test_destination_date(): assert time.time() == EPOCH def test_destination_timedelta(): now = time.time() with time_machine.travel(dt.timedelta(seconds=3600)): assert now + 3600 <= time.time() <= now + 3601 def test_destination_timedelta_first_travel_in_process(): # Would previously segfault subprocess.run( [ sys.executable, "-c", dedent( """ from datetime import timedelta import time_machine with time_machine.travel(timedelta()): pass """ ), ], check=True, ) def test_destination_timedelta_negative(): now = time.time() with time_machine.travel(dt.timedelta(seconds=-3600)): assert now - 3600 <= time.time() <= now - 3599 def test_destination_timedelta_nested(): with time_machine.travel(EPOCH), time_machine.travel(dt.timedelta(seconds=10)): assert time.time() == EPOCH + 10.0 @time_machine.travel("1970-01-01 00:01 +0000") def test_destination_string(): assert time.time() == EPOCH + 60.0 @pytest.mark.parametrize( ["local_tz", "expected_offset"], [ ("UTC", 0), ("Europe/Amsterdam", -3600), ("US/Eastern", 5 * 3600), ], ) @pytest.mark.parametrize("destination", ["1970-01-01 00:00", "1970-01-01"]) def test_destination_string_naive(local_tz, expected_offset, destination): with change_local_timezone(local_tz), time_machine.travel(destination): assert time.time() == EPOCH + expected_offset @time_machine.travel(lambda: EPOCH + 140.0) def test_destination_callable_lambda_float(): assert time.time() == EPOCH + 140.0 @time_machine.travel(lambda: "1970-01-01 00:02 +0000") def test_destination_callable_lambda_string(): assert time.time() == EPOCH + 120.0 @time_machine.travel(EPOCH + 13.0 for _ in range(1)) # pragma: no branch def test_destination_generator(): assert time.time() == EPOCH + 13.0 def test_traveller_object(): traveller = time_machine.travel(EPOCH + 10.0) assert time.time() >= LIBRARY_EPOCH try: traveller.start() assert time.time() == EPOCH + 10.0 finally: traveller.stop() assert time.time() >= LIBRARY_EPOCH @time_machine.travel(EPOCH + 15.0) def test_function_decorator(): assert time.time() == EPOCH + 15.0 def test_coroutine_decorator(): recorded_time = None @time_machine.travel(EPOCH + 140.0) async def record_time() -> None: nonlocal recorded_time recorded_time = time.time() asyncio.run(record_time()) assert recorded_time == EPOCH + 140.0 def test_class_decorator_fails_non_testcase(): with pytest.raises(TypeError) as excinfo: @time_machine.travel(EPOCH) class Something: pass assert excinfo.value.args == ("Can only decorate unittest.TestCase subclasses.",) @time_machine.travel(EPOCH) class ClassDecoratorInheritanceBase(TestCase): prop: bool @classmethod def setUpClass(cls): super().setUpClass() cls.setUpTestData() @classmethod def setUpTestData(cls) -> None: cls.prop = True class ClassDecoratorInheritanceTests(ClassDecoratorInheritanceBase): @classmethod def setUpTestData(cls) -> None: super().setUpTestData() cls.prop = False def test_ineheritance_correctly_rebound(self): assert self.prop is False class TestMethodDecorator: @time_machine.travel(EPOCH + 95.0) def test_method_decorator(self): assert time.time() == EPOCH + 95.0 class UnitTestMethodTests(TestCase): @time_machine.travel(EPOCH + 25.0) def test_method_decorator(self): assert time.time() == EPOCH + 25.0 @time_machine.travel(EPOCH + 95.0) class UnitTestClassTests(TestCase): def test_class_decorator(self): sleep_one_cycle(time.CLOCK_MONOTONIC) assert EPOCH + 95.0 < time.time() < EPOCH + 96.0 @time_machine.travel(EPOCH + 25.0) def test_stacked_method_decorator(self): assert time.time() == EPOCH + 25.0 @time_machine.travel(EPOCH + 95.0) class UnitTestClassCustomSetUpClassTests(TestCase): custom_setupclass_ran: bool @classmethod def setUpClass(cls): super().setUpClass() cls.custom_setupclass_ran = True def test_class_decorator(self): sleep_one_cycle(time.CLOCK_MONOTONIC) assert EPOCH + 95.0 < time.time() < EPOCH + 96.0 assert self.custom_setupclass_ran @time_machine.travel(EPOCH + 110.0) class UnitTestClassSetUpClassSkipTests(TestCase): @classmethod def setUpClass(cls): raise SkipTest("Not today") # Other tests would fail if the travel() wasn't stopped def test_thats_always_skipped(self): # pragma: no cover pass # shift() tests def test_shift_with_timedelta(): with time_machine.travel(EPOCH, tick=False) as traveller: traveller.shift(dt.timedelta(days=1)) assert time.time() == EPOCH + (3600.0 * 24) def test_shift_integer_delta(): with time_machine.travel(EPOCH, tick=False) as traveller: traveller.shift(10) assert time.time() == EPOCH + 10 def test_shift_negative_delta(): with time_machine.travel(EPOCH, tick=False) as traveller: traveller.shift(-10) assert time.time() == EPOCH - 10 def test_shift_wrong_delta(): with ( time_machine.travel(EPOCH, tick=False) as traveller, pytest.raises(TypeError) as excinfo, ): traveller.shift(delta="1.1") # type: ignore[arg-type] assert excinfo.value.args == ("Unsupported type for delta argument: '1.1'",) def test_shift_when_tick(): with time_machine.travel(EPOCH, tick=True) as traveller: traveller.shift(10.0) assert EPOCH + 10.0 <= time.time() < EPOCH + 20.0 # move_to() tests def test_move_to_datetime(): with time_machine.travel(EPOCH) as traveller: assert time.time() == EPOCH traveller.move_to(EPOCH_PLUS_ONE_YEAR_DATETIME) first = time.time() sleep_one_cycle(time.CLOCK_MONOTONIC) assert first == EPOCH_PLUS_ONE_YEAR second = time.time() assert first < second < first + 1.0 def test_move_to_datetime_no_tick(): with time_machine.travel(EPOCH, tick=False) as traveller: traveller.move_to(EPOCH_PLUS_ONE_YEAR_DATETIME) assert time.time() == EPOCH_PLUS_ONE_YEAR assert time.time() == EPOCH_PLUS_ONE_YEAR def test_move_to_past_datetime(): with time_machine.travel(EPOCH_PLUS_ONE_YEAR) as traveller: assert time.time() == EPOCH_PLUS_ONE_YEAR traveller.move_to(EPOCH_DATETIME) assert time.time() == EPOCH def test_move_to_datetime_with_tzinfo_zoneinfo(): orig_timezone = time.timezone orig_altzone = time.altzone orig_tzname = time.tzname orig_daylight = time.daylight with time_machine.travel(EPOCH) as traveller: assert time.time() == EPOCH assert time.timezone == orig_timezone assert time.altzone == orig_altzone assert time.tzname == orig_tzname assert time.daylight == orig_daylight dest = EPOCH_PLUS_ONE_YEAR_DATETIME.replace( tzinfo=ZoneInfo("Africa/Addis_Ababa") ) traveller.move_to(dest) assert time.timezone == -3 * 3600 assert time.altzone == -3 * 3600 assert time.tzname == ("EAT", "EAT") assert time.daylight == 0 assert time.localtime() == time.struct_time( ( 1971, 1, 1, 0, 0, 0, 4, 1, 0, ) ) assert time.timezone == orig_timezone assert time.altzone == orig_altzone assert time.tzname == orig_tzname assert time.daylight == orig_daylight def test_move_to_datetime_change_tick_on(): with time_machine.travel(EPOCH, tick=False) as traveller: traveller.move_to(EPOCH_PLUS_ONE_YEAR_DATETIME, tick=True) assert time.time() == EPOCH_PLUS_ONE_YEAR sleep_one_cycle(time.CLOCK_MONOTONIC) assert time.time() > EPOCH_PLUS_ONE_YEAR def test_move_to_datetime_change_tick_off(): with time_machine.travel(EPOCH, tick=True) as traveller: traveller.move_to(EPOCH_PLUS_ONE_YEAR_DATETIME, tick=False) assert time.time() == EPOCH_PLUS_ONE_YEAR assert time.time() == EPOCH_PLUS_ONE_YEAR # uuid tests def time_from_uuid1(value: uuid.UUID) -> dt.datetime: return dt.datetime(1582, 10, 15) + dt.timedelta(microseconds=value.time // 10) def test_uuid1(): """ Test that the uuid.uuid1() methods generate values for the destination. They are a known location in the stdlib that can make system calls to find the current datetime. """ destination = dt.datetime(2017, 2, 6, 14, 8, 21) with time_machine.travel(destination, tick=False): assert time_from_uuid1(uuid.uuid1()) == destination # pytest plugin tests def test_fixture_unused(time_machine): assert time.time() >= LIBRARY_EPOCH def test_fixture_used(time_machine): time_machine.move_to(EPOCH) assert time.time() == EPOCH def test_fixture_used_tick_false(time_machine): time_machine.move_to(EPOCH, tick=False) assert time.time() == EPOCH assert time.time() == EPOCH def test_fixture_used_tick_true(time_machine): time_machine.move_to(EPOCH, tick=True) original = time.time() sleep_one_cycle(time.CLOCK_MONOTONIC) assert original == EPOCH assert original < time.time() < EPOCH + 10.0 def test_fixture_move_to_twice(time_machine): time_machine.move_to(EPOCH) assert time.time() == EPOCH time_machine.move_to(EPOCH_PLUS_ONE_YEAR) assert time.time() == EPOCH_PLUS_ONE_YEAR def test_fixture_move_to_and_shift(time_machine): time_machine.move_to(EPOCH, tick=False) assert time.time() == EPOCH time_machine.shift(100) assert time.time() == EPOCH + 100 def test_fixture_shift_without_move_to(time_machine): with pytest.raises(RuntimeError) as excinfo: time_machine.shift(100) assert excinfo.value.args == ( "Initialize time_machine with move_to() before using shift().", ) # escape hatch tests class TestEscapeHatch: def test_is_travelling_false(self): assert time_machine.escape_hatch.is_travelling() is False def test_is_travelling_true(self): with time_machine.travel(EPOCH): assert time_machine.escape_hatch.is_travelling() is True def test_datetime_now(self): real_now = dt.datetime.now() with time_machine.travel(EPOCH): eh_now = time_machine.escape_hatch.datetime.datetime.now() assert eh_now >= real_now def test_datetime_now_tz(self): real_now = dt.datetime.now(tz=dt.timezone.utc) with time_machine.travel(EPOCH): eh_now = time_machine.escape_hatch.datetime.datetime.now(tz=dt.timezone.utc) assert eh_now >= real_now def test_datetime_utcnow(self): real_now = dt.datetime.utcnow() with time_machine.travel(EPOCH): eh_now = time_machine.escape_hatch.datetime.datetime.utcnow() assert eh_now >= real_now @py_have_clock_gettime def test_time_clock_gettime(self): now = time.clock_gettime(time.CLOCK_REALTIME) with time_machine.travel(EPOCH + 180.0): eh_now = time_machine.escape_hatch.time.clock_gettime(time.CLOCK_REALTIME) assert eh_now >= now @py_have_clock_gettime def test_time_clock_gettime_ns(self): now = time.clock_gettime_ns(time.CLOCK_REALTIME) with time_machine.travel(EPOCH + 190.0): eh_now = time_machine.escape_hatch.time.clock_gettime_ns( time.CLOCK_REALTIME ) assert eh_now >= now def test_time_gmtime(self): now = time.gmtime() with time_machine.travel(EPOCH): eh_now = time_machine.escape_hatch.time.gmtime() assert eh_now >= now def test_time_localtime(self): now = time.localtime() with time_machine.travel(EPOCH): eh_now = time_machine.escape_hatch.time.localtime() assert eh_now >= now def test_time_monotonic(self): with time_machine.travel(LIBRARY_EPOCH): # real monotonic time counts from a small number assert time_machine.escape_hatch.time.monotonic() < LIBRARY_EPOCH def test_time_monotonic_ns(self): with time_machine.travel(LIBRARY_EPOCH): # real monotonic time counts from a small number assert ( time_machine.escape_hatch.time.monotonic_ns() < LIBRARY_EPOCH * NANOSECONDS_PER_SECOND ) def test_time_strftime_no_arg(self): today = dt.date.today() with time_machine.travel(EPOCH): eh_formatted = time_machine.escape_hatch.time.strftime("%Y-%m-%d") eh_today = dt.datetime.strptime(eh_formatted, "%Y-%m-%d").date() assert eh_today >= today def test_time_strftime_arg(self): with time_machine.travel(EPOCH): formatted = time_machine.escape_hatch.time.strftime( "%Y-%m-%d", time.localtime(EPOCH_PLUS_ONE_YEAR), ) assert formatted == "1971-01-01" def test_time_time(self): now = time.time() with time_machine.travel(EPOCH): eh_now = time_machine.escape_hatch.time.time() assert eh_now >= now def test_time_time_ns(self): now = time.time_ns() with time_machine.travel(EPOCH): eh_now = time_machine.escape_hatch.time.time_ns() assert eh_now >= now time-machine-2.17.0/tox.ini000066400000000000000000000010501504441626200154540ustar00rootroot00000000000000[tox] requires = tox>=4.2 env_list = py{314, 313, 312, 311, 310, 39, 314t, 313t} [testenv] runner = uv-venv-lock-runner package = wheel extras = cli set_env = PYTHONDEVMODE = 1 commands = python \ -W error::ResourceWarning \ -W error::DeprecationWarning \ -W error::PendingDeprecationWarning \ -W ignore:datetime.datetime.utcfromtimestamp:DeprecationWarning \ -W ignore:datetime.datetime.utcnow:DeprecationWarning \ -m coverage run \ -m pytest {posargs:tests} dependency_groups = test time-machine-2.17.0/uv.lock000066400000000000000000003342231504441626200154600ustar00rootroot00000000000000version = 1 revision = 3 requires-python = ">=3.9" resolution-markers = [ "python_full_version >= '3.11'", "python_full_version == '3.10.*'", "python_full_version < '3.10'", ] [[package]] name = "accessible-pygments" version = "0.0.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/bc/c1/bbac6a50d02774f91572938964c582fff4270eee73ab822a4aeea4d8b11b/accessible_pygments-0.0.5.tar.gz", hash = "sha256:40918d3e6a2b619ad424cb91e556bd3bd8865443d9f22f1dcdf79e33c8046872", size = 1377899, upload-time = "2024-05-10T11:23:10.216Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/8d/3f/95338030883d8c8b91223b4e21744b04d11b161a3ef117295d8241f50ab4/accessible_pygments-0.0.5-py3-none-any.whl", hash = "sha256:88ae3211e68a1d0b011504b2ffc1691feafce124b845bd072ab6f9f66f34d4b7", size = 1395903, upload-time = "2024-05-10T11:23:08.421Z" }, ] [[package]] name = "alabaster" version = "0.7.16" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version < '3.10'", ] sdist = { url = "https://files.pythonhosted.org/packages/c9/3e/13dd8e5ed9094e734ac430b5d0eb4f2bb001708a8b7856cbf8e084e001ba/alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65", size = 23776, upload-time = "2024-01-10T00:56:10.189Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/32/34/d4e1c02d3bee589efb5dfa17f88ea08bdb3e3eac12bc475462aec52ed223/alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92", size = 13511, upload-time = "2024-01-10T00:56:08.388Z" }, ] [[package]] name = "alabaster" version = "1.0.0" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.11'", "python_full_version == '3.10.*'", ] sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, ] [[package]] name = "babel" version = "2.17.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, ] [[package]] name = "beautifulsoup4" version = "4.13.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "soupsieve" }, { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d8/e4/0c4c39e18fd76d6a628d4dd8da40543d136ce2d1752bd6eeeab0791f4d6b/beautifulsoup4-4.13.4.tar.gz", hash = "sha256:dbb3c4e1ceae6aefebdaf2423247260cd062430a410e38c66f2baa50a8437195", size = 621067, upload-time = "2025-04-15T17:05:13.836Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/50/cd/30110dc0ffcf3b131156077b90e9f60ed75711223f306da4db08eff8403b/beautifulsoup4-4.13.4-py3-none-any.whl", hash = "sha256:9bbbb14bfde9d79f38b8cd5f8c7c85f4b8f2523190ebed90e950a8dea4cb1c4b", size = 187285, upload-time = "2025-04-15T17:05:12.221Z" }, ] [[package]] name = "certifi" version = "2025.8.3" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/dc/67/960ebe6bf230a96cda2e0abcf73af550ec4f090005363542f0765df162e0/certifi-2025.8.3.tar.gz", hash = "sha256:e564105f78ded564e3ae7c923924435e1daa7463faeab5bb932bc53ffae63407", size = 162386, upload-time = "2025-08-03T03:07:47.08Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/e5/48/1549795ba7742c948d2ad169c1c8cdbae65bc450d6cd753d124b17c8cd32/certifi-2025.8.3-py3-none-any.whl", hash = "sha256:f6c12493cfb1b06ba2ff328595af9350c65d6644968e5d3a2ffd78699af217a5", size = 161216, upload-time = "2025-08-03T03:07:45.777Z" }, ] [[package]] name = "charset-normalizer" version = "3.4.2" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367, upload-time = "2025-05-02T08:34:42.01Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/95/28/9901804da60055b406e1a1c5ba7aac1276fb77f1dde635aabfc7fd84b8ab/charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941", size = 201818, upload-time = "2025-05-02T08:31:46.725Z" }, { url = "https://files.pythonhosted.org/packages/d9/9b/892a8c8af9110935e5adcbb06d9c6fe741b6bb02608c6513983048ba1a18/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd", size = 144649, upload-time = "2025-05-02T08:31:48.889Z" }, { url = "https://files.pythonhosted.org/packages/7b/a5/4179abd063ff6414223575e008593861d62abfc22455b5d1a44995b7c101/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6", size = 155045, upload-time = "2025-05-02T08:31:50.757Z" }, { url = "https://files.pythonhosted.org/packages/3b/95/bc08c7dfeddd26b4be8c8287b9bb055716f31077c8b0ea1cd09553794665/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d", size = 147356, upload-time = "2025-05-02T08:31:52.634Z" }, { url = "https://files.pythonhosted.org/packages/a8/2d/7a5b635aa65284bf3eab7653e8b4151ab420ecbae918d3e359d1947b4d61/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86", size = 149471, upload-time = "2025-05-02T08:31:56.207Z" }, { url = "https://files.pythonhosted.org/packages/ae/38/51fc6ac74251fd331a8cfdb7ec57beba8c23fd5493f1050f71c87ef77ed0/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c", size = 151317, upload-time = "2025-05-02T08:31:57.613Z" }, { url = "https://files.pythonhosted.org/packages/b7/17/edee1e32215ee6e9e46c3e482645b46575a44a2d72c7dfd49e49f60ce6bf/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0", size = 146368, upload-time = "2025-05-02T08:31:59.468Z" }, { url = "https://files.pythonhosted.org/packages/26/2c/ea3e66f2b5f21fd00b2825c94cafb8c326ea6240cd80a91eb09e4a285830/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef", size = 154491, upload-time = "2025-05-02T08:32:01.219Z" }, { url = "https://files.pythonhosted.org/packages/52/47/7be7fa972422ad062e909fd62460d45c3ef4c141805b7078dbab15904ff7/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6", size = 157695, upload-time = "2025-05-02T08:32:03.045Z" }, { url = "https://files.pythonhosted.org/packages/2f/42/9f02c194da282b2b340f28e5fb60762de1151387a36842a92b533685c61e/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366", size = 154849, upload-time = "2025-05-02T08:32:04.651Z" }, { url = "https://files.pythonhosted.org/packages/67/44/89cacd6628f31fb0b63201a618049be4be2a7435a31b55b5eb1c3674547a/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db", size = 150091, upload-time = "2025-05-02T08:32:06.719Z" }, { url = "https://files.pythonhosted.org/packages/1f/79/4b8da9f712bc079c0f16b6d67b099b0b8d808c2292c937f267d816ec5ecc/charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a", size = 98445, upload-time = "2025-05-02T08:32:08.66Z" }, { url = "https://files.pythonhosted.org/packages/7d/d7/96970afb4fb66497a40761cdf7bd4f6fca0fc7bafde3a84f836c1f57a926/charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509", size = 105782, upload-time = "2025-05-02T08:32:10.46Z" }, { url = "https://files.pythonhosted.org/packages/05/85/4c40d00dcc6284a1c1ad5de5e0996b06f39d8232f1031cd23c2f5c07ee86/charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2", size = 198794, upload-time = "2025-05-02T08:32:11.945Z" }, { url = "https://files.pythonhosted.org/packages/41/d9/7a6c0b9db952598e97e93cbdfcb91bacd89b9b88c7c983250a77c008703c/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645", size = 142846, upload-time = "2025-05-02T08:32:13.946Z" }, { url = "https://files.pythonhosted.org/packages/66/82/a37989cda2ace7e37f36c1a8ed16c58cf48965a79c2142713244bf945c89/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd", size = 153350, upload-time = "2025-05-02T08:32:15.873Z" }, { url = "https://files.pythonhosted.org/packages/df/68/a576b31b694d07b53807269d05ec3f6f1093e9545e8607121995ba7a8313/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8", size = 145657, upload-time = "2025-05-02T08:32:17.283Z" }, { url = "https://files.pythonhosted.org/packages/92/9b/ad67f03d74554bed3aefd56fe836e1623a50780f7c998d00ca128924a499/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f", size = 147260, upload-time = "2025-05-02T08:32:18.807Z" }, { url = "https://files.pythonhosted.org/packages/a6/e6/8aebae25e328160b20e31a7e9929b1578bbdc7f42e66f46595a432f8539e/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7", size = 149164, upload-time = "2025-05-02T08:32:20.333Z" }, { url = "https://files.pythonhosted.org/packages/8b/f2/b3c2f07dbcc248805f10e67a0262c93308cfa149a4cd3d1fe01f593e5fd2/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9", size = 144571, upload-time = "2025-05-02T08:32:21.86Z" }, { url = "https://files.pythonhosted.org/packages/60/5b/c3f3a94bc345bc211622ea59b4bed9ae63c00920e2e8f11824aa5708e8b7/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544", size = 151952, upload-time = "2025-05-02T08:32:23.434Z" }, { url = "https://files.pythonhosted.org/packages/e2/4d/ff460c8b474122334c2fa394a3f99a04cf11c646da895f81402ae54f5c42/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82", size = 155959, upload-time = "2025-05-02T08:32:24.993Z" }, { url = "https://files.pythonhosted.org/packages/a2/2b/b964c6a2fda88611a1fe3d4c400d39c66a42d6c169c924818c848f922415/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0", size = 153030, upload-time = "2025-05-02T08:32:26.435Z" }, { url = "https://files.pythonhosted.org/packages/59/2e/d3b9811db26a5ebf444bc0fa4f4be5aa6d76fc6e1c0fd537b16c14e849b6/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5", size = 148015, upload-time = "2025-05-02T08:32:28.376Z" }, { url = "https://files.pythonhosted.org/packages/90/07/c5fd7c11eafd561bb51220d600a788f1c8d77c5eef37ee49454cc5c35575/charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a", size = 98106, upload-time = "2025-05-02T08:32:30.281Z" }, { url = "https://files.pythonhosted.org/packages/a8/05/5e33dbef7e2f773d672b6d79f10ec633d4a71cd96db6673625838a4fd532/charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28", size = 105402, upload-time = "2025-05-02T08:32:32.191Z" }, { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936, upload-time = "2025-05-02T08:32:33.712Z" }, { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790, upload-time = "2025-05-02T08:32:35.768Z" }, { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924, upload-time = "2025-05-02T08:32:37.284Z" }, { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626, upload-time = "2025-05-02T08:32:38.803Z" }, { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567, upload-time = "2025-05-02T08:32:40.251Z" }, { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957, upload-time = "2025-05-02T08:32:41.705Z" }, { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408, upload-time = "2025-05-02T08:32:43.709Z" }, { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399, upload-time = "2025-05-02T08:32:46.197Z" }, { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815, upload-time = "2025-05-02T08:32:48.105Z" }, { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537, upload-time = "2025-05-02T08:32:49.719Z" }, { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565, upload-time = "2025-05-02T08:32:51.404Z" }, { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357, upload-time = "2025-05-02T08:32:53.079Z" }, { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776, upload-time = "2025-05-02T08:32:54.573Z" }, { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622, upload-time = "2025-05-02T08:32:56.363Z" }, { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435, upload-time = "2025-05-02T08:32:58.551Z" }, { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653, upload-time = "2025-05-02T08:33:00.342Z" }, { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231, upload-time = "2025-05-02T08:33:02.081Z" }, { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243, upload-time = "2025-05-02T08:33:04.063Z" }, { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442, upload-time = "2025-05-02T08:33:06.418Z" }, { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147, upload-time = "2025-05-02T08:33:08.183Z" }, { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057, upload-time = "2025-05-02T08:33:09.986Z" }, { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454, upload-time = "2025-05-02T08:33:11.814Z" }, { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174, upload-time = "2025-05-02T08:33:13.707Z" }, { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166, upload-time = "2025-05-02T08:33:15.458Z" }, { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064, upload-time = "2025-05-02T08:33:17.06Z" }, { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641, upload-time = "2025-05-02T08:33:18.753Z" }, { url = "https://files.pythonhosted.org/packages/28/f8/dfb01ff6cc9af38552c69c9027501ff5a5117c4cc18dcd27cb5259fa1888/charset_normalizer-3.4.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4", size = 201671, upload-time = "2025-05-02T08:34:12.696Z" }, { url = "https://files.pythonhosted.org/packages/32/fb/74e26ee556a9dbfe3bd264289b67be1e6d616329403036f6507bb9f3f29c/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7", size = 144744, upload-time = "2025-05-02T08:34:14.665Z" }, { url = "https://files.pythonhosted.org/packages/ad/06/8499ee5aa7addc6f6d72e068691826ff093329fe59891e83b092ae4c851c/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836", size = 154993, upload-time = "2025-05-02T08:34:17.134Z" }, { url = "https://files.pythonhosted.org/packages/f1/a2/5e4c187680728219254ef107a6949c60ee0e9a916a5dadb148c7ae82459c/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597", size = 147382, upload-time = "2025-05-02T08:34:19.081Z" }, { url = "https://files.pythonhosted.org/packages/4c/fe/56aca740dda674f0cc1ba1418c4d84534be51f639b5f98f538b332dc9a95/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7", size = 149536, upload-time = "2025-05-02T08:34:21.073Z" }, { url = "https://files.pythonhosted.org/packages/53/13/db2e7779f892386b589173dd689c1b1e304621c5792046edd8a978cbf9e0/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f", size = 151349, upload-time = "2025-05-02T08:34:23.193Z" }, { url = "https://files.pythonhosted.org/packages/69/35/e52ab9a276186f729bce7a0638585d2982f50402046e4b0faa5d2c3ef2da/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba", size = 146365, upload-time = "2025-05-02T08:34:25.187Z" }, { url = "https://files.pythonhosted.org/packages/a6/d8/af7333f732fc2e7635867d56cb7c349c28c7094910c72267586947561b4b/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12", size = 154499, upload-time = "2025-05-02T08:34:27.359Z" }, { url = "https://files.pythonhosted.org/packages/7a/3d/a5b2e48acef264d71e036ff30bcc49e51bde80219bb628ba3e00cf59baac/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518", size = 157735, upload-time = "2025-05-02T08:34:29.798Z" }, { url = "https://files.pythonhosted.org/packages/85/d8/23e2c112532a29f3eef374375a8684a4f3b8e784f62b01da931186f43494/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5", size = 154786, upload-time = "2025-05-02T08:34:31.858Z" }, { url = "https://files.pythonhosted.org/packages/c7/57/93e0169f08ecc20fe82d12254a200dfaceddc1c12a4077bf454ecc597e33/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3", size = 150203, upload-time = "2025-05-02T08:34:33.88Z" }, { url = "https://files.pythonhosted.org/packages/2c/9d/9bf2b005138e7e060d7ebdec7503d0ef3240141587651f4b445bdf7286c2/charset_normalizer-3.4.2-cp39-cp39-win32.whl", hash = "sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471", size = 98436, upload-time = "2025-05-02T08:34:35.907Z" }, { url = "https://files.pythonhosted.org/packages/6d/24/5849d46cf4311bbf21b424c443b09b459f5b436b1558c04e45dbb7cc478b/charset_normalizer-3.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e", size = 105772, upload-time = "2025-05-02T08:34:37.935Z" }, { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload-time = "2025-05-02T08:34:40.053Z" }, ] [[package]] name = "colorama" version = "0.4.6" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] [[package]] name = "coverage" version = "7.8.2" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/ba/07/998afa4a0ecdf9b1981ae05415dad2d4e7716e1b1f00abbd91691ac09ac9/coverage-7.8.2.tar.gz", hash = "sha256:a886d531373a1f6ff9fad2a2ba4a045b68467b779ae729ee0b3b10ac20033b27", size = 812759, upload-time = "2025-05-23T11:39:57.856Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/26/6b/7dd06399a5c0b81007e3a6af0395cd60e6a30f959f8d407d3ee04642e896/coverage-7.8.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd8ec21e1443fd7a447881332f7ce9d35b8fbd2849e761bb290b584535636b0a", size = 211573, upload-time = "2025-05-23T11:37:47.207Z" }, { url = "https://files.pythonhosted.org/packages/f0/df/2b24090820a0bac1412955fb1a4dade6bc3b8dcef7b899c277ffaf16916d/coverage-7.8.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4c26c2396674816deaeae7ded0e2b42c26537280f8fe313335858ffff35019be", size = 212006, upload-time = "2025-05-23T11:37:50.289Z" }, { url = "https://files.pythonhosted.org/packages/c5/c4/e4e3b998e116625562a872a342419652fa6ca73f464d9faf9f52f1aff427/coverage-7.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1aec326ed237e5880bfe69ad41616d333712c7937bcefc1343145e972938f9b3", size = 241128, upload-time = "2025-05-23T11:37:52.229Z" }, { url = "https://files.pythonhosted.org/packages/b1/67/b28904afea3e87a895da850ba587439a61699bf4b73d04d0dfd99bbd33b4/coverage-7.8.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5e818796f71702d7a13e50c70de2a1924f729228580bcba1607cccf32eea46e6", size = 239026, upload-time = "2025-05-23T11:37:53.846Z" }, { url = "https://files.pythonhosted.org/packages/8c/0f/47bf7c5630d81bc2cd52b9e13043685dbb7c79372a7f5857279cc442b37c/coverage-7.8.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:546e537d9e24efc765c9c891328f30f826e3e4808e31f5d0f87c4ba12bbd1622", size = 240172, upload-time = "2025-05-23T11:37:55.711Z" }, { url = "https://files.pythonhosted.org/packages/ba/38/af3eb9d36d85abc881f5aaecf8209383dbe0fa4cac2d804c55d05c51cb04/coverage-7.8.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab9b09a2349f58e73f8ebc06fac546dd623e23b063e5398343c5270072e3201c", size = 240086, upload-time = "2025-05-23T11:37:57.724Z" }, { url = "https://files.pythonhosted.org/packages/9e/64/c40c27c2573adeba0fe16faf39a8aa57368a1f2148865d6bb24c67eadb41/coverage-7.8.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fd51355ab8a372d89fb0e6a31719e825cf8df8b6724bee942fb5b92c3f016ba3", size = 238792, upload-time = "2025-05-23T11:37:59.737Z" }, { url = "https://files.pythonhosted.org/packages/8e/ab/b7c85146f15457671c1412afca7c25a5696d7625e7158002aa017e2d7e3c/coverage-7.8.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0774df1e093acb6c9e4d58bce7f86656aeed6c132a16e2337692c12786b32404", size = 239096, upload-time = "2025-05-23T11:38:01.693Z" }, { url = "https://files.pythonhosted.org/packages/d3/50/9446dad1310905fb1dc284d60d4320a5b25d4e3e33f9ea08b8d36e244e23/coverage-7.8.2-cp310-cp310-win32.whl", hash = "sha256:00f2e2f2e37f47e5f54423aeefd6c32a7dbcedc033fcd3928a4f4948e8b96af7", size = 214144, upload-time = "2025-05-23T11:38:03.68Z" }, { url = "https://files.pythonhosted.org/packages/23/ed/792e66ad7b8b0df757db8d47af0c23659cdb5a65ef7ace8b111cacdbee89/coverage-7.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:145b07bea229821d51811bf15eeab346c236d523838eda395ea969d120d13347", size = 215043, upload-time = "2025-05-23T11:38:05.217Z" }, { url = "https://files.pythonhosted.org/packages/6a/4d/1ff618ee9f134d0de5cc1661582c21a65e06823f41caf801aadf18811a8e/coverage-7.8.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b99058eef42e6a8dcd135afb068b3d53aff3921ce699e127602efff9956457a9", size = 211692, upload-time = "2025-05-23T11:38:08.485Z" }, { url = "https://files.pythonhosted.org/packages/96/fa/c3c1b476de96f2bc7a8ca01a9f1fcb51c01c6b60a9d2c3e66194b2bdb4af/coverage-7.8.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5feb7f2c3e6ea94d3b877def0270dff0947b8d8c04cfa34a17be0a4dc1836879", size = 212115, upload-time = "2025-05-23T11:38:09.989Z" }, { url = "https://files.pythonhosted.org/packages/f7/c2/5414c5a1b286c0f3881ae5adb49be1854ac5b7e99011501f81c8c1453065/coverage-7.8.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:670a13249b957bb9050fab12d86acef7bf8f6a879b9d1a883799276e0d4c674a", size = 244740, upload-time = "2025-05-23T11:38:11.947Z" }, { url = "https://files.pythonhosted.org/packages/cd/46/1ae01912dfb06a642ef3dd9cf38ed4996fda8fe884dab8952da616f81a2b/coverage-7.8.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0bdc8bf760459a4a4187b452213e04d039990211f98644c7292adf1e471162b5", size = 242429, upload-time = "2025-05-23T11:38:13.955Z" }, { url = "https://files.pythonhosted.org/packages/06/58/38c676aec594bfe2a87c7683942e5a30224791d8df99bcc8439fde140377/coverage-7.8.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07a989c867986c2a75f158f03fdb413128aad29aca9d4dbce5fc755672d96f11", size = 244218, upload-time = "2025-05-23T11:38:15.631Z" }, { url = "https://files.pythonhosted.org/packages/80/0c/95b1023e881ce45006d9abc250f76c6cdab7134a1c182d9713878dfefcb2/coverage-7.8.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2db10dedeb619a771ef0e2949ccba7b75e33905de959c2643a4607bef2f3fb3a", size = 243865, upload-time = "2025-05-23T11:38:17.622Z" }, { url = "https://files.pythonhosted.org/packages/57/37/0ae95989285a39e0839c959fe854a3ae46c06610439350d1ab860bf020ac/coverage-7.8.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e6ea7dba4e92926b7b5f0990634b78ea02f208d04af520c73a7c876d5a8d36cb", size = 242038, upload-time = "2025-05-23T11:38:19.966Z" }, { url = "https://files.pythonhosted.org/packages/4d/82/40e55f7c0eb5e97cc62cbd9d0746fd24e8caf57be5a408b87529416e0c70/coverage-7.8.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ef2f22795a7aca99fc3c84393a55a53dd18ab8c93fb431004e4d8f0774150f54", size = 242567, upload-time = "2025-05-23T11:38:21.912Z" }, { url = "https://files.pythonhosted.org/packages/f9/35/66a51adc273433a253989f0d9cc7aa6bcdb4855382cf0858200afe578861/coverage-7.8.2-cp311-cp311-win32.whl", hash = "sha256:641988828bc18a6368fe72355df5f1703e44411adbe49bba5644b941ce6f2e3a", size = 214194, upload-time = "2025-05-23T11:38:23.571Z" }, { url = "https://files.pythonhosted.org/packages/f6/8f/a543121f9f5f150eae092b08428cb4e6b6d2d134152c3357b77659d2a605/coverage-7.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:8ab4a51cb39dc1933ba627e0875046d150e88478dbe22ce145a68393e9652975", size = 215109, upload-time = "2025-05-23T11:38:25.137Z" }, { url = "https://files.pythonhosted.org/packages/77/65/6cc84b68d4f35186463cd7ab1da1169e9abb59870c0f6a57ea6aba95f861/coverage-7.8.2-cp311-cp311-win_arm64.whl", hash = "sha256:8966a821e2083c74d88cca5b7dcccc0a3a888a596a04c0b9668a891de3a0cc53", size = 213521, upload-time = "2025-05-23T11:38:27.123Z" }, { url = "https://files.pythonhosted.org/packages/8d/2a/1da1ada2e3044fcd4a3254fb3576e160b8fe5b36d705c8a31f793423f763/coverage-7.8.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2f6fe3654468d061942591aef56686131335b7a8325684eda85dacdf311356c", size = 211876, upload-time = "2025-05-23T11:38:29.01Z" }, { url = "https://files.pythonhosted.org/packages/70/e9/3d715ffd5b6b17a8be80cd14a8917a002530a99943cc1939ad5bb2aa74b9/coverage-7.8.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76090fab50610798cc05241bf83b603477c40ee87acd358b66196ab0ca44ffa1", size = 212130, upload-time = "2025-05-23T11:38:30.675Z" }, { url = "https://files.pythonhosted.org/packages/a0/02/fdce62bb3c21649abfd91fbdcf041fb99be0d728ff00f3f9d54d97ed683e/coverage-7.8.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bd0a0a5054be160777a7920b731a0570284db5142abaaf81bcbb282b8d99279", size = 246176, upload-time = "2025-05-23T11:38:32.395Z" }, { url = "https://files.pythonhosted.org/packages/a7/52/decbbed61e03b6ffe85cd0fea360a5e04a5a98a7423f292aae62423b8557/coverage-7.8.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da23ce9a3d356d0affe9c7036030b5c8f14556bd970c9b224f9c8205505e3b99", size = 243068, upload-time = "2025-05-23T11:38:33.989Z" }, { url = "https://files.pythonhosted.org/packages/38/6c/d0e9c0cce18faef79a52778219a3c6ee8e336437da8eddd4ab3dbd8fadff/coverage-7.8.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9392773cffeb8d7e042a7b15b82a414011e9d2b5fdbbd3f7e6a6b17d5e21b20", size = 245328, upload-time = "2025-05-23T11:38:35.568Z" }, { url = "https://files.pythonhosted.org/packages/f0/70/f703b553a2f6b6c70568c7e398ed0789d47f953d67fbba36a327714a7bca/coverage-7.8.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:876cbfd0b09ce09d81585d266c07a32657beb3eaec896f39484b631555be0fe2", size = 245099, upload-time = "2025-05-23T11:38:37.627Z" }, { url = "https://files.pythonhosted.org/packages/ec/fb/4cbb370dedae78460c3aacbdad9d249e853f3bc4ce5ff0e02b1983d03044/coverage-7.8.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3da9b771c98977a13fbc3830f6caa85cae6c9c83911d24cb2d218e9394259c57", size = 243314, upload-time = "2025-05-23T11:38:39.238Z" }, { url = "https://files.pythonhosted.org/packages/39/9f/1afbb2cb9c8699b8bc38afdce00a3b4644904e6a38c7bf9005386c9305ec/coverage-7.8.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a990f6510b3292686713bfef26d0049cd63b9c7bb17e0864f133cbfd2e6167f", size = 244489, upload-time = "2025-05-23T11:38:40.845Z" }, { url = "https://files.pythonhosted.org/packages/79/fa/f3e7ec7d220bff14aba7a4786ae47043770cbdceeea1803083059c878837/coverage-7.8.2-cp312-cp312-win32.whl", hash = "sha256:bf8111cddd0f2b54d34e96613e7fbdd59a673f0cf5574b61134ae75b6f5a33b8", size = 214366, upload-time = "2025-05-23T11:38:43.551Z" }, { url = "https://files.pythonhosted.org/packages/54/aa/9cbeade19b7e8e853e7ffc261df885d66bf3a782c71cba06c17df271f9e6/coverage-7.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:86a323a275e9e44cdf228af9b71c5030861d4d2610886ab920d9945672a81223", size = 215165, upload-time = "2025-05-23T11:38:45.148Z" }, { url = "https://files.pythonhosted.org/packages/c4/73/e2528bf1237d2448f882bbebaec5c3500ef07301816c5c63464b9da4d88a/coverage-7.8.2-cp312-cp312-win_arm64.whl", hash = "sha256:820157de3a589e992689ffcda8639fbabb313b323d26388d02e154164c57b07f", size = 213548, upload-time = "2025-05-23T11:38:46.74Z" }, { url = "https://files.pythonhosted.org/packages/1a/93/eb6400a745ad3b265bac36e8077fdffcf0268bdbbb6c02b7220b624c9b31/coverage-7.8.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ea561010914ec1c26ab4188aef8b1567272ef6de096312716f90e5baa79ef8ca", size = 211898, upload-time = "2025-05-23T11:38:49.066Z" }, { url = "https://files.pythonhosted.org/packages/1b/7c/bdbf113f92683024406a1cd226a199e4200a2001fc85d6a6e7e299e60253/coverage-7.8.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cb86337a4fcdd0e598ff2caeb513ac604d2f3da6d53df2c8e368e07ee38e277d", size = 212171, upload-time = "2025-05-23T11:38:51.207Z" }, { url = "https://files.pythonhosted.org/packages/91/22/594513f9541a6b88eb0dba4d5da7d71596dadef6b17a12dc2c0e859818a9/coverage-7.8.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26a4636ddb666971345541b59899e969f3b301143dd86b0ddbb570bd591f1e85", size = 245564, upload-time = "2025-05-23T11:38:52.857Z" }, { url = "https://files.pythonhosted.org/packages/1f/f4/2860fd6abeebd9f2efcfe0fd376226938f22afc80c1943f363cd3c28421f/coverage-7.8.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5040536cf9b13fb033f76bcb5e1e5cb3b57c4807fef37db9e0ed129c6a094257", size = 242719, upload-time = "2025-05-23T11:38:54.529Z" }, { url = "https://files.pythonhosted.org/packages/89/60/f5f50f61b6332451520e6cdc2401700c48310c64bc2dd34027a47d6ab4ca/coverage-7.8.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc67994df9bcd7e0150a47ef41278b9e0a0ea187caba72414b71dc590b99a108", size = 244634, upload-time = "2025-05-23T11:38:57.326Z" }, { url = "https://files.pythonhosted.org/packages/3b/70/7f4e919039ab7d944276c446b603eea84da29ebcf20984fb1fdf6e602028/coverage-7.8.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e6c86888fd076d9e0fe848af0a2142bf606044dc5ceee0aa9eddb56e26895a0", size = 244824, upload-time = "2025-05-23T11:38:59.421Z" }, { url = "https://files.pythonhosted.org/packages/26/45/36297a4c0cea4de2b2c442fe32f60c3991056c59cdc3cdd5346fbb995c97/coverage-7.8.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:684ca9f58119b8e26bef860db33524ae0365601492e86ba0b71d513f525e7050", size = 242872, upload-time = "2025-05-23T11:39:01.049Z" }, { url = "https://files.pythonhosted.org/packages/a4/71/e041f1b9420f7b786b1367fa2a375703889ef376e0d48de9f5723fb35f11/coverage-7.8.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8165584ddedb49204c4e18da083913bdf6a982bfb558632a79bdaadcdafd0d48", size = 244179, upload-time = "2025-05-23T11:39:02.709Z" }, { url = "https://files.pythonhosted.org/packages/bd/db/3c2bf49bdc9de76acf2491fc03130c4ffc51469ce2f6889d2640eb563d77/coverage-7.8.2-cp313-cp313-win32.whl", hash = "sha256:34759ee2c65362163699cc917bdb2a54114dd06d19bab860725f94ef45a3d9b7", size = 214393, upload-time = "2025-05-23T11:39:05.457Z" }, { url = "https://files.pythonhosted.org/packages/c6/dc/947e75d47ebbb4b02d8babb1fad4ad381410d5bc9da7cfca80b7565ef401/coverage-7.8.2-cp313-cp313-win_amd64.whl", hash = "sha256:2f9bc608fbafaee40eb60a9a53dbfb90f53cc66d3d32c2849dc27cf5638a21e3", size = 215194, upload-time = "2025-05-23T11:39:07.171Z" }, { url = "https://files.pythonhosted.org/packages/90/31/a980f7df8a37eaf0dc60f932507fda9656b3a03f0abf188474a0ea188d6d/coverage-7.8.2-cp313-cp313-win_arm64.whl", hash = "sha256:9fe449ee461a3b0c7105690419d0b0aba1232f4ff6d120a9e241e58a556733f7", size = 213580, upload-time = "2025-05-23T11:39:08.862Z" }, { url = "https://files.pythonhosted.org/packages/8a/6a/25a37dd90f6c95f59355629417ebcb74e1c34e38bb1eddf6ca9b38b0fc53/coverage-7.8.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8369a7c8ef66bded2b6484053749ff220dbf83cba84f3398c84c51a6f748a008", size = 212734, upload-time = "2025-05-23T11:39:11.109Z" }, { url = "https://files.pythonhosted.org/packages/36/8b/3a728b3118988725f40950931abb09cd7f43b3c740f4640a59f1db60e372/coverage-7.8.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:159b81df53a5fcbc7d45dae3adad554fdbde9829a994e15227b3f9d816d00b36", size = 212959, upload-time = "2025-05-23T11:39:12.751Z" }, { url = "https://files.pythonhosted.org/packages/53/3c/212d94e6add3a3c3f412d664aee452045ca17a066def8b9421673e9482c4/coverage-7.8.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e6fcbbd35a96192d042c691c9e0c49ef54bd7ed865846a3c9d624c30bb67ce46", size = 257024, upload-time = "2025-05-23T11:39:15.569Z" }, { url = "https://files.pythonhosted.org/packages/a4/40/afc03f0883b1e51bbe804707aae62e29c4e8c8bbc365c75e3e4ddeee9ead/coverage-7.8.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05364b9cc82f138cc86128dc4e2e1251c2981a2218bfcd556fe6b0fbaa3501be", size = 252867, upload-time = "2025-05-23T11:39:17.64Z" }, { url = "https://files.pythonhosted.org/packages/18/a2/3699190e927b9439c6ded4998941a3c1d6fa99e14cb28d8536729537e307/coverage-7.8.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46d532db4e5ff3979ce47d18e2fe8ecad283eeb7367726da0e5ef88e4fe64740", size = 255096, upload-time = "2025-05-23T11:39:19.328Z" }, { url = "https://files.pythonhosted.org/packages/b4/06/16e3598b9466456b718eb3e789457d1a5b8bfb22e23b6e8bbc307df5daf0/coverage-7.8.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4000a31c34932e7e4fa0381a3d6deb43dc0c8f458e3e7ea6502e6238e10be625", size = 256276, upload-time = "2025-05-23T11:39:21.077Z" }, { url = "https://files.pythonhosted.org/packages/a7/d5/4b5a120d5d0223050a53d2783c049c311eea1709fa9de12d1c358e18b707/coverage-7.8.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:43ff5033d657cd51f83015c3b7a443287250dc14e69910577c3e03bd2e06f27b", size = 254478, upload-time = "2025-05-23T11:39:22.838Z" }, { url = "https://files.pythonhosted.org/packages/ba/85/f9ecdb910ecdb282b121bfcaa32fa8ee8cbd7699f83330ee13ff9bbf1a85/coverage-7.8.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94316e13f0981cbbba132c1f9f365cac1d26716aaac130866ca812006f662199", size = 255255, upload-time = "2025-05-23T11:39:24.644Z" }, { url = "https://files.pythonhosted.org/packages/50/63/2d624ac7d7ccd4ebbd3c6a9eba9d7fc4491a1226071360d59dd84928ccb2/coverage-7.8.2-cp313-cp313t-win32.whl", hash = "sha256:3f5673888d3676d0a745c3d0e16da338c5eea300cb1f4ada9c872981265e76d8", size = 215109, upload-time = "2025-05-23T11:39:26.722Z" }, { url = "https://files.pythonhosted.org/packages/22/5e/7053b71462e970e869111c1853afd642212568a350eba796deefdfbd0770/coverage-7.8.2-cp313-cp313t-win_amd64.whl", hash = "sha256:2c08b05ee8d7861e45dc5a2cc4195c8c66dca5ac613144eb6ebeaff2d502e73d", size = 216268, upload-time = "2025-05-23T11:39:28.429Z" }, { url = "https://files.pythonhosted.org/packages/07/69/afa41aa34147655543dbe96994f8a246daf94b361ccf5edfd5df62ce066a/coverage-7.8.2-cp313-cp313t-win_arm64.whl", hash = "sha256:1e1448bb72b387755e1ff3ef1268a06617afd94188164960dba8d0245a46004b", size = 214071, upload-time = "2025-05-23T11:39:30.55Z" }, { url = "https://files.pythonhosted.org/packages/71/1e/388267ad9c6aa126438acc1ceafede3bb746afa9872e3ec5f0691b7d5efa/coverage-7.8.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:496948261eaac5ac9cf43f5d0a9f6eb7a6d4cb3bedb2c5d294138142f5c18f2a", size = 211566, upload-time = "2025-05-23T11:39:32.333Z" }, { url = "https://files.pythonhosted.org/packages/8f/a5/acc03e5cf0bba6357f5e7c676343de40fbf431bb1e115fbebf24b2f7f65e/coverage-7.8.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:eacd2de0d30871eff893bab0b67840a96445edcb3c8fd915e6b11ac4b2f3fa6d", size = 211996, upload-time = "2025-05-23T11:39:34.512Z" }, { url = "https://files.pythonhosted.org/packages/5b/a2/0fc0a9f6b7c24fa4f1d7210d782c38cb0d5e692666c36eaeae9a441b6755/coverage-7.8.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b039ffddc99ad65d5078ef300e0c7eed08c270dc26570440e3ef18beb816c1ca", size = 240741, upload-time = "2025-05-23T11:39:36.252Z" }, { url = "https://files.pythonhosted.org/packages/e6/da/1c6ba2cf259710eed8916d4fd201dccc6be7380ad2b3b9f63ece3285d809/coverage-7.8.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e49824808d4375ede9dd84e9961a59c47f9113039f1a525e6be170aa4f5c34d", size = 238672, upload-time = "2025-05-23T11:39:38.03Z" }, { url = "https://files.pythonhosted.org/packages/ac/51/c8fae0dc3ca421e6e2509503696f910ff333258db672800c3bdef256265a/coverage-7.8.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b069938961dfad881dc2f8d02b47645cd2f455d3809ba92a8a687bf513839787", size = 239769, upload-time = "2025-05-23T11:39:40.24Z" }, { url = "https://files.pythonhosted.org/packages/59/8e/b97042ae92c59f40be0c989df090027377ba53f2d6cef73c9ca7685c26a6/coverage-7.8.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:de77c3ba8bb686d1c411e78ee1b97e6e0b963fb98b1637658dd9ad2c875cf9d7", size = 239555, upload-time = "2025-05-23T11:39:42.3Z" }, { url = "https://files.pythonhosted.org/packages/47/35/b8893e682d6e96b1db2af5997fc13ef62219426fb17259d6844c693c5e00/coverage-7.8.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:1676628065a498943bd3f64f099bb573e08cf1bc6088bbe33cf4424e0876f4b3", size = 237768, upload-time = "2025-05-23T11:39:44.069Z" }, { url = "https://files.pythonhosted.org/packages/03/6c/023b0b9a764cb52d6243a4591dcb53c4caf4d7340445113a1f452bb80591/coverage-7.8.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:8e1a26e7e50076e35f7afafde570ca2b4d7900a491174ca357d29dece5aacee7", size = 238757, upload-time = "2025-05-23T11:39:46.195Z" }, { url = "https://files.pythonhosted.org/packages/03/ed/3af7e4d721bd61a8df7de6de9e8a4271e67f3d9e086454558fd9f48eb4f6/coverage-7.8.2-cp39-cp39-win32.whl", hash = "sha256:6782a12bf76fa61ad9350d5a6ef5f3f020b57f5e6305cbc663803f2ebd0f270a", size = 214166, upload-time = "2025-05-23T11:39:47.934Z" }, { url = "https://files.pythonhosted.org/packages/9d/30/ee774b626773750dc6128354884652507df3c59d6aa8431526107e595227/coverage-7.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:1efa4166ba75ccefd647f2d78b64f53f14fb82622bc94c5a5cb0a622f50f1c9e", size = 215050, upload-time = "2025-05-23T11:39:50.252Z" }, { url = "https://files.pythonhosted.org/packages/69/2f/572b29496d8234e4a7773200dd835a0d32d9e171f2d974f3fe04a9dbc271/coverage-7.8.2-pp39.pp310.pp311-none-any.whl", hash = "sha256:ec455eedf3ba0bbdf8f5a570012617eb305c63cb9f03428d39bf544cb2b94837", size = 203636, upload-time = "2025-05-23T11:39:52.002Z" }, { url = "https://files.pythonhosted.org/packages/a0/1a/0b9c32220ad694d66062f571cc5cedfa9997b64a591e8a500bb63de1bd40/coverage-7.8.2-py3-none-any.whl", hash = "sha256:726f32ee3713f7359696331a18daf0c3b3a70bb0ae71141b9d3c52be7c595e32", size = 203623, upload-time = "2025-05-23T11:39:53.846Z" }, ] [package.optional-dependencies] toml = [ { name = "tomli", marker = "python_full_version <= '3.11'" }, ] [[package]] name = "docutils" version = "0.21.2" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444, upload-time = "2024-04-23T18:57:18.24Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408, upload-time = "2024-04-23T18:57:14.835Z" }, ] [[package]] name = "exceptiongroup" version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "typing-extensions", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" }, ] [[package]] name = "furo" version = "2025.7.19" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "accessible-pygments" }, { name = "beautifulsoup4" }, { name = "pygments" }, { name = "sphinx", version = "7.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "sphinx-basic-ng" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d0/69/312cd100fa45ddaea5a588334d2defa331ff427bcb61f5fe2ae61bdc3762/furo-2025.7.19.tar.gz", hash = "sha256:4164b2cafcf4023a59bb3c594e935e2516f6b9d35e9a5ea83d8f6b43808fe91f", size = 1662054, upload-time = "2025-07-19T10:52:09.754Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/3a/34/2b07b72bee02a63241d654f5d8af87a2de977c59638eec41ca356ab915cd/furo-2025.7.19-py3-none-any.whl", hash = "sha256:bdea869822dfd2b494ea84c0973937e35d1575af088b6721a29c7f7878adc9e3", size = 342175, upload-time = "2025-07-19T10:52:02.399Z" }, ] [[package]] name = "idna" version = "3.10" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" }, ] [[package]] name = "imagesize" version = "1.4.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" }, ] [[package]] name = "importlib-metadata" version = "8.7.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "zipp", marker = "python_full_version < '3.10'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" }, ] [[package]] name = "iniconfig" version = "2.1.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" }, ] [[package]] name = "jinja2" version = "3.1.6" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "markupsafe" }, ] sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, ] [[package]] name = "markupsafe" version = "3.0.2" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357, upload-time = "2024-10-18T15:20:51.44Z" }, { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393, upload-time = "2024-10-18T15:20:52.426Z" }, { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732, upload-time = "2024-10-18T15:20:53.578Z" }, { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866, upload-time = "2024-10-18T15:20:55.06Z" }, { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964, upload-time = "2024-10-18T15:20:55.906Z" }, { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977, upload-time = "2024-10-18T15:20:57.189Z" }, { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366, upload-time = "2024-10-18T15:20:58.235Z" }, { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091, upload-time = "2024-10-18T15:20:59.235Z" }, { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065, upload-time = "2024-10-18T15:21:00.307Z" }, { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514, upload-time = "2024-10-18T15:21:01.122Z" }, { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353, upload-time = "2024-10-18T15:21:02.187Z" }, { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392, upload-time = "2024-10-18T15:21:02.941Z" }, { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984, upload-time = "2024-10-18T15:21:03.953Z" }, { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120, upload-time = "2024-10-18T15:21:06.495Z" }, { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032, upload-time = "2024-10-18T15:21:07.295Z" }, { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057, upload-time = "2024-10-18T15:21:08.073Z" }, { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359, upload-time = "2024-10-18T15:21:09.318Z" }, { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306, upload-time = "2024-10-18T15:21:10.185Z" }, { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094, upload-time = "2024-10-18T15:21:11.005Z" }, { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521, upload-time = "2024-10-18T15:21:12.911Z" }, { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" }, { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" }, { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" }, { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" }, { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" }, { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" }, { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" }, { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" }, { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" }, { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" }, { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" }, { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" }, { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" }, { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" }, { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" }, { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" }, { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" }, { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" }, { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" }, { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" }, { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" }, { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" }, { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" }, { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" }, { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" }, { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" }, { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" }, { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" }, { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" }, { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" }, { url = "https://files.pythonhosted.org/packages/a7/ea/9b1530c3fdeeca613faeb0fb5cbcf2389d816072fab72a71b45749ef6062/MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a", size = 14344, upload-time = "2024-10-18T15:21:43.721Z" }, { url = "https://files.pythonhosted.org/packages/4b/c2/fbdbfe48848e7112ab05e627e718e854d20192b674952d9042ebd8c9e5de/MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff", size = 12389, upload-time = "2024-10-18T15:21:44.666Z" }, { url = "https://files.pythonhosted.org/packages/f0/25/7a7c6e4dbd4f867d95d94ca15449e91e52856f6ed1905d58ef1de5e211d0/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13", size = 21607, upload-time = "2024-10-18T15:21:45.452Z" }, { url = "https://files.pythonhosted.org/packages/53/8f/f339c98a178f3c1e545622206b40986a4c3307fe39f70ccd3d9df9a9e425/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144", size = 20728, upload-time = "2024-10-18T15:21:46.295Z" }, { url = "https://files.pythonhosted.org/packages/1a/03/8496a1a78308456dbd50b23a385c69b41f2e9661c67ea1329849a598a8f9/MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29", size = 20826, upload-time = "2024-10-18T15:21:47.134Z" }, { url = "https://files.pythonhosted.org/packages/e6/cf/0a490a4bd363048c3022f2f475c8c05582179bb179defcee4766fb3dcc18/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0", size = 21843, upload-time = "2024-10-18T15:21:48.334Z" }, { url = "https://files.pythonhosted.org/packages/19/a3/34187a78613920dfd3cdf68ef6ce5e99c4f3417f035694074beb8848cd77/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0", size = 21219, upload-time = "2024-10-18T15:21:49.587Z" }, { url = "https://files.pythonhosted.org/packages/17/d8/5811082f85bb88410ad7e452263af048d685669bbbfb7b595e8689152498/MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178", size = 20946, upload-time = "2024-10-18T15:21:50.441Z" }, { url = "https://files.pythonhosted.org/packages/7c/31/bd635fb5989440d9365c5e3c47556cfea121c7803f5034ac843e8f37c2f2/MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f", size = 15063, upload-time = "2024-10-18T15:21:51.385Z" }, { url = "https://files.pythonhosted.org/packages/b3/73/085399401383ce949f727afec55ec3abd76648d04b9f22e1c0e99cb4bec3/MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a", size = 15506, upload-time = "2024-10-18T15:21:52.974Z" }, ] [[package]] name = "packaging" version = "25.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, ] [[package]] name = "pluggy" version = "1.6.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] [[package]] name = "pygments" version = "2.19.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581, upload-time = "2025-01-06T17:26:30.443Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293, upload-time = "2025-01-06T17:26:25.553Z" }, ] [[package]] name = "pytest" version = "8.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "iniconfig" }, { name = "packaging" }, { name = "pluggy" }, { name = "pygments" }, { name = "tomli", marker = "python_full_version < '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fb/aa/405082ce2749be5398045152251ac69c0f3578c7077efc53431303af97ce/pytest-8.4.0.tar.gz", hash = "sha256:14d920b48472ea0dbf68e45b96cd1ffda4705f33307dcc86c676c1b5104838a6", size = 1515232, upload-time = "2025-06-02T17:36:30.03Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/2f/de/afa024cbe022b1b318a3d224125aa24939e99b4ff6f22e0ba639a2eaee47/pytest-8.4.0-py3-none-any.whl", hash = "sha256:f40f825768ad76c0977cbacdf1fd37c6f7a468e460ea6a0636078f8972d4517e", size = 363797, upload-time = "2025-06-02T17:36:27.859Z" }, ] [[package]] name = "pytest-randomly" version = "3.16.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, { name = "pytest" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c0/68/d221ed7f4a2a49a664da721b8e87b52af6dd317af2a6cb51549cf17ac4b8/pytest_randomly-3.16.0.tar.gz", hash = "sha256:11bf4d23a26484de7860d82f726c0629837cf4064b79157bd18ec9d41d7feb26", size = 13367, upload-time = "2024-10-25T15:45:34.274Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/22/70/b31577d7c46d8e2f9baccfed5067dd8475262a2331ffb0bfdf19361c9bde/pytest_randomly-3.16.0-py3-none-any.whl", hash = "sha256:8633d332635a1a0983d3bba19342196807f6afb17c3eef78e02c2f85dade45d6", size = 8396, upload-time = "2024-10-25T15:45:32.78Z" }, ] [[package]] name = "python-dateutil" version = "2.9.0.post0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "six" }, ] sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, ] [[package]] name = "requests" version = "2.32.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "certifi" }, { name = "charset-normalizer" }, { name = "idna" }, { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258, upload-time = "2025-06-09T16:43:07.34Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847, upload-time = "2025-06-09T16:43:05.728Z" }, ] [[package]] name = "roman-numerals-py" version = "3.1.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/30/76/48fd56d17c5bdbdf65609abbc67288728a98ed4c02919428d4f52d23b24b/roman_numerals_py-3.1.0.tar.gz", hash = "sha256:be4bf804f083a4ce001b5eb7e3c0862479d10f94c936f6c4e5f250aa5ff5bd2d", size = 9017, upload-time = "2025-02-22T07:34:54.333Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/53/97/d2cbbaa10c9b826af0e10fdf836e1bf344d9f0abb873ebc34d1f49642d3f/roman_numerals_py-3.1.0-py3-none-any.whl", hash = "sha256:9da2ad2fb670bcf24e81070ceb3be72f6c11c440d73bd579fbeca1e9f330954c", size = 7742, upload-time = "2025-02-22T07:34:52.422Z" }, ] [[package]] name = "six" version = "1.17.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] [[package]] name = "snowballstemmer" version = "3.0.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/75/a7/9810d872919697c9d01295633f5d574fb416d47e535f258272ca1f01f447/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895", size = 105575, upload-time = "2025-05-09T16:34:51.843Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/c8/78/3565d011c61f5a43488987ee32b6f3f656e7f107ac2782dd57bdd7d91d9a/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064", size = 103274, upload-time = "2025-05-09T16:34:50.371Z" }, ] [[package]] name = "soupsieve" version = "2.7" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/3f/f4/4a80cd6ef364b2e8b65b15816a843c0980f7a5a2b4dc701fc574952aa19f/soupsieve-2.7.tar.gz", hash = "sha256:ad282f9b6926286d2ead4750552c8a6142bc4c783fd66b0293547c8fe6ae126a", size = 103418, upload-time = "2025-04-20T18:50:08.518Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload-time = "2025-04-20T18:50:07.196Z" }, ] [[package]] name = "sphinx" version = "7.4.7" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version < '3.10'", ] dependencies = [ { name = "alabaster", version = "0.7.16", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "babel", marker = "python_full_version < '3.10'" }, { name = "colorama", marker = "python_full_version < '3.10' and sys_platform == 'win32'" }, { name = "docutils", marker = "python_full_version < '3.10'" }, { name = "imagesize", marker = "python_full_version < '3.10'" }, { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, { name = "jinja2", marker = "python_full_version < '3.10'" }, { name = "packaging", marker = "python_full_version < '3.10'" }, { name = "pygments", marker = "python_full_version < '3.10'" }, { name = "requests", marker = "python_full_version < '3.10'" }, { name = "snowballstemmer", marker = "python_full_version < '3.10'" }, { name = "sphinxcontrib-applehelp", marker = "python_full_version < '3.10'" }, { name = "sphinxcontrib-devhelp", marker = "python_full_version < '3.10'" }, { name = "sphinxcontrib-htmlhelp", marker = "python_full_version < '3.10'" }, { name = "sphinxcontrib-jsmath", marker = "python_full_version < '3.10'" }, { name = "sphinxcontrib-qthelp", marker = "python_full_version < '3.10'" }, { name = "sphinxcontrib-serializinghtml", marker = "python_full_version < '3.10'" }, { name = "tomli", marker = "python_full_version < '3.10'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5b/be/50e50cb4f2eff47df05673d361095cafd95521d2a22521b920c67a372dcb/sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe", size = 8067911, upload-time = "2024-07-20T14:46:56.059Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/0d/ef/153f6803c5d5f8917dbb7f7fcf6d34a871ede3296fa89c2c703f5f8a6c8e/sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239", size = 3401624, upload-time = "2024-07-20T14:46:52.142Z" }, ] [[package]] name = "sphinx" version = "8.1.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version == '3.10.*'", ] dependencies = [ { name = "alabaster", version = "1.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, { name = "babel", marker = "python_full_version == '3.10.*'" }, { name = "colorama", marker = "python_full_version == '3.10.*' and sys_platform == 'win32'" }, { name = "docutils", marker = "python_full_version == '3.10.*'" }, { name = "imagesize", marker = "python_full_version == '3.10.*'" }, { name = "jinja2", marker = "python_full_version == '3.10.*'" }, { name = "packaging", marker = "python_full_version == '3.10.*'" }, { name = "pygments", marker = "python_full_version == '3.10.*'" }, { name = "requests", marker = "python_full_version == '3.10.*'" }, { name = "snowballstemmer", marker = "python_full_version == '3.10.*'" }, { name = "sphinxcontrib-applehelp", marker = "python_full_version == '3.10.*'" }, { name = "sphinxcontrib-devhelp", marker = "python_full_version == '3.10.*'" }, { name = "sphinxcontrib-htmlhelp", marker = "python_full_version == '3.10.*'" }, { name = "sphinxcontrib-jsmath", marker = "python_full_version == '3.10.*'" }, { name = "sphinxcontrib-qthelp", marker = "python_full_version == '3.10.*'" }, { name = "sphinxcontrib-serializinghtml", marker = "python_full_version == '3.10.*'" }, { name = "tomli", marker = "python_full_version == '3.10.*'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611, upload-time = "2024-10-13T20:27:13.93Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125, upload-time = "2024-10-13T20:27:10.448Z" }, ] [[package]] name = "sphinx" version = "8.2.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.11'", ] dependencies = [ { name = "alabaster", version = "1.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "babel", marker = "python_full_version >= '3.11'" }, { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, { name = "docutils", marker = "python_full_version >= '3.11'" }, { name = "imagesize", marker = "python_full_version >= '3.11'" }, { name = "jinja2", marker = "python_full_version >= '3.11'" }, { name = "packaging", marker = "python_full_version >= '3.11'" }, { name = "pygments", marker = "python_full_version >= '3.11'" }, { name = "requests", marker = "python_full_version >= '3.11'" }, { name = "roman-numerals-py", marker = "python_full_version >= '3.11'" }, { name = "snowballstemmer", marker = "python_full_version >= '3.11'" }, { name = "sphinxcontrib-applehelp", marker = "python_full_version >= '3.11'" }, { name = "sphinxcontrib-devhelp", marker = "python_full_version >= '3.11'" }, { name = "sphinxcontrib-htmlhelp", marker = "python_full_version >= '3.11'" }, { name = "sphinxcontrib-jsmath", marker = "python_full_version >= '3.11'" }, { name = "sphinxcontrib-qthelp", marker = "python_full_version >= '3.11'" }, { name = "sphinxcontrib-serializinghtml", marker = "python_full_version >= '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/38/ad/4360e50ed56cb483667b8e6dadf2d3fda62359593faabbe749a27c4eaca6/sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348", size = 8321876, upload-time = "2025-03-02T22:31:59.658Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/31/53/136e9eca6e0b9dc0e1962e2c908fbea2e5ac000c2a2fbd9a35797958c48b/sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3", size = 3589741, upload-time = "2025-03-02T22:31:56.836Z" }, ] [[package]] name = "sphinx-basic-ng" version = "1.0.0b2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "sphinx", version = "7.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/98/0b/a866924ded68efec7a1759587a4e478aec7559d8165fac8b2ad1c0e774d6/sphinx_basic_ng-1.0.0b2.tar.gz", hash = "sha256:9ec55a47c90c8c002b5960c57492ec3021f5193cb26cebc2dc4ea226848651c9", size = 20736, upload-time = "2023-07-08T18:40:54.166Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/3c/dd/018ce05c532a22007ac58d4f45232514cd9d6dd0ee1dc374e309db830983/sphinx_basic_ng-1.0.0b2-py3-none-any.whl", hash = "sha256:eb09aedbabfb650607e9b4b68c9d240b90b1e1be221d6ad71d61c52e29f7932b", size = 22496, upload-time = "2023-07-08T18:40:52.659Z" }, ] [[package]] name = "sphinx-build-compatibility" version = "0.0.1" source = { git = "https://github.com/readthedocs/sphinx-build-compatibility?rev=4f304bd4562cdc96316f4fec82b264ca379d23e0#4f304bd4562cdc96316f4fec82b264ca379d23e0" } dependencies = [ { name = "requests" }, { name = "sphinx", version = "7.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, ] [[package]] name = "sphinx-copybutton" version = "0.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "sphinx", version = "7.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fc/2b/a964715e7f5295f77509e59309959f4125122d648f86b4fe7d70ca1d882c/sphinx-copybutton-0.5.2.tar.gz", hash = "sha256:4cf17c82fb9646d1bc9ca92ac280813a3b605d8c421225fd9913154103ee1fbd", size = 23039, upload-time = "2023-04-14T08:10:22.998Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/9e/48/1ea60e74949eecb12cdd6ac43987f9fd331156388dcc2319b45e2ebb81bf/sphinx_copybutton-0.5.2-py3-none-any.whl", hash = "sha256:fb543fd386d917746c9a2c50360c7905b605726b9355cd26e9974857afeae06e", size = 13343, upload-time = "2023-04-14T08:10:20.844Z" }, ] [[package]] name = "sphinxcontrib-applehelp" version = "2.0.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, ] [[package]] name = "sphinxcontrib-devhelp" version = "2.0.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, ] [[package]] name = "sphinxcontrib-htmlhelp" version = "2.1.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, ] [[package]] name = "sphinxcontrib-jsmath" version = "1.0.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, ] [[package]] name = "sphinxcontrib-qthelp" version = "2.0.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, ] [[package]] name = "sphinxcontrib-serializinghtml" version = "2.0.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, ] [[package]] name = "time-machine" version = "2.17.0" source = { editable = "." } dependencies = [ { name = "python-dateutil" }, ] [package.optional-dependencies] cli = [ { name = "tokenize-rt" }, ] [package.dev-dependencies] docs = [ { name = "furo" }, { name = "sphinx", version = "7.4.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "sphinx-build-compatibility" }, { name = "sphinx-copybutton" }, ] test = [ { name = "coverage", extra = ["toml"] }, { name = "pytest" }, { name = "pytest-randomly" }, { name = "python-dateutil" }, ] [package.metadata] requires-dist = [ { name = "python-dateutil" }, { name = "tokenize-rt", marker = "extra == 'cli'" }, ] provides-extras = ["cli"] [package.metadata.requires-dev] docs = [ { name = "furo", specifier = ">=2024.8.6" }, { name = "sphinx", specifier = ">=7.4.7" }, { name = "sphinx-build-compatibility", git = "https://github.com/readthedocs/sphinx-build-compatibility?rev=4f304bd4562cdc96316f4fec82b264ca379d23e0" }, { name = "sphinx-copybutton", specifier = ">=0.5.2" }, ] test = [ { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" }, { name = "coverage", extras = ["toml"] }, { name = "pytest" }, { name = "pytest-randomly" }, { name = "python-dateutil" }, ] [[package]] name = "tokenize-rt" version = "6.2.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/69/ed/8f07e893132d5051d86a553e749d5c89b2a4776eb3a579b72ed61f8559ca/tokenize_rt-6.2.0.tar.gz", hash = "sha256:8439c042b330c553fdbe1758e4a05c0ed460dbbbb24a606f11f0dee75da4cad6", size = 5476, upload-time = "2025-05-23T23:48:00.035Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/33/f0/3fe8c6e69135a845f4106f2ff8b6805638d4e85c264e70114e8126689587/tokenize_rt-6.2.0-py2.py3-none-any.whl", hash = "sha256:a152bf4f249c847a66497a4a95f63376ed68ac6abf092a2f7cfb29d044ecff44", size = 6004, upload-time = "2025-05-23T23:47:58.812Z" }, ] [[package]] name = "tomli" version = "2.2.1" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload-time = "2024-11-27T22:38:36.873Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload-time = "2024-11-27T22:37:54.956Z" }, { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload-time = "2024-11-27T22:37:56.698Z" }, { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload-time = "2024-11-27T22:37:57.63Z" }, { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload-time = "2024-11-27T22:37:59.344Z" }, { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload-time = "2024-11-27T22:38:00.429Z" }, { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload-time = "2024-11-27T22:38:02.094Z" }, { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload-time = "2024-11-27T22:38:03.206Z" }, { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload-time = "2024-11-27T22:38:04.217Z" }, { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload-time = "2024-11-27T22:38:05.908Z" }, { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload-time = "2024-11-27T22:38:06.812Z" }, { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload-time = "2024-11-27T22:38:07.731Z" }, { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload-time = "2024-11-27T22:38:09.384Z" }, { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload-time = "2024-11-27T22:38:10.329Z" }, { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload-time = "2024-11-27T22:38:11.443Z" }, { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload-time = "2024-11-27T22:38:13.099Z" }, { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload-time = "2024-11-27T22:38:14.766Z" }, { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload-time = "2024-11-27T22:38:15.843Z" }, { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload-time = "2024-11-27T22:38:17.645Z" }, { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload-time = "2024-11-27T22:38:19.159Z" }, { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload-time = "2024-11-27T22:38:20.064Z" }, { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708, upload-time = "2024-11-27T22:38:21.659Z" }, { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582, upload-time = "2024-11-27T22:38:22.693Z" }, { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543, upload-time = "2024-11-27T22:38:24.367Z" }, { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691, upload-time = "2024-11-27T22:38:26.081Z" }, { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170, upload-time = "2024-11-27T22:38:27.921Z" }, { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530, upload-time = "2024-11-27T22:38:29.591Z" }, { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666, upload-time = "2024-11-27T22:38:30.639Z" }, { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954, upload-time = "2024-11-27T22:38:31.702Z" }, { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724, upload-time = "2024-11-27T22:38:32.837Z" }, { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383, upload-time = "2024-11-27T22:38:34.455Z" }, { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" }, ] [[package]] name = "typing-extensions" version = "4.14.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/d1/bc/51647cd02527e87d05cb083ccc402f93e441606ff1f01739a62c8ad09ba5/typing_extensions-4.14.0.tar.gz", hash = "sha256:8676b788e32f02ab42d9e7c61324048ae4c6d844a399eebace3d4979d75ceef4", size = 107423, upload-time = "2025-06-02T14:52:11.399Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl", hash = "sha256:a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af", size = 43839, upload-time = "2025-06-02T14:52:10.026Z" }, ] [[package]] name = "urllib3" version = "2.5.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" }, ] [[package]] name = "zipp" version = "3.22.0" source = { registry = "https://pypi.org/simple" } sdist = { url = "https://files.pythonhosted.org/packages/12/b6/7b3d16792fdf94f146bed92be90b4eb4563569eca91513c8609aebf0c167/zipp-3.22.0.tar.gz", hash = "sha256:dd2f28c3ce4bc67507bfd3781d21b7bb2be31103b51a4553ad7d90b84e57ace5", size = 25257, upload-time = "2025-05-26T14:46:32.217Z" } wheels = [ { url = "https://files.pythonhosted.org/packages/ad/da/f64669af4cae46f17b90798a827519ce3737d31dbafad65d391e49643dc4/zipp-3.22.0-py3-none-any.whl", hash = "sha256:fe208f65f2aca48b81f9e6fd8cf7b8b32c26375266b009b413d45306b6148343", size = 9796, upload-time = "2025-05-26T14:46:30.775Z" }, ]