types-futures

3.3.8 · active · verified Wed Apr 15

types-futures provides static type annotations (stubs) for the `concurrent.futures` module, which is part of Python's standard library. It enables type checkers like MyPy, Pyright, or PyCharm to perform static analysis and provide type hints for code utilizing thread and process pools. This package is maintained by the Typeshed project and is released automatically to PyPI, often daily, to keep up with changes in the runtime library.

Warnings

gotcha Do not confuse `types-futures` with the `futures` PyPI package. The `futures` package is a Python 2 backport of `concurrent.futures` and is not compatible with Python 3. `types-futures` provides stubs for Python 3's built-in `concurrent.futures` module.
Fix: Ensure you are installing `types-futures` for type-checking `concurrent.futures` in Python 3 environments, and do not install the `futures` runtime package on Python 3.
breaking As `types-futures` is part of Typeshed, any version bump can introduce changes to the stubs that might cause your code to fail type checking, even if the runtime behavior remains the same. This is inherent to the nature of stub files aligning with potentially evolving APIs.
Fix: Pin the `types-futures` version to match the major.minor version of the `concurrent.futures` (implicitly, your Python runtime) it's stubbing, e.g., `types-futures~=3.x.y`. Regularly update and re-run type checks.
gotcha The `asyncio.Future` and `concurrent.futures.Future` classes are distinct and incompatible. Code expecting one will not correctly process the other, leading to runtime errors or incorrect type checking. `asyncio.Future` instances are awaitable, whereas `concurrent.futures.Future` instances are not.
Fix: Be mindful of the context (asynchronous vs. thread/process-based concurrency) and use the appropriate `Future` class. Ensure correct type hints are used for each to leverage `types-futures` effectively.

Install

pip install types-futures Install types-futures

Imports

Future
```
from concurrent.futures import Future
```

ThreadPoolExecutor

from concurrent.futures import ThreadPoolExecutor

ProcessPoolExecutor

from concurrent.futures import ProcessPoolExecutor

as_completed

from concurrent.futures import as_completed

wait
```
from concurrent.futures import wait
```

Quickstart

This quickstart demonstrates using `concurrent.futures.ThreadPoolExecutor` with type hints. By installing `types-futures`, type checkers will correctly interpret the types of `Future` objects and executor methods, allowing for static analysis of your concurrent code.

from concurrent.futures import ThreadPoolExecutor, Future
from typing import List

def long_running_task(n: int) -> int:
    import time
    time.sleep(0.1)
    return n * n

def main() -> None:
    with ThreadPoolExecutor(max_workers=5) as executor:
        futures: List[Future[int]] = [
            executor.submit(long_running_task, i) for i in range(10)
        ]
        results: List[int] = [f.result() for f in futures]
    print(f"Computed results: {results}")

if __name__ == '__main__':
    main()

view raw JSON →