basedmypy 2.6.0

Description:

basedmypy 2.6.0

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]]) -> <nothing>"
Basedmypy shows:
Revealed type is "(T@f, str | 1 | 2)"
Revealed type is "def [T: int] (a: T, b: str | 1 | 2) -> Never"