Writing and linting Python at scale(engineering.fb.com)

  Like This

  from typing import TypeVar
  
  T, U, V, W = TypeVar('T'), TypeVar('U'), TypeVar('V'), TypeVar('W')
  
  def concatenate(a: tuple[T, U], b: tuple[V, W]) -> tuple[T, U, V, W]:
      return a + b

  from typing import Any, Callable
  
  Transformer = Callable[[dict[str, Any]], dict[Callable, Any]]

  from typing import TypeVarTuple

  Ts = TypeVarTuple("Ts”)
  Us = TypeVarTuple("Us”)

  def tconcat(
    t1: tuple[*Ts], 
    t2: tuple[*Us]
  ) -> tuple[*Ts, *Us]: ...

   def concat_tuples(tuple1: Tuple[int, str, float], tuple2: Tuple[str, str, str]) -> Tuple[int, str, float, str, str, str]:
       return tuple1 + tuple2

   T = TypeVar('T')
   def transform(x: Dict[str, T]) -> Dict[str, Callable[[], T]]:
       return {key: lambda : value for key, value in x.items()}

   from numbers import Number
   def transform2(x: Dict[str, Number]) -> Dict[str, Callable[[Number], Number]]:
       return {key: lambda y: value + y for key, value in x.items()}

   def transform3(x: Dict[str, Number]) -> Dict[str, Callable[[], Number]]:
       return {key: lambda: value + value for key, value in x.items()}

  JSONObject = None | str | int | bool | list["JSONObject"] | dict[str, "JSONObject"]
  # this type checks
  a: JSONObject = {"a": [1, 2, "7", True, {"false": None}]}
  # this doesn't type check
  b: JSONObject = {"a": [1, 2, "7", True, {"false": object()}]}

   from typing import Dict, List
   JSON = Dict[str, 'JSON'] | List['JSON'] | float | int | str | None