Basedmypy is a type checker that is built on top of the work done by the mypy project. It adds based functionality and breaks compatibility with the cringe parts of pep 484.

Based features

Baseline

Basedmypy has baseline, baseline is based! It allows you to adopt new strictness or features without the burden of fixing up every usage, just save all current errors to the baseline file and deal with them later.

Consider the following:

def foo(a):
    print(a)

> mypy demo.py
demo.py:1: error: missing typehints
Failed: errors found in source file


> mypy --write-baseline demo.py
demo.py:1: error: missing typehints
Baseline successfully written to .mypy/baseline.json

> mypy demo.py
Success: no issues found in 1 source file

Then on subsequent runs the existing errors will be filtered out:

def foo(a):
    print(a)

def bar(b: str, c: int) -> bool:
    return b + c

> mypy demo.py
demo.py:4:5: error: Returning Any from function declared to return "bool"  [no-any-return]
demo.py:4:16: error: Unsupported operand types for + ("str" and "int")  [operator]
Found 2 errors in 1 file (checked 1 source file)

Intersection Types

Using the & operator or basedtyping.Intersection you can denote intersection types:

class Growable(ABC, Generic[T]):
    @abstractmethod
    def add(self, item: T): ...

class Resettable(ABC):
    @abstractmethod
    def reset(self): ...

def f(x: Resettable & Growable[str]):
    x.reset()
    x.add("first")

Type Joins

Mypy joins types to their common base type:

a: int
b: str
reveal_type(a if bool() else b)  # Revealed type is "builtins.object"

Basedmypy joins types into unions instead:

a: int
b: str
reveal_type(a if bool() else b)  # Revealed type is "int | str"

Bare Literals

Literal is so cumbersome! just use a bare literal instead:

class Color(Enum):
    RED = auto()

a: 1 | 2
b: True | Color.RED

Default Return Type

The default return type of functions is None instead of Any: (configurable with the default_return option.)

def f(name: str):
    print(f"Hello, {name}!")

reveal_type(f)  # (str) -> None

Generic TypeVar Bounds

Allows the bounds of TypeVars to be generic.

So you are able to have functions with polymorphic generic parameters.

E = TypeVar("E")
I = TypeVar("I", bound=Iterable[E])

def foo(i: I, e: E) -> I:
    assert e not in i
    return i

reveal_type(foo(["based"], "mypy"))  # N: Revealed type is "list[str]"
reveal_type(foo({1, 2}, 3))  # N: Revealed type is "set[int]"

Overload Implementation Inference

The types in overload implementations (including properties) can be inferred:

@overload
def f(a: int) -> str: ...

@overload
def f(a: str) -> int: ...

def f(a):
    reveal_type(a)  # int | str
    return None  # error: expected str | int

class A:
    @property
    def foo(self) -> int: ...
    @foo.setter
    def foo(self, value): ...  # no need for annotations

Infer Function Parameters

Infer the type of a function parameter from it's default value:

def f(a=1, b=True):
    reveal_type((a, b))  # (int, bool)

Tuple Literal Types

Basedmypy allows denotation of tuple types with tuple literals:

a: (int, str) = (1, "a")

Types in Messages

Basedmypy makes significant changes to error and info messages, consider:

T = TypeVar("T", bound=int)

def f(a: T, b: list[str | 1 | 2]) -> Never:
    reveal_type((a, b))

reveal_type(f)

Mypy shows:

Revealed type is "Tuple[T`-1, Union[builtins.str, Literal[1], Literal[2]]]"
Revealed type is "def [T <: builtins.int] (a: T`-1, b: Union[builtins.str, Literal[1], Literal[2]]) -> "

Basedmypy shows:

Revealed type is "(T@f, str | 1 | 2)"
Revealed type is "def [T: int] (a: T, b: str | 1 | 2) -> Never"