generate-typing-rewrite-info

#!/usr/bin/env python3
from __future__ import annotations

import os
import sys
from collections import defaultdict

import flake8_typing_imports
import mypy_extensions
import typing_extensions

if sys.version_info >= (3, 8):
    from importlib.metadata import version
else:
    from importlib_metadata import version


# --- typing_extensions notes ---
# https://github.com/python/typing_extensions#other-notes-and-limitations
# - get_origin and get_args lack support for Annotated in Python 3.8
#   and lack support for ParamSpecArgs and ParamSpecKwargs in 3.9.
# - Starting with 3.11, NamedTuple and TypedDict can inherit from Generic
# - @final was changed in Python 3.11 to set the .__final__ attribute
# - @overload was changed in Python 3.11 to make function overloads
#   introspectable at runtime.
CUSTOM_TYPING_EXT_SYMBOLS = {
    (3, 10): {'get_origin', 'get_args'},
    (3, 11): {'NamedTuple', 'TypedDict', 'final', 'overload'},
}


def main() -> int:
    flake8_typing_imports_version = version('flake8-typing-imports')
    mypy_extensions_version = version('mypy_extensions')
    typing_extensions_version = version('typing_extensions')

    mypy_extensions_all = frozenset(
        a for a in dir(mypy_extensions) if a != 'Any'
    )
    typing_extensions_all = frozenset(typing_extensions.__all__) - {
        sym for v in CUSTOM_TYPING_EXT_SYMBOLS.values() for sym in v
    }

    # some attrs are removed and then added back
    min_contiguous_versions: dict[str, flake8_typing_imports.Version] = {}
    for v, attrs in flake8_typing_imports.SYMBOLS:
        for removed in set(min_contiguous_versions) - attrs:
            del min_contiguous_versions[removed]

        for attr in attrs:
            min_contiguous_versions.setdefault(attr, v)

    symbols: dict[flake8_typing_imports.Version, set[str]] = defaultdict(set)
    for a, v in min_contiguous_versions.items():
        symbols[v].add(a)

    # --pyXX-plus assumes the min --pyXX so group symbols by their
    # rounded up major version
    symbols_rounded_up: dict[tuple[int, int], set[str]] = defaultdict(set)
    for v, attrs in sorted(symbols.items()):
        symbols_rounded_up[v.major, v.minor + int(v.patch != 0)] |= attrs

    # combine 3.5 and 3.6 because this lib is 3.7+
    symbols_rounded_up[(3, 6)] |= symbols_rounded_up.pop((3, 5))

    deltas: dict[tuple[int, int], set[str]] = defaultdict(set)
    prev: set[str] = set()
    for v, attrs in sorted(symbols_rounded_up.items()):
        deltas[v] = attrs - prev
        prev = attrs

    mypy_extensions_added: dict[tuple[int, int], set[str]] = {}
    typing_extensions_added: dict[tuple[int, int], set[str]] = defaultdict(set)
    for v, attrs in deltas.items():
        mypy_extensions_added[v] = attrs & mypy_extensions_all
        typing_extensions_added[v] = attrs & typing_extensions_all
    for v, attrs in CUSTOM_TYPING_EXT_SYMBOLS.items():
        typing_extensions_added[v] |= attrs

    print(f'# GENERATED VIA {os.path.basename(sys.argv[0])}')
    print('# Using:')
    print(f'#     flake8-typing-imports=={flake8_typing_imports_version}')
    print(f'#     mypy_extensions=={mypy_extensions_version}')
    print(f'#     typing_extensions=={typing_extensions_version}')

    for k, v in sorted(mypy_extensions_added.items()):
        if not v:
            continue
        print(f'REPLACES[{k}].update((')
        for symbol in sorted(v):
            print(f"    'mypy_extensions=typing:{symbol}',")
        print('))')

    for k, v in sorted(typing_extensions_added.items()):
        if not v:
            continue
        print(f'REPLACES[{k}].update((')
        for symbol in sorted(v):
            print(f"    'typing_extensions=typing:{symbol}',")
        print('))')

    print('# END GENERATED')

    return 0


if __name__ == '__main__':
    raise SystemExit(main())