Trust the fine-grained cache for files not known to have changed

A daemon started with --use-fine-grained-cache looks at every source on
its first check: validate_meta stats each file (and hashes it when the
cache's mtime does not match, which a downloaded cache's never does), and
the fswatcher then stats them all again to find what changed since the
cache. For a large repository on a network or FUSE filesystem, that is the
whole cost of a cold start, though a tool that knows what changed - git,
or a filesystem that keeps a journal - could say so in one step.

--changed-since-cache-file names that file: every path that may differ
from the files the cache was generated from, one per line. For any other
source whose cache metadata names the same path, validate_meta accepts
the metadata without a stat, State creation does not ask whether it is a
directory, and the first fine-grained update looks only at the named
files and at sources the cache has nothing for, through the same
update_changed path dmypy recheck --update takes. A missing file is
warned about and ignored, so every file is looked at as before.

Like --quickstart-file, the option is hidden: its user is a wrapper that
knows how the cache was made.
6 files changed
tree: a7466db35b9cf2b129c9bf698dda3e9c90a4aff1
  1. .github/
  2. docs/
  3. misc/
  4. mypy/
  5. mypyc/
  6. skills/
  7. test-data/
  8. .editorconfig
  9. .git-blame-ignore-revs
  10. .gitattributes
  11. .gitignore
  12. .pre-commit-config.yaml
  13. .readthedocs.yaml
  14. action.yml
  15. build-requirements.txt
  16. CHANGELOG.md
  17. conftest.py
  18. CONTRIBUTING.md
  19. CREDITS
  20. dev-requirements.in
  21. dev-requirements.txt
  22. LICENSE
  23. MANIFEST.in
  24. mypy-requirements.txt
  25. mypy_bootstrap.ini
  26. mypy_self_check.ini
  27. pyproject.toml
  28. README.md
  29. runtests.py
  30. setup.py
  31. test-requirements.in
  32. test-requirements.txt
  33. tox.ini
README.md

Mypy: Static Typing for Python

Stable Version Downloads Build Status Documentation Status Chat at https://gitter.im/python/typing Checked with mypy Code style: black Linting: Ruff

Got a question?

We are always happy to answer questions! Here are some good places to ask them:

If you're just getting started, the documentation and type hints cheat sheet can also help answer questions.

If you think you've found a bug:

To report a bug or request an enhancement:

To discuss a new type system feature:

What is mypy?

Mypy is a static type checker for Python.

Type checkers help ensure that you're using variables and functions in your code correctly. With mypy, add type hints (PEP 484) to your Python programs, and mypy will warn you when you use those types incorrectly.

Python is a dynamic language, so usually you'll only see errors in your code when you attempt to run it. Mypy is a static checker, so it finds bugs in your programs without even running them!

Here is a small example to whet your appetite:

number = input("What is your favourite number?")
print("It is", number + 1)  # error: Unsupported operand types for + ("str" and "int")

Adding type hints for mypy does not interfere with the way your program would otherwise run. Think of type hints as similar to comments! You can always use the Python interpreter to run your code, even if mypy reports errors.

Mypy is designed with gradual typing in mind. This means you can add type hints to your code base slowly and that you can always fall back to dynamic typing when static typing is not convenient.

Mypy has a powerful and easy-to-use type system, supporting features such as type inference, generics, callable types, tuple types, union types, structural subtyping and more. Using mypy will make your programs easier to understand, debug, and maintain.

See the documentation for more examples and information.

In particular, see:

Quick start

Mypy can be installed using pip:

python3 -m pip install -U mypy

If you want to run the latest version of the code, you can install from the repo directly:

python3 -m pip install -U git+https://github.com/python/mypy.git

Now you can type-check the statically typed parts of a program like this:

mypy PROGRAM

You can always use the Python interpreter to run your statically typed programs, even if mypy reports type errors:

python3 PROGRAM

If you are working with large code bases, you can run mypy in daemon mode, that will give much faster (often sub-second) incremental updates:

dmypy run -- PROGRAM

You can also try mypy in an online playground (developed by Yusuke Miyazaki).

Integrations

Mypy can be integrated into popular IDEs:

Web site and documentation

Additional information is available at the web site:

https://www.mypy-lang.org/

Jump straight to the documentation:

https://mypy.readthedocs.io/

Follow along our changelog at:

https://mypy-lang.blogspot.com/

Contributing

Help in testing, development, documentation and other tasks is highly appreciated and useful to the project. There are tasks for contributors of all experience levels.

To get started with developing mypy, see CONTRIBUTING.md.

Mypyc and compiled version of mypy

Mypyc uses Python type hints to compile Python modules to faster C extensions. Mypy is itself compiled using mypyc: this makes mypy approximately 4 times faster than if interpreted!

To install an interpreted mypy instead, use:

python3 -m pip install --no-binary mypy -U mypy

To use a compiled version of a development version of mypy, directly install a binary from https://github.com/mypyc/mypy_mypyc-wheels/releases/latest.

To contribute to the mypyc project, check out the issue tracker at https://github.com/mypyc/mypyc