Datasets:

SwashBuckler001
/

idiombench

"""
Tests the handling of generic protocols.
"""

# Specification: https://typing.readthedocs.io/en/latest/spec/protocol.html#generic-protocols


from typing import Callable, Generic, Iterator, Protocol, Self, TypeVar, assert_type

S = TypeVar("S")
T = TypeVar("T")
T_co = TypeVar("T_co", covariant=True)
T_contra = TypeVar("T_contra", contravariant=True)


class Iterable(Protocol[T_co]):
    def __iter__(self) -> Iterator[T_co]:
        ...


# > Protocol[T, S, ...] is allowed as a shorthand for Protocol, Generic[T, S, ...].
# In particular, the implicit order of type parameters is dictated by
# the order in which they appear in the `Protocol` subscript.


class Proto1(Iterable[T_co], Protocol[S, T_co]):
    def method1(self, x: S) -> S:
        ...


class Concrete1:
    def __iter__(self) -> Iterator[int]:
        return (x for x in [1, 2, 3])

    def method1(self, x: str) -> str:
        return ""


p1: Proto1[str, int] = Concrete1()  # OK
p2: Proto1[int, str] = Concrete1()  # E: incompatible type


# > It is an error to combine the shorthand with Generic[T, S, ...]
class Proto2(Protocol[T_co], Generic[T_co]):  # E
    ...


# > User-defined generic protocols support explicitly declared variance.
class Box(Protocol[T_co]):
    def content(self) -> T_co:
        ...


def func1(box_int: Box[int], box_float: Box[float]):
    v1: Box[float] = box_int  # OK
    v2: Box[int] = box_float  # E


class Sender(Protocol[T_contra]):
    def send(self, data: T_contra) -> int:
        return 0


def func2(sender_int: Sender[int], sender_float: Sender[float]):
    v1: Sender[int] = sender_float  # OK
    v2: Sender[float] = sender_int  # E


class AttrProto(Protocol[T]):
    attr: T


def func3(attr_int: AttrProto[int], attr_float: AttrProto[float]):
    v1: AttrProto[float] = attr_int  # E
    v2: AttrProto[int] = attr_float  # E


# Specification: https://typing.readthedocs.io/en/latest/spec/protocol.html#self-types-in-protocols
# > The self-types in protocols follow the rules for other methods.
# Specification: https://typing.readthedocs.io/en/latest/spec/annotations.html#annotating-instance-and-class-methods
# > In addition, the first argument in an instance method can be annotated
# > with a type variable. In this case the return type may use the same
# > type variable, thus making that method a generic function.


T_bounded = TypeVar("T_bounded", bound="HasParent")


class HasParent(Protocol):
    def get_parent(self: T_bounded) -> T_bounded:
        ...


GenericHasParent = TypeVar("GenericHasParent", bound=HasParent)


def generic_get_parent(n: GenericHasParent) -> GenericHasParent:
    return n.get_parent()


class ConcreteHasParent:
    def get_parent(self) -> Self:
        return self


parent = generic_get_parent(ConcreteHasParent())  # OK
assert_type(parent, ConcreteHasParent)


# Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#use-in-protocols
# > `Self` is valid within Protocols, similar to its use in classes:


class HasParentProperty(Protocol):
    @property
    def parent(self) -> Self:
        ...


class ConcreteParentProperty:
    @property
    def parent(self) -> Self:
        return self


class InvalidParentProperty:
    @property
    def parent(self) -> HasParentProperty:
        return ConcreteParentProperty()


hp1: HasParentProperty = ConcreteParentProperty()  # OK
hp2: HasParentProperty = InvalidParentProperty()  # E



class HasMethod(Protocol):
    def m(self, item: T, callback: Callable[[T], str]) -> str:
        ...


class ConcreteHasMethod:
    def m(self, item: T, callback: Callable[[T], str]) -> str:
        return ""


class InvalidHasMethod:
    def m(self, item: int, callback: Callable[[int], str]) -> str:
        return ""


hm1: HasMethod = ConcreteHasMethod()  # OK
hm2: HasMethod = InvalidHasMethod()  # E


# Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#use-in-protocols
# > Checking a class for assignability to a protocol: If a protocol uses `Self`
# > in methods or attribute annotations, then a class `Foo` is assignable
# > to the protocol if its corresponding methods and attribute annotations use
# > either `Self` or `Foo` or any of `Foo`'s subclasses.


class HasGreaterThan(Protocol):
    def __gt__(self, other: Self) -> bool:
        ...


class ConcreteGreaterThan1:
    def __gt__(self, other: Self) -> bool:
        return False


class ConcreteGreaterThan2:
    def __gt__(self, other: "ConcreteGreaterThan2") -> bool:
        return False


class InvalidGreaterThan:
    def __gt__(self, other: int) -> bool:
        return False


hg1: HasGreaterThan = ConcreteGreaterThan1()  # OK
hg2: HasGreaterThan = ConcreteGreaterThan2()  # OK
hg3: HasGreaterThan = InvalidGreaterThan()  # E

	"""
	Tests the handling of generic protocols.
	"""

	# Specification: https://typing.readthedocs.io/en/latest/spec/protocol.html#generic-protocols


	from typing import Callable, Generic, Iterator, Protocol, Self, TypeVar, assert_type

	S = TypeVar("S")
	T = TypeVar("T")
	T_co = TypeVar("T_co", covariant=True)
	T_contra = TypeVar("T_contra", contravariant=True)


	class Iterable(Protocol[T_co]):
	def __iter__(self) -> Iterator[T_co]:
	...


	# > Protocol[T, S, ...] is allowed as a shorthand for Protocol, Generic[T, S, ...].
	# In particular, the implicit order of type parameters is dictated by
	# the order in which they appear in the `Protocol` subscript.


	class Proto1(Iterable[T_co], Protocol[S, T_co]):
	def method1(self, x: S) -> S:
	...


	class Concrete1:
	def __iter__(self) -> Iterator[int]:
	return (x for x in [1, 2, 3])

	def method1(self, x: str) -> str:
	return ""


	p1: Proto1[str, int] = Concrete1() # OK
	p2: Proto1[int, str] = Concrete1() # E: incompatible type


	# > It is an error to combine the shorthand with Generic[T, S, ...]
	class Proto2(Protocol[T_co], Generic[T_co]): # E
	...


	# > User-defined generic protocols support explicitly declared variance.
	class Box(Protocol[T_co]):
	def content(self) -> T_co:
	...


	def func1(box_int: Box[int], box_float: Box[float]):
	v1: Box[float] = box_int # OK
	v2: Box[int] = box_float # E


	class Sender(Protocol[T_contra]):
	def send(self, data: T_contra) -> int:
	return 0


	def func2(sender_int: Sender[int], sender_float: Sender[float]):
	v1: Sender[int] = sender_float # OK
	v2: Sender[float] = sender_int # E


	class AttrProto(Protocol[T]):
	attr: T


	def func3(attr_int: AttrProto[int], attr_float: AttrProto[float]):
	v1: AttrProto[float] = attr_int # E
	v2: AttrProto[int] = attr_float # E


	# Specification: https://typing.readthedocs.io/en/latest/spec/protocol.html#self-types-in-protocols
	# > The self-types in protocols follow the rules for other methods.
	# Specification: https://typing.readthedocs.io/en/latest/spec/annotations.html#annotating-instance-and-class-methods
	# > In addition, the first argument in an instance method can be annotated
	# > with a type variable. In this case the return type may use the same
	# > type variable, thus making that method a generic function.


	T_bounded = TypeVar("T_bounded", bound="HasParent")


	class HasParent(Protocol):
	def get_parent(self: T_bounded) -> T_bounded:
	...


	GenericHasParent = TypeVar("GenericHasParent", bound=HasParent)


	def generic_get_parent(n: GenericHasParent) -> GenericHasParent:
	return n.get_parent()


	class ConcreteHasParent:
	def get_parent(self) -> Self:
	return self


	parent = generic_get_parent(ConcreteHasParent()) # OK
	assert_type(parent, ConcreteHasParent)


	# Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#use-in-protocols
	# > `Self` is valid within Protocols, similar to its use in classes:


	class HasParentProperty(Protocol):
	@property
	def parent(self) -> Self:
	...


	class ConcreteParentProperty:
	@property
	def parent(self) -> Self:
	return self


	class InvalidParentProperty:
	@property
	def parent(self) -> HasParentProperty:
	return ConcreteParentProperty()


	hp1: HasParentProperty = ConcreteParentProperty() # OK
	hp2: HasParentProperty = InvalidParentProperty() # E



	class HasMethod(Protocol):
	def m(self, item: T, callback: Callable[[T], str]) -> str:
	...


	class ConcreteHasMethod:
	def m(self, item: T, callback: Callable[[T], str]) -> str:
	return ""


	class InvalidHasMethod:
	def m(self, item: int, callback: Callable[[int], str]) -> str:
	return ""


	hm1: HasMethod = ConcreteHasMethod() # OK
	hm2: HasMethod = InvalidHasMethod() # E


	# Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#use-in-protocols
	# > Checking a class for assignability to a protocol: If a protocol uses `Self`
	# > in methods or attribute annotations, then a class `Foo` is assignable
	# > to the protocol if its corresponding methods and attribute annotations use
	# > either `Self` or `Foo` or any of `Foo`'s subclasses.


	class HasGreaterThan(Protocol):
	def __gt__(self, other: Self) -> bool:
	...


	class ConcreteGreaterThan1:
	def __gt__(self, other: Self) -> bool:
	return False


	class ConcreteGreaterThan2:
	def __gt__(self, other: "ConcreteGreaterThan2") -> bool:
	return False


	class InvalidGreaterThan:
	def __gt__(self, other: int) -> bool:
	return False


	hg1: HasGreaterThan = ConcreteGreaterThan1() # OK
	hg2: HasGreaterThan = ConcreteGreaterThan2() # OK
	hg3: HasGreaterThan = InvalidGreaterThan() # E