@zzzen/pyright-internal 1.1.255 → 1.2.0-beta

package/src/tests/samples/memberAccess11.py

@@ -1,37 +0,0 @@
-# This sample tests that methods are bound properly regardless of
-# whether they are decorated.
-
-from typing import Callable
-
-UnboundMethodThatTakesIntAndReturnsStr = Callable[["MyClass", int], str]
-
-
-def method_decorator(
-    method: UnboundMethodThatTakesIntAndReturnsStr,
-) -> UnboundMethodThatTakesIntAndReturnsStr:
-    def wrapper(self: "MyClass", a: int) -> str:
-        return "wrapped " + method(self, a)
-
-    return wrapper
-
-
-class MyClass:
-    def __init__(self):
-        self.method4 = lambda x: x
-
-    @method_decorator
-    def method1(self, a: int) -> str:
-        return "foo"
-
-    def method2(self, a: int) -> str:
-        return "foo"
-
-    method3 = method_decorator(method2)
-
-
-mc = MyClass()
-
-mc.method1(1)
-mc.method2(1)
-mc.method3(1)
-mc.method4(1)

package/src/tests/samples/memberAccess12.py

@@ -1,36 +0,0 @@
-# This sample tests a member access when the metaclass implements a descriptor
-# protocol.
-
-from typing import Any, Optional, Union, Type, TypeVar, overload
-
-
-T = TypeVar("T")
-
-
-class MetaClass(type):
-    @overload
-    def __get__(self: Type[T], instance: None, owner: Any) -> Type[T]:
-        ...
-
-    @overload
-    def __get__(self: Type[T], instance: object, owner: Any) -> T:
-        ...
-
-    def __get__(
-        self: Type[T], instance: Optional[object], owner: Any
-    ) -> Union[Type[T], T]:
-        if instance is None:
-            return self
-        return self()
-
-
-class A(metaclass=MetaClass):
-    ...
-
-
-class B:
-    a = A
-
-
-reveal_type(B.a, expected_text="Type[A]")
-reveal_type(B().a, expected_text="A")

package/src/tests/samples/memberAccess13.py

@@ -1,17 +0,0 @@
-# This sample tests a member access when the member is a class
-# that inherits from Any.
-
-from typing import Type
-from unittest.mock import Mock
-
-
-class MockProducer:
-    produce: Type[Mock] = Mock
-
-
-reveal_type(MockProducer.produce, expected_text="Type[Mock]")
-reveal_type(MockProducer().produce, expected_text="Type[Mock]")
-
-
-reveal_type(MockProducer.produce(), expected_text="Mock")
-reveal_type(MockProducer().produce(), expected_text="Mock")

package/src/tests/samples/memberAccess14.py

@@ -1,63 +0,0 @@
-# This sample tests the use of a generic descriptor class that
-# is parameterized based on the type of the object that instantiates
-# the descriptor.
-
-
-from typing import Any, Callable, Generic, TypeVar, Union, overload
-
-T = TypeVar("T")
-T_contra = TypeVar("T_contra", contravariant=True)
-V_co = TypeVar("V_co", covariant=True)
-CachedSlotPropertyT = TypeVar(
-    "CachedSlotPropertyT", bound="CachedSlotProperty[Any, Any]"
-)
-
-
-class CachedSlotProperty(Generic[T_contra, V_co]):
-    def __init__(self, name: str, function: Callable[[T_contra], V_co]) -> None:
-        ...
-
-    @overload
-    def __get__(
-        self: CachedSlotPropertyT, instance: None, owner: type[T_contra]
-    ) -> CachedSlotPropertyT:
-        ...
-
-    @overload
-    def __get__(self, instance: T_contra, owner: Any) -> V_co:
-        ...
-
-    def __get__(
-        self: CachedSlotPropertyT, instance: Union[T_contra, None], owner: Any
-    ) -> Union[CachedSlotPropertyT, V_co]:
-        ...
-
-
-def cached_slot_property(
-    name: str,
-) -> Callable[[Callable[[T_contra], V_co]], CachedSlotProperty[T_contra, V_co]]:
-    ...
-
-
-class C(Generic[T]):
-    def __init__(self, data: T) -> None:
-        ...
-
-    @cached_slot_property("_prop")
-    def prop(self) -> int:
-        ...
-
-
-class D(C[float]):
-    ...
-
-
-reveal_type(C.prop, expected_text="CachedSlotProperty[Self@C[T@C], int]")
-reveal_type(D.prop, expected_text="CachedSlotProperty[D, int]")
-
-
-c = C("")
-reveal_type(c.prop, expected_text="int")
-
-d = D(1)
-reveal_type(d.prop, expected_text="int")

package/src/tests/samples/memberAccess15.py

@@ -1,20 +0,0 @@
-# This sample tests the case where an accessed member is a
-# method that has a "self" or "cls" parameter with no explicit
-# type annotation and an inferred type that is based on this value.
-
-
-class A:
-    async def get(self):
-        return self
-
-
-class B(A):
-    pass
-
-
-async def run():
-    val1 = await A().get()
-    reveal_type(val1, expected_text="A")
-
-    val2 = await B().get()
-    reveal_type(val2, expected_text="B")

package/src/tests/samples/memberAccess16.py

@@ -1,12 +0,0 @@
-# This sample tests the case where a member is accessed from a "type"
-# instance or a Type[T].
-
-# pyright: strict
-
-from typing import TypeVar
-
-Cls = TypeVar("Cls")
-
-
-def func(cls: type[Cls]) -> list[type[Cls]]:
-    return cls.__subclasses__()

package/src/tests/samples/memberAccess17.py

@@ -1,31 +0,0 @@
-# This sample tests the case where a __getattr__ method override
-# differentiates based on the name of the accessed member.
-
-from typing import Any, overload, Literal
-
-
-class Obj:
-    @overload
-    def __getattr__(self, name: Literal["foo"]) -> int:
-        ...
-
-    @overload
-    def __getattr__(self, name: Literal["bar"]) -> str:
-        ...
-
-    def __getattr__(self, name: str) -> Any:
-        if name == "foo":
-            return 1
-        return "1"
-
-
-obj = Obj()
-b1 = obj.foo
-reveal_type(b1, expected_text="int")
-b2 = getattr(obj, "foo")
-reveal_type(b2, expected_text="Any")
-
-c1 = obj.bar
-reveal_type(c1, expected_text="str")
-c2 = getattr(obj, "bar")
-reveal_type(c2, expected_text="Any")

package/src/tests/samples/memberAccess18.py

@@ -1,31 +0,0 @@
-# This sample tests that a descriptor returned by a __getattr__ method
-# is not applied as part of a member access expression evaluation.
-
-from typing import Any, Generic, TypeVar
-
-_T = TypeVar("_T")
-
-
-class A:
-    pass
-
-
-class Descriptor:
-    def __get__(self, instance: object, owner: Any) -> A:
-        return A()
-
-
-class CollectionThing(Generic[_T]):
-    thing: _T
-
-    def __getitem__(self, key: str) -> _T:
-        return self.thing
-
-    def __getattr__(self, key: str) -> _T:
-        return self.thing
-
-
-c1: CollectionThing[Descriptor] = CollectionThing()
-
-reveal_type(c1["key"], expected_text="Descriptor")
-reveal_type(c1.key, expected_text="Descriptor")

package/src/tests/samples/memberAccess2.py

@@ -1,45 +0,0 @@
-# This sample verifies that callable variables are bound
-# to instances when they appear within most classes, but
-# not within TypedDict or data classes.
-
-from typing import Callable, NamedTuple, TypedDict
-
-# This class follows the normal rules where variable
-# b, which is callable, acts like a class member and
-# is bound to an instance by the member access operator.
-class Foo1:
-    def __init__(self):
-        self.c = lambda s: s
-
-    def a(self, s: str):
-        return s
-
-    b = lambda a_inst, s: a_inst.inner_str + s
-
-
-sample = Foo1()
-a = sample.a("")
-b = sample.b("")
-c = sample.c("")
-
-d = Foo1.a(Foo1(), "")
-e = Foo1.b(Foo1(), "")
-
-
-# This class is a data class (because it derives from
-# named tuple), so all variables that appear to be class
-# variables are actually instance variables.
-class Foo2(NamedTuple):
-    a: Callable[[int], int]
-
-
-foo2 = Foo2(a=lambda a: a)
-f = foo2.a(3)
-
-
-class Foo3(TypedDict):
-    a: Callable[[int], int]
-
-
-foo3 = Foo3(a=lambda a: a)
-g = foo3["a"](3)

package/src/tests/samples/memberAccess3.py

@@ -1,64 +0,0 @@
-# This sample tests instance and class variable type inference when
-# the type can't be inferred from the class itself and must use
-# the parent class.
-
-
-from typing import Generic, TypeVar
-
-
-class A:
-    pi = 3.1415
-
-    def __init__(self):
-        self.x = 1
-
-
-class B(A):
-    def __init__(self):
-        self.y = "hi"
-
-
-class C(B):
-    def method1(self):
-        a = self.x
-        require_int(a)
-
-        # This should generate an error because a should be an int
-        require_str(a)
-
-        b = self.y
-        require_str(b)
-
-        # This should generate an error because b should be an str
-        require_int(b)
-
-        c = self.pi
-        require_float(c)
-
-        # This should generate an error because c should be a float
-        require_int(c)
-
-
-def require_int(val: int):
-    pass
-
-
-def require_str(val: str):
-    pass
-
-
-def require_float(val: float):
-    pass
-
-
-_TParent = TypeVar("_TParent")
-_TChild = TypeVar("_TChild")
-
-
-class Parent(Generic[_TParent]):
-    member1: _TParent
-
-
-class Child(Parent[_TChild]):
-    def __init__(self, val: _TChild):
-        self.member1 = val

package/src/tests/samples/memberAccess4.py

@@ -1,91 +0,0 @@
-# This sample tests the logic for validating that an explicit
-# "self" or "cls" parameter type is honored when binding the
-# method to an object or class.
-
-from typing import Protocol, Type, TypeVar
-
-
-class HasItemProtocol1(Protocol):
-    item: int
-
-
-class Mixin1:
-    def do_stuff(self: HasItemProtocol1):
-        pass
-
-
-class A1(Mixin1):
-    item = 1
-
-
-class B1(Mixin1):
-    item = "hi"
-
-
-class C1(Mixin1):
-    pass
-
-
-A1().do_stuff()
-
-# This should generate an error because B1 doesn't
-# match the protocol.
-B1().do_stuff()
-
-# This should generate an error because C1 doesn't
-# match the protocol.
-C1().do_stuff()
-
-
-class HasItemProtocol2(Protocol):
-    def must_have(self) -> None:
-        pass
-
-
-class Mixin2:
-    @classmethod
-    def do_stuff(cls: Type[HasItemProtocol2]):
-        pass
-
-
-class A2(Mixin2):
-    def must_have(self) -> None:
-        pass
-
-
-class B2(Mixin2):
-    pass
-
-
-A2.do_stuff()
-
-# This should generate an error because B2 doesn't
-# match the protocol.
-B2.do_stuff()
-
-
-class Bar:
-    pass
-
-
-class Foo:
-    @staticmethod
-    def get_or_create(context: Bar):
-        return object.__getattribute__(context, "")
-
-
-TFoo2 = TypeVar("TFoo2", bound="Foo2")
-
-
-class Foo2:
-    @classmethod
-    def bar(cls: type[TFoo2]) -> TFoo2:
-        ...
-
-    def baz(self) -> None:
-        self.bar()
-
-
-class ClassWithNewOverride:
-    def __new__(cls):
-        return object.__new__(cls)

package/src/tests/samples/memberAccess5.py

@@ -1,26 +0,0 @@
-# This sample tests the handling of unions between
-# objects that provide a __get__ method and those
-# that do not.
-
-from typing import Any, Union
-
-
-class IntProvider:
-    def __get__(self, instance: object, owner: Any) -> int:
-        return 0
-
-
-class Foo:
-    _int_value_declared: Union[IntProvider, int] = 3
-    _int_value_inferred = 3
-
-    def __init__(self):
-        pass
-
-    def get_int_value_1(self) -> int:
-        reveal_type(self._int_value_declared, expected_text="int")
-        return self._int_value_declared
-
-    def get_int_value_2(self) -> int:
-        reveal_type(self._int_value_inferred, expected_text="int")
-        return self._int_value_inferred

package/src/tests/samples/memberAccess6.py

@@ -1,52 +0,0 @@
-# This sample tests member access "set" operations when the target
-# member is an object that doesn't provide a __set__ method.
-
-# pyright: strict
-
-from typing import Any, Generic, Optional, Type, TypeVar, overload
-
-
-_T = TypeVar("_T")
-
-
-class FooBase:
-    pass
-
-
-class Column(Generic[_T]):
-    def __init__(self: "Column[_T]", type: Type[_T]) -> None:
-        ...
-
-    @overload
-    def __get__(self: "Column[_T]", instance: None, type: Any) -> "Column[_T]":
-        ...
-
-    @overload
-    def __get__(self: "Column[_T]", instance: FooBase, type: Any) -> _T:
-        ...
-
-    def __get__(
-        self, instance: Optional[FooBase], type: Any
-    ) -> Optional[_T] | "Column[_T]":
-        ...
-
-
-class Foo(FooBase):
-    bar: Column[str] = Column(str)
-    baz = Column(str)
-
-
-Foo.bar
-Foo().bar
-Foo.baz
-Foo().baz
-
-foo = Foo()
-
-# This should generate an error because bar is declared as containing a
-# Column[str], which doesn't provide a __set__ method.
-foo.bar = ""
-
-# This should generate an error because baz's inferred type is
-# Column[str], which doesn't provide a __set__ method.
-foo.baz = ""

package/src/tests/samples/memberAccess7.py

@@ -1,36 +0,0 @@
-# This sample tests the handling of a __getattr__ method that returns
-# a callable. Such a method should not be bound.
-
-from typing import Callable, TypeVar
-
-
-class ClassA:
-    def __init__(self):
-        return
-
-    def __getattr__(self, key: str) -> Callable[[str], str]:
-        return lambda a: a
-
-
-a = ClassA()
-
-a.foo("hi")
-
-
-T = TypeVar("T")
-
-
-class MetaClass(type):
-    def __getattr__(cls, key: str) -> Callable[[T], T]:
-        return lambda x: x
-
-
-class ClassB(metaclass=MetaClass):
-    pass
-
-
-v1 = ClassB.some_function(3)
-reveal_type(v1, expected_text="int")
-
-v2 = ClassB.some_function("hi")
-reveal_type(v2, expected_text="str")

package/src/tests/samples/memberAccess8.py

@@ -1,75 +0,0 @@
-# This sample tests the use of a generic descriptor class.
-
-from typing import Any, Callable, Generic, Optional, Type, TypeVar, overload
-
-
-_T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
-
-
-class Column(Generic[_T]):
-    def __get__(self, instance: object, type: Any) -> _T:
-        ...
-
-    def __set__(self, instance: object, value: _T) -> _T:
-        ...
-
-    def __delete__(self, instance: object) -> None:
-        ...
-
-
-class Foo:
-    bar: Column[str] = Column()
-    baz: Column[list[int]] = Column()
-
-
-foo = Foo()
-
-v1 = foo.bar
-reveal_type(v1, expected_text="str")
-
-foo.bar = ""
-del foo.bar
-
-
-v2 = foo.baz
-reveal_type(v2, expected_text="list[int]")
-
-foo.baz = [1]
-del foo.baz
-
-
-class Minimal(Generic[_T, _T_co]):
-    def __init__(self, name: str, func: Callable[[_T], _T_co]):
-        ...
-
-    @overload
-    def __get__(self, instance: None, owner: Type[_T]) -> "Minimal[_T, _T_co]":
-        ...
-
-    @overload
-    def __get__(self, instance: _T, owner: Type[_T]) -> _T_co:
-        ...
-
-    def __get__(self, instance: Optional[_T], owner: Type[_T]) -> Any:
-        ...
-
-
-def minimal_property(
-    name: str,
-) -> Callable[[Callable[[_T], _T_co]], Minimal[_T, _T_co]]:
-    def decorator(func: Callable[[_T], _T_co]) -> Minimal[_T, _T_co]:
-        return Minimal(name, func)
-
-    return decorator
-
-
-class B:
-    @minimal_property("foo")
-    def foo(self) -> str:
-        return "hello"
-
-
-b = B()
-reveal_type(b.foo, expected_text="str")
-reveal_type(B.foo, expected_text="Minimal[B, str]")

package/src/tests/samples/memberAccess9.py

@@ -1,11 +0,0 @@
-# This sample tests that the presence of a __getattr__ doesn't
-# mean that an __init__ method is assumed.
-
-
-class GetAttrTest:
-    def __getattr__(self, name: str) -> int:
-        ...
-
-
-def test_get_attr() -> None:
-    a = GetAttrTest()

package/src/tests/samples/metaclass1.py

@@ -1,7 +0,0 @@
-# This sample tests pyright's ability to use metaclasses.
-
-from ctypes import Array, c_uint64
-
-myArray1 = (c_uint64 * 5)()
-
-myArray2: Array[c_uint64] = (c_uint64 * 5)()

package/src/tests/samples/metaclass2.py

@@ -1,35 +0,0 @@
-# This sample verifies that the type checker allows access
-# to class variables provided by a metaclass.
-
-from enum import Enum
-from typing import Mapping
-
-
-class Fruit(Enum):
-    apple = 1
-    orange = 2
-    pear = 3
-
-
-def requires_fruit_mapping(a: Mapping[str, Fruit]):
-    pass
-
-
-requires_fruit_mapping(Fruit.__members__)
-
-aaa = len(Fruit)
-
-for i in Fruit:
-    print(i)
-
-
-class Meta(type):
-    def foo(cls, some_param: str):
-        pass
-
-
-class MyClass(metaclass=Meta):
-    pass
-
-
-MyClass.foo("some argument")