cut stringclasses 1
value | version stringclasses 10
values | idiom_id stringclasses 53
values | pep stringclasses 53
values | introduced_in stringclasses 11
values | form stringclasses 2
values | file stringclasses 887
values | code stringclasses 916
values | source stringclasses 1
value | origin stringlengths 15 17 | origin_revision stringclasses 10
values | license stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_22.py | # callbacks.py
def on_error(x: int) -> None:
...
def on_success() -> None:
...
# main.py
import callbacks
from typing import Protocol
class Reporter(Protocol):
def on_error(self, x: int) -> None:
...
def on_success(self) -> None:
...
rp: Reporter = callbacks # Passes type check
| pydocs | pep-0544.txt:841 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_23.py | from typing import runtime_checkable, Protocol
@runtime_checkable
class SupportsClose(Protocol):
def close(self):
...
assert isinstance(open('some/file'), SupportsClose)
| pydocs | pep-0544.txt:879 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_24.py | class Foo(Protocol):
@property
def c(self) -> int:
return 42 # Default value can be provided for property...
@abstractproperty
def d(self) -> int: # ... or it can be abstract
return 0
| pydocs | pep-0544.txt:937 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_25.py | from typing import Protocol
class Base:
attr: str
class Proto(Base, Protocol):
def meth(self) -> int:
...
class C:
attr: str
def meth(self) -> int:
return 0
| pydocs | pep-0544.txt:1074 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_26.py | class Proto(Protocol):
@abstractmethod
def first(self) -> int:
raise NotImplementedError
def second(self) -> int:
return self.first() + 1
def fun(arg: Proto) -> None:
arg.second()
| pydocs | pep-0544.txt:1146 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_27.py | class P(Protocol):
x: int
class C:
def initialize(self) -> None:
self.x = 0
c = C()
isinstance(c, P) # False
c.initialize()
isinstance(c, P) # True
def f(x: Union[P, int]) -> None:
if isinstance(x, P):
# Static type of x is P here.
...
else:
# Static type of x is int... | pydocs | pep-0544.txt:1233 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_28.py | class Proto(Proto1, Proto2, ..., Protocol):
pass
| pydocs | pep-0544.txt:1270 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_29.py | class P(Protocol):
x: float
def f(arg: P) -> None:
arg.x = 0.42
class C:
x: int
c = C()
f(c) # Would typecheck if covariant subtyping
# of mutable attributes were allowed.
c.x >> 1 # But this fails at runtime
| pydocs | pep-0544.txt:1313 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_30.py | T = TypeVar('T')
class P(Protocol[T]): # Protocol is declared as invariant.
def meth(self) -> T:
...
class C:
def meth(self) -> float:
...
class D(C):
def meth(self) -> int:
...
| pydocs | pep-0544.txt:1341 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | protocol | 544 | 3.8 | modern | protocol/modern_31.py | class OldIterable(Sized, Protocol[T]):
def __getitem__(self, item: int) -> T: ...
CompatIterable = Union[Iterable[T], OldIterable[T]]
class A:
def __iter__(self) -> Iterator[str]: ...
class B:
def __len__(self) -> int: ...
def __getitem__(self, item: int) -> str: ...
def iterate(it: CompatIterable[st... | pydocs | pep-0544.txt:1387 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | positional-only-params | 570 | 3.8 | modern | positional-only-params/modern_01.py | def name(positional_only_parameters, /, positional_or_keyword_parameters,
*, keyword_only_parameters):
...
| pydocs | pep-0570.rst:443 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | positional-only-params | 570 | 3.8 | modern | positional-only-params/modern_02.py | def name(p1, p2, /, p_or_kw, *, kw):
...
def name(p1, p2=None, /, p_or_kw=None, *, kw):
...
def name(p1, p2=None, /, *, kw):
...
def name(p1, p2=None, /):
...
def name(p1, p2, /, p_or_kw):
...
def name(p1, p2, /):
...
| pydocs | pep-0570.rst:461 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | positional-only-params | 570 | 3.8 | modern | positional-only-params/modern_03.py | def foo(name, /, **kwds):
return 'name' in kwds
| pydocs | pep-0570.rst:539 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | positional-only-params | 570 | 3.8 | modern | positional-only-params/modern_04.py | def standard_arg(arg):
print(arg)
def pos_only_arg(arg, /):
print(arg)
def kwd_only_arg(*, arg):
print(arg)
def combined_example(pos_only, /, standard, *, kwd_only):
print(pos_only, standard, kwd_only)
| pydocs | pep-0570.rst:635 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | positional-only-params | 570 | 3.8 | modern | positional-only-params/modern_05.py | def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
...
| pydocs | pep-0570.rst:705 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | modern | builtin-generics/modern_01.py | from __future__ import annotations
def find(haystack: dict[str, list[int]]) -> int:
...
| pydocs | pep-0585.rst:66 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | modern | builtin-generics/modern_02.py | list[str]
tuple[int, ...]
ChainMap[str, list[str]]
| pydocs | pep-0585.rst:142 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | modern | builtin-generics/modern_03.py | l = list[str]()
list is list[str]
list == list[str]
list[str] == list[str]
list[str] == list[int]
isinstance([1, 2, 3], list[str])
issubclass(list, list[str])
isinstance(list[str], types.GenericAlias)
| pydocs | pep-0585.rst:167 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | modern | builtin-generics/modern_04.py | l: list[str] = []
| pydocs | pep-0585.rst:193 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | modern | builtin-generics/modern_05.py | l = list[str]()
| pydocs | pep-0585.rst:197 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | modern | builtin-generics/modern_06.py | list[str]
tuple[int, ...]
collections.ChainMap[str, list[str]]
| pydocs | pep-0585.rst:243 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | legacy | builtin-generics/legacy_01.py | from typing import List, Tuple, ChainMap
List[str]
Tuple[int, ...]
ChainMap[str, List[str]]
| pydocs | pep-0585.rst:254 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | builtin-generics | 585 | 3.9 | modern | builtin-generics/modern_07.py | isinstance([1, 2, 3], list[str])
| pydocs | pep-0585.rst:322 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_01.py | from typing import Literal
def accepts_only_four(x: Literal[4]) -> None:
pass
accepts_only_four(4) # OK
accepts_only_four(19) # Rejected
| pydocs | pep-0586.rst:23 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_02.py | # Note: this is a simplification of the true type signature.
_PathType = Union[str, bytes, int]
@overload
def open(path: _PathType,
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+"],
) -> IO[Text]: ...
@overload
def open(path: _PathType,
mode: Literal["rb", "wb", "ab", "xb", "r+b", "... | pydocs | pep-0586.rst:125 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_03.py | Literal[26]
Literal[0x1A] # Exactly equivalent to Literal[26]
Literal[-4]
Literal["hello world"]
Literal[b"hello world"]
Literal[u"hello world"]
Literal[True]
Literal[Color.RED] # Assuming Color is some enum
Literal[None]
| pydocs | pep-0586.rst:165 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_04.py | ReadOnlyMode = Literal["r", "r+"]
WriteAndTruncateMode = Literal["w", "w+", "wt", "w+t"]
WriteNoTruncateMode = Literal["r+", "r+t"]
AppendMode = Literal["a", "a+", "at", "a+t"]
AllModes = Literal[ReadOnlyMode, WriteAndTruncateMode,
WriteNoTruncateMode, AppendMode]
| pydocs | pep-0586.rst:182 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_05.py | Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]
| pydocs | pep-0586.rst:196 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_06.py | Literal[1, 2, 3, "foo", 5, None]
| pydocs | pep-0586.rst:200 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_07.py | Optional[Literal[1, 2, 3, "foo", 5]]
| pydocs | pep-0586.rst:204 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_08.py | def my_function(x: Literal[1 + 2]) -> int:
return x * 3
x: Literal = 3
y: Literal[my_function] = my_function
| pydocs | pep-0586.rst:271 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_09.py | def expects_str(x: str) -> None: ...
var: Literal["foo"] = "foo"
# Legal: Literal["foo"] is a subtype of str
expects_str(var)
| pydocs | pep-0586.rst:360 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_10.py | def expects_literal(x: Literal["foo"]) -> None: ...
def runner(my_str: str) -> None:
# ILLEGAL: str is not a subclass of Literal["foo"]
expects_literal(my_str)
| pydocs | pep-0586.rst:369 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_11.py | a: Literal[0] = 0
b: Literal[5] = 5
some_tuple: Tuple[int, str, List[bool]] = (3, "abc", [True, False])
reveal_type(some_tuple[a]) # Revealed type is 'int'
some_tuple[b] # Error: 5 is not a valid index into the tuple
| pydocs | pep-0586.rst:393 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_12.py | class Test:
def __init__(self, param: int) -> None:
self.myfield = param
def mymethod(self, val: int) -> str: ...
a: Literal["myfield"] = "myfield"
b: Literal["mymethod"] = "mymethod"
c: Literal["blah"] = "blah"
t = Test()
reveal_type(getattr(t, a)) # Revealed type is 'int'
reveal_type(getattr(... | pydocs | pep-0586.rst:402 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_13.py | _PathType = Union[str, bytes, int]
@overload
def open(path: _PathType,
mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+"],
) -> IO[Text]: ...
@overload
def open(path: _PathType,
mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"],
) -> IO[bytes]: ...
# Fallback... | pydocs | pep-0586.rst:430 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_14.py | A = TypeVar('A', bound=int)
B = TypeVar('B', bound=int)
C = TypeVar('C', bound=int)
# A simplified definition for Matrix[row, column]
class Matrix(Generic[A, B]):
def __add__(self, other: Matrix[A, B]) -> Matrix[A, B]: ...
def __matmul__(self, other: Matrix[B, C]) -> Matrix[A, C]: ...
def transpose(self) -... | pydocs | pep-0586.rst:467 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_15.py | T = TypeVar('T', Literal["a"], Literal["b"], Literal["c"])
S = TypeVar('S', bound=Literal["foo"])
| pydocs | pep-0586.rst:486 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_16.py | @overload
def is_int_like(x: Union[int, List[int]]) -> Literal[True]: ...
@overload
def is_int_like(x: object) -> bool: ...
def is_int_like(x): ...
vector: List[int] = [1, 2, 3]
if is_int_like(vector):
vector.append(3)
else:
vector.append("bad") # This branch is inferred to be unreachable
scalar: Union[int,... | pydocs | pep-0586.rst:567 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_17.py | def expects_three(x: Literal[3]) -> None: ...
expects_three(foo) # Type checks, since 'foo' is Final and equal to 3
| pydocs | pep-0586.rst:599 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | literal-types | 586 | 3.8 | modern | literal-types/modern_18.py | def foobar(arg1: Literal[1], arg2: Literal[True]) -> None:
pass
| pydocs | pep-0586.rst:665 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_01.py | from typing import TypedDict
class Movie(TypedDict):
name: str
year: int
| pydocs | pep-0589.rst:37 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_02.py | class EmptyDict(TypedDict):
pass
| pydocs | pep-0589.rst:159 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_03.py | class Strings(TypedDict):
items: List[str]
print(isinstance({'items': [1]}, Strings)) # Should be False
print(isinstance({'items': ['x']}, Strings)) # Should be True
| pydocs | pep-0589.rst:231 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_04.py | class BookBasedMovie(TypedDict):
name: str
year: int
based_on: str
| pydocs | pep-0589.rst:255 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_05.py | class X(TypedDict):
x: int
class Y(TypedDict):
y: str
class XYZ(X, Y):
z: bool
| pydocs | pep-0589.rst:262 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_06.py | class X(TypedDict):
x: str
class Y(X):
x: int # Type check error: cannot overwrite TypedDict field "x"
| pydocs | pep-0589.rst:282 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_07.py | class X(TypedDict):
x: int
class Y(TypedDict):
x: str
class XYZ(X, Y): # Type check error: cannot overwrite TypedDict field "x" while merging
xyz: bool
| pydocs | pep-0589.rst:296 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_08.py | class Movie(TypedDict, total=False):
name: str
year: int
| pydocs | pep-0589.rst:313 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_09.py | Movie = TypedDict('Movie', {'name': str, 'year': int})
| pydocs | pep-0589.rst:342 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_10.py | Movie = TypedDict('Movie',
{'name': str, 'year': int},
total=False)
| pydocs | pep-0589.rst:346 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_11.py | class A(TypedDict):
x: Optional[int]
class B(TypedDict):
x: int
def f(a: A) -> None:
a['x'] = None
b: B = {'x': 0}
f(b) # Type check error: 'B' not compatible with 'A'
b['x'] + 1 # Runtime error: None + 1
| pydocs | pep-0589.rst:391 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_12.py | class A(TypedDict, total=False):
x: int
class B(TypedDict):
x: int
def f(a: A) -> None:
del a['x']
b: B = {'x': 0}
f(b) # Type check error: 'B' not compatible with 'A'
b['x'] + 1 # Runtime KeyError: 'x'
| pydocs | pep-0589.rst:408 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_13.py | class A(TypedDict):
x: int
class B(A):
y: str
def f(d: Dict[str, int]) -> None:
d['y'] = 0
def g(a: A) -> None:
f(a) # Type check error: 'A' incompatible with Dict[str, int]
b: B = {'x': 0, 'y': 'foo'}
g(b)
b['y'] + 'bar' # Runtime error: int + str
| pydocs | pep-0589.rst:453 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | typed-dict | 589 | 3.8 | modern | typed-dict/modern_14.py | class A(TypedDict):
x: int
class B(TypedDict):
x: int
y: str
def sum_values(m: Mapping[str, int]) -> int:
n = 0
for v in m.values():
n += v # Runtime error
return n
def f(a: A) -> None:
sum_values(a) # Error: 'A' incompatible with Mapping[str, int]
b: B = {'x': 0, 'y': 'foo'}
f... | pydocs | pep-0589.rst:475 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_01.py | from typing import final
@final
class Base:
...
class Derived(Base): # Error: Cannot inherit from final class "Base"
...
| pydocs | pep-0591.rst:83 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_02.py | from typing import final
class Base:
@final
def foo(self) -> None:
...
class Derived(Base):
def foo(self) -> None: # Error: Cannot override final attribute "foo"
# (previously declared in base class "Base")
...
| pydocs | pep-0591.rst:94 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_03.py | from typing import Any, overload
class Base:
@overload
def method(self) -> None: ...
@overload
def method(self, arg: int) -> int: ...
@final
def method(self, x=None):
...
| pydocs | pep-0591.rst:110 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_04.py | ID: Final[float] = 1
| pydocs | pep-0591.rst:136 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_05.py | ID: Final = 1
| pydocs | pep-0591.rst:140 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_06.py | from typing import Final
RATE: Final = 3000
class Base:
DEFAULT_ID: Final = 0
RATE = 300 # Error: can't assign to final attribute
Base.DEFAULT_ID = 1 # Error: can't override a final attribute
| pydocs | pep-0591.rst:170 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_07.py | from typing import Final
class Window:
BORDER_WIDTH: Final = 2.5
...
class ListView(Window):
BORDER_WIDTH = 3 # Error: can't override a final attribute
| pydocs | pep-0591.rst:187 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_08.py | class ImmutablePoint:
x: Final[int]
y: Final[int] # Error: final attribute without an initializer
def __init__(self) -> None:
self.x = 1 # Good
| pydocs | pep-0591.rst:199 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_09.py | x: List[Final[int]] = [] # Error!
def fun(x: Final[List[int]]) -> None: # Error!
...
| pydocs | pep-0591.rst:214 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_10.py | x: Final = ['a', 'b']
x.append('c') # OK
y: Final[Sequence[str]] = ['a', 'b']
y.append('x') # Error: "Sequence[str]" has no attribute "append"
z: Final = ('a', 'b') # Also works
| pydocs | pep-0591.rst:224 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | final-qualifier | 591 | 3.8 | modern | final-qualifier/modern_11.py | from typing import NamedTuple, Final
X: Final = "x"
Y: Final = "y"
N = NamedTuple("N", [(X, int), (Y, int)])
| pydocs | pep-0591.rst:236 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_01.py | UnsignedShort = Annotated[int, struct2.ctype('H')]
SignedChar = Annotated[int, struct2.ctype('b')]
class Student(struct2.Packed):
# mypy typechecks 'name' field as 'str'
name: Annotated[str, struct2.ctype("<10s")]
serialnum: UnsignedShort
school: SignedChar
# 'unpack' only uses the metadata within the... | pydocs | pep-0593.rst:67 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_02.py | Currency = Annotated[
TypedDict('Currency', {'dollars': float, 'pounds': float}, total=False),
TaggedUnion,
]
| pydocs | pep-0593.rst:100 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_03.py | Annotated[int, ValueRange(3, 10), ctype("char")]
| pydocs | pep-0593.rst:128 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_04.py | Annotated[int, ValueRange(3, 10), ctype("char")] != Annotated[
int, ctype("char"), ValueRange(3, 10)
]
| pydocs | pep-0593.rst:136 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_05.py | Annotated[Annotated[int, ValueRange(3, 10)], ctype("char")] == Annotated[
int, ValueRange(3, 10), ctype("char")
]
| pydocs | pep-0593.rst:143 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_06.py | Annotated[int, ValueRange(3, 10)] != Annotated[
int, ValueRange(3, 10), ValueRange(3, 10)
]
| pydocs | pep-0593.rst:149 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_07.py | T1 = Annotated[int, ValueRange(-10, 5)]
T2 = Annotated[T1, ValueRange(-20, 3)]
| pydocs | pep-0593.rst:190 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_08.py | T2 = Annotated[int, ValueRange(-10, 5), ValueRange(-20, 3)]
| pydocs | pep-0593.rst:195 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | annotated | 593 | 3.9 | modern | annotated/modern_09.py | @struct2.packed
class Student(NamedTuple):
name: Annotated[str, struct.ctype("<10s")]
get_type_hints(Student) == {'name': str}
get_type_hints(Student, include_extras=False) == {'name': str}
get_type_hints(Student, include_extras=True) == {
'name': Annotated[str, struct.ctype("<10s")]
}
| pydocs | pep-0593.rst:206 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_01.py | isinstance(5, int | str)
issubclass(bool, int | float)
| pydocs | pep-0604.rst:51 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_02.py | isinstance(None, int | None)
isinstance(42, None | int)
| pydocs | pep-0604.rst:57 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_03.py | # Instead of
# def f(list: List[Union[int, str]], param: Optional[int]) -> Union[float, str]
def f(list: List[int | str], param: int | None) -> float | str:
pass
f([1, "abc"], None)
# Instead of typing.List[typing.Union[str, int]]
typing.List[str | int]
list[str | int]
# Instead of typing.Dict[str, typing.Union[... | pydocs | pep-0604.rst:69 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_04.py | int | str == typing.Union[int, str]
typing.Union[int, int] == int
int | int == int
| pydocs | pep-0604.rst:88 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_05.py | (int | str) == (str | int)
(int | str | float) == typing.Union[str, float, int]
| pydocs | pep-0604.rst:97 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_06.py | None | t == typing.Optional[t]
| pydocs | pep-0604.rst:105 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_07.py | str(int | list[str])
# int | list[str]
str(int | int)
# int
| pydocs | pep-0604.rst:111 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_08.py | # valid
isinstance("", int | str)
# invalid
isinstance(2, list[int]) # TypeError: isinstance() argument 2 cannot be a parameterized generic
isinstance(1, int | list[int])
# valid
issubclass(bool, int | float)
# invalid
issubclass(bool, bool | list[int])
| pydocs | pep-0604.rst:124 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_09.py | class M(type):
def __or__(self, other): return "Hello"
class C(metaclass=M): pass
C | int
int | C
Union[C, int]
| pydocs | pep-0604.rst:146 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | union-syntax | 604 | 3.10 | modern | union-syntax/modern_10.py | from __future__ import annotations
def foo() -> int | str: pass
eval(foo.__annotations__['return'])
| pydocs | pep-0604.rst:193 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | legacy | param-spec/legacy_01.py | from typing import Awaitable, Callable, TypeVar
R = TypeVar("R")
def add_logging(f: Callable[..., R]) -> Callable[..., Awaitable[R]]:
async def inner(*args: object, **kwargs: object) -> R:
await log_to_database()
return f(*args, **kwargs)
return inner
@add_logging
def takes_int_str(x: int, y: str) -> int... | pydocs | pep-0612.rst:37 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_01.py | from typing import Awaitable, Callable, ParamSpec, TypeVar
P = ParamSpec("P")
R = TypeVar("R")
def add_logging(f: Callable[P, R]) -> Callable[P, Awaitable[R]]:
async def inner(*args: P.args, **kwargs: P.kwargs) -> R:
await log_to_database()
return f(*args, **kwargs)
return inner
@add_logging
def takes_in... | pydocs | pep-0612.rst:87 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | legacy | param-spec/legacy_02.py | class Request:
...
def with_request(f: Callable[..., R]) -> Callable[..., R]:
def inner(*args: object, **kwargs: object) -> R:
return f(Request(), *args, **kwargs)
return inner
@with_request
def takes_int_str(request: Request, x: int, y: str) -> int:
# use request
return x + 7
takes_int_str(1, "A")
tak... | pydocs | pep-0612.rst:111 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_02.py | from typing import Concatenate
def with_request(f: Callable[Concatenate[Request, P], R]) -> Callable[P, R]:
def inner(*args: P.args, **kwargs: P.kwargs) -> R:
return f(Request(), *args, **kwargs)
return inner
@with_request
def takes_int_str(request: Request, x: int, y: str) -> int:
# use request
return x ... | pydocs | pep-0612.rst:133 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_03.py | from typing import ParamSpec
P = ParamSpec("P") # Accepted
P = ParamSpec("WrongName") # Rejected because P =/= WrongName
| pydocs | pep-0612.rst:163 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_04.py | def foo(x: P) -> P: ... # Rejected
def foo(x: Concatenate[int, P]) -> int: ... # Rejected
def foo(x: typing.List[P]) -> None: ... # Rejected
def foo(x: Callable[[int, str], P]) -> None: ... # Rejected
| pydocs | pep-0612.rst:202 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_05.py | T = TypeVar("T")
P_2 = ParamSpec("P_2")
class X(Generic[T, P]):
f: Callable[P, int]
x: T
def f(x: X[int, P_2]) -> str: ... # Accepted
def f(x: X[int, Concatenate[int, P_2]]) -> str: ... # Accepted
def f(x: X[int, [int, bool]]) -> str: ... # Accepted
def f(x: X[int, ...]) -> str: ...... | pydocs | pep-0612.rst:218 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_06.py | P = ParamSpec("P")
def foo(x: Callable[P, int], y: Callable[P, int]) -> Callable[P, bool]: ...
def x_y(x: int, y: str) -> int: ...
def y_x(y: int, x: str) -> int: ...
foo(x_y, x_y) # Should return (x: int, y: str) -> bool
foo(x_y, y_x) # Could return (__a: int, __b: str) -> bool
# This works becaus... | pydocs | pep-0612.rst:279 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_07.py | def bar(x: int, *args: bool) -> int: ...
def add(x: Callable[P, int]) -> Callable[Concatenate[str, P], bool]: ...
add(bar) # Should return (__a: str, x: int, *args: bool) -> bool
def remove(x: Callable[Concatenate[int, P], int]) -> Callable[P, bool]: ...
remove(bar) # Should return (*args: bool) -> bool
d... | pydocs | pep-0612.rst:324 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_08.py | def expects_int_first(x: Callable[Concatenate[int, P], int]) -> None: ...
@expects_int_first # Rejected
def one(x: str) -> int: ...
@expects_int_first # Rejected
def two(*, x: int) -> int: ...
@expects_int_first # Rejected
def three(**kwargs: int) -> int: ...
@expects_int_first # Accepted
def four(*args: int) -> in... | pydocs | pep-0612.rst:347 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_09.py | def puts_p_into_scope(f: Callable[P, int]) -> None:
def inner(*args: P.args, **kwargs: P.kwargs) -> None: # Accepted
pass
def mixed_up(*args: P.kwargs, **kwargs: P.args) -> None: # Rejected
pass
def misplaced(x: P.args) -> None: # Rejected
pass
def out_of_scope(*arg... | pydocs | pep-0612.rst:390 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_10.py | def puts_p_into_scope(f: Callable[P, int]) -> None:
stored_args: P.args # Rejected
stored_kwargs: P.kwargs # Rejected
def just_args(*args: P.args) -> None: # Rejected
pass
def just_kwargs(**kwargs: P.kwargs) -> None: # Rejected
pass
| pydocs | pep-0612.rst:414 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_11.py | def decorator(f: Callable[P, int]) -> Callable[P, None]:
def foo(*args: P.args, **kwargs: P.kwargs) -> None:
f(*args, **kwargs) # Accepted, should resolve to int
f(*kwargs, **args) # Rejected
f(1, *args, **kwargs) # Rejected
return foo # Accepted
| pydocs | pep-0612.rst:454 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_12.py | def add(f: Callable[P, int]) -> Callable[Concatenate[str, P], None]:
def foo(s: str, *args: P.args, **kwargs: P.kwargs) -> None: # Accepted
pass
def bar(*args: P.args, s: str, **kwargs: P.kwargs) -> None: # Rejected
pass
return foo # Accepted
def re... | pydocs | pep-0612.rst:479 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
train | 3.10 | param-spec | 612 | 3.10 | modern | param-spec/modern_13.py | def outer(f: Callable[P, None]) -> Callable[P, None]:
def foo(x: int, *args: P.args, **kwargs: P.kwargs) -> None:
f(*args, **kwargs)
def bar(*args: P.args, **kwargs: P.kwargs) -> None:
foo(1, *args, **kwargs) # Accepted
foo(x=1, *args, **kwargs) # Rejected
return bar
| pydocs | pep-0612.rst:507 | 2c89d6ac2ccea9d8691f1b75d95c2d7294cc32ca | CC0-1.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.