mypy-dev 1.9.0.dev0__py3-none-any.whl

mypyc/test-data/run-traits.test

@@ -0,0 +1,411 @@
+[case testTraitBasic1]
+from mypy_extensions import trait
+
+class A:
+    line: int
+    def foo(self) -> None:
+        print("foo")
+
+@trait
+class T:
+    def bar(self) -> None:
+        print("bar")
+    def baz(self) -> object:
+        return None
+
+class C(A, T):
+    def baz(self) -> int:
+        return 10
+
+def use_t(t: T) -> object:
+    t.bar()
+    return t.baz()
+
+def use_c(c: C) -> int:
+    use_t(c)
+    c.foo()
+    c.bar()
+    return c.baz()
+
+use_t(C())
+
+# This trait is dead code but there's no reason it shouldn't compile
+@trait
+class ChildlessTrait:
+    def __init__(self) -> None:
+        pass
+
+[file driver.py]
+from native import A, T, C, use_c, use_t
+c = C()
+c.foo()
+c.bar()
+assert c.baz() == 10
+assert use_c(c) == 10
+assert use_t(c) == 10
+[out]
+bar
+foo
+bar
+bar
+foo
+bar
+bar
+
+[case testTraitBasic2]
+from mypy_extensions import trait
+
+class A:
+    line: int
+    def foo(self) -> None:
+        print("foo")
+
+@trait
+class T:
+    def bar(self) -> None:
+        print("bar", self.baz())
+    def baz(self) -> int:
+        return -1
+
+@trait
+class T2:
+    line: int
+    def baz(self) -> int:
+        return -2
+
+class C(A, T):
+    def __init__(self) -> None:
+        self.line = 1337
+        self.x = 12
+    def baz(self) -> int:
+        return self.x
+
+class D(C, T2):
+    def __init__(self) -> None:
+        self.line = 1337
+        self.x = 13
+
+@trait
+class T3:
+    def baz(self) -> int:
+        return -2
+
+class E(T3):
+    def __init__(self) -> None:
+        pass
+
+
+def use_t(t: T) -> None:
+    t.bar()
+def use_t2(t: T2) -> int:
+    t.line = t.line
+    return t.line
+
+def use_c(c: C) -> int:
+    use_t(c)
+    c.foo()
+    c.bar()
+    return c.line
+
+def use_d(d: D) -> int:
+    return d.baz()
+
+[file driver.py]
+from native import A, T, C, D, use_c, use_t, use_d, use_t2
+c = C()
+d = D()
+c.foo()
+c.bar()
+print("baz", c.baz())
+print("baz", d.baz())
+use_c(c)
+use_t(c)
+use_c(d)
+use_t(d)
+assert use_d(d) == 13
+print(d.line)
+assert d.line == 1337
+assert use_t2(d) == 1337
+[out]
+foo
+bar 12
+baz 12
+baz 13
+bar 12
+foo
+bar 12
+bar 12
+bar 13
+foo
+bar 13
+bar 13
+1337
+
+[case testTrait3]
+from mypy_extensions import trait
+from typing import Generic, TypeVar
+
+@trait
+class T1: pass
+@trait
+class T2: pass
+
+T = TypeVar('T')
+
+class C(Generic[T], T1, T2):
+    pass
+
+@trait
+class S1(Generic[T]):
+    def foo(self) -> None: pass
+    def bar(self, x: T) -> T: raise Exception
+
+@trait
+class S2(S1[T]):
+    def bar(self, x: T) -> T: return x
+
+@trait
+class S3(S2[T]):
+    def bar(self, x: T) -> T: return x
+
+class D(S3[bool]):
+    def bar(self, x: bool) -> bool: return x
+
+
+[file driver.py]
+import native
+
+[case testTrait4]
+from mypy_extensions import trait
+from typing import Generic, TypeVar
+
+T = TypeVar('T')
+
+
+@trait
+class S1(Generic[T]):
+    def bar(self) -> T: raise Exception
+
+class S2(S1[bool]):
+    def bar(self) -> bool: return False
+
+class D(S2):
+    pass
+
+def lol(x: S1) -> None:
+    x.bar()
+
+[file driver.py]
+import native
+native.lol(native.D())
+
+[case testTraitOrdering]
+import other_b
+# Regression test for a bug where inheriting from a class that
+# inherited from a trait that got processed later on the command line
+# filed to compile.
+[file other_b.py]
+from other_c import Plugin
+
+class Whatever(Plugin):
+    pass
+
+[file other_c.py]
+from mypy_extensions import trait
+
+@trait
+class Base:
+    x = None  # type: int
+
+class Plugin(Base):
+    def __init__(self) -> None:
+        self.x = 10
+
+[file driver.py]
+from native import *
+
+[case testDiamond]
+from mypy_extensions import trait
+
+@trait
+class Base:
+    def get_value(self) -> str:
+        return "Base"
+
+@trait
+class Trait(Base):
+    def get_value(self) -> str:
+        return "Trait"
+
+class Message(Base):
+    def show_message(self) -> None:
+        print("I am a " + self.get_value())
+
+class DerivedMessage(Message, Trait):
+    pass
+
+[file driver.py]
+from native import *
+a = Message()
+a.show_message()
+b = DerivedMessage()
+b.show_message()
+
+[out]
+I am a Base
+I am a Trait
+
+[case testTraitAttrsSubTrait]
+from mypy_extensions import trait
+
+class A:
+    a: int
+
+@trait
+class T1:
+    x: int
+
+@trait
+class T2(T1):
+    y: int
+
+class C(A, T2):
+    c: int
+
+def f(t1: T1, t2: T2) -> None:
+    t1.x, t2.x = t2.x, t1.x
+
+def g(t1: T1, t2: T2) -> None:
+    t2.y = t1.x
+
+def get_x(c: C) -> int:
+    return c.x
+
+def get_y(c: C) -> int:
+    return c.y
+
+[file driver.py]
+from native import C, f, g, get_x, get_y
+
+c1 = C()
+c2 = C()
+
+c1.x = 1
+c1.y = 0
+c2.x = 2
+c2.y = 0
+
+f(c1, c2)
+assert c1.x == 2
+assert c2.x == 1
+assert get_x(c1) == 2
+assert get_x(c2) == 1
+
+assert get_y(c2) == 0
+g(c1, c2)
+assert get_y(c2) == 2
+[out]
+
+[case testTraitAttrsTriangle]
+from mypy_extensions import trait
+
+class A:
+    a: int
+
+@trait
+class T(A):
+    x: int
+    def meth(self) -> int:
+        return self.a
+
+class B(A):
+    b: int
+
+class C(B, T):
+    pass
+
+def take_t(t: T) -> int:
+    return t.x + t.meth()
+
+def take_c(c: C) -> int:
+    return c.x + c.meth()
+
+[file driver.py]
+from native import C, take_t, take_c
+
+c = C()
+c.a = 1
+c.x = 10
+
+assert take_t(c) == take_c(c) == 11
+[out]
+
+[case testTraitAttrsTree]
+from mypy_extensions import trait
+
+class A:
+    a: int
+
+@trait
+class T1:
+    x: int
+
+class B(A, T1):
+    b: int
+
+@trait
+class T2:
+    x: int
+
+class C(B, T2):
+    pass
+
+def f(t1: T1, t2: T2) -> None:
+    t1.x, t2.x = t2.x, t1.x
+
+def g(c1: C, c2: C) -> None:
+    c1.x, c2.x = c2.x, c1.x
+
+[file driver.py]
+from native import C, f, g
+
+c1 = C()
+c2 = C()
+
+c1.x = 1
+c2.x = 2
+
+f(c1, c2)
+assert c1.x == 2
+assert c2.x == 1
+
+g(c1, c2)
+assert c1.x == 1
+assert c2.x == 2
+[out]
+
+[case testTraitErrorMessages]
+from mypy_extensions import trait
+
+@trait
+class Trait:
+    pass
+
+def create() -> Trait:
+    return Trait()
+
+[file driver.py]
+from native import Trait, create
+from testutil import assertRaises
+
+with assertRaises(TypeError, "traits may not be directly created"):
+    Trait()
+
+with assertRaises(TypeError, "traits may not be directly created"):
+    create()
+
+class Sub(Trait):
+    pass
+
+with assertRaises(TypeError, "interpreted classes cannot inherit from compiled traits"):
+    Sub()

mypyc/test-data/run-tuples.test

@@ -0,0 +1,258 @@
+# Test cases for tuples (compile and run)
+
+[case testTuple]
+from typing import List, Optional, Tuple
+from typing import Tuple
+def f(x: Tuple[int, int]) -> Tuple[int,int]:
+    return x
+
+def lurr(x: List[Optional[Tuple[int, str]]]) -> object:
+    return x[0]
+
+def asdf(x: Tuple[int, str]) -> None:
+    pass
+[file driver.py]
+from testutil import assertRaises
+from native import f, lurr, asdf
+
+assert f((1,2)) == (1, 2)
+assert lurr([(1, '2')]) == (1, '2')
+
+with assertRaises(TypeError):
+    print(lurr([(1, 2)]))
+
+with assertRaises(TypeError):
+    asdf((1, 2))
+
+[case testTupleGet]
+from typing import Tuple
+def f(x: Tuple[Tuple[int, bool], int]) -> int:
+    return x[0][0]
+[file driver.py]
+from native import f
+print(f(((1,True),2)))
+big_number = pow(2, 80)
+print(f(((big_number,True),2)))
+[out]
+1
+1208925819614629174706176
+
+[case testSequenceTupleArg]
+from typing import Tuple
+def f(x: Tuple[int, ...]) -> int:
+    return x[1]
+[file driver.py]
+from native import f
+print(f((1,2,3,4)))
+[out]
+2
+
+[case testTupleAttr]
+from typing import Tuple
+class C:
+    b: Tuple[Tuple[Tuple[int, int], int], int, str, object]
+    c: Tuple[()]
+def f() -> None:
+    c = C()
+    c.b = (((1, 2), 2), 1, 'hi', 'hi2')
+    print(c.b)
+
+def g() -> None:
+    try:
+        h()
+    except Exception:
+        print('caught the exception')
+
+def h() -> Tuple[Tuple[Tuple[int, int], int], int, str, object]:
+    raise Exception('Intentional exception')
+[file driver.py]
+from native import f, g, C
+f()
+g()
+assert not hasattr(C(), 'c')
+[out]
+(((1, 2), 2), 1, 'hi', 'hi2')
+caught the exception
+
+[case testNamedTupleAttributeRun]
+from typing import NamedTuple
+
+NT = NamedTuple('NT', [('x', int), ('y', int)])
+
+def f(nt: NT) -> int:
+    if nt.x > nt.y:
+        return nt.x
+    return nt.y
+
+nt = NT(1, 2)
+[file driver.py]
+from native import NT, nt, f
+
+assert f(nt) == 2
+assert f(NT(3, 2)) == 3
+
+class Sub(NT):
+    pass
+assert f(Sub(3, 2)) == 3
+
+-- Ref: https://github.com/mypyc/mypyc/issues/924
+[case testNamedTupleClassSyntax]
+from typing import Dict, List, NamedTuple, Optional, Tuple, Union
+from typing_extensions import final
+
+class FuncIR: pass
+
+StealsDescription = Union[bool, List[bool]]
+
+class Record(NamedTuple):
+    st_mtime: float
+    st_size: int
+    is_borrowed: bool
+    hash: str
+    python_path: Tuple[str, ...]
+    type: 'ClassIR'
+    method: FuncIR
+    shadow_method: Optional[FuncIR]
+    classes: Dict[str, 'ClassIR']
+    steals: StealsDescription
+    ordering: Optional[List[int]]
+    extra_int_constants: List[Tuple[int]]
+
+# Make sure mypyc loads the annotation string for this forward reference.
+# Ref: https://github.com/mypyc/mypyc/issues/938
+class ClassIR: pass
+
+# Ref: https://github.com/mypyc/mypyc/issues/927
+@final
+class Inextensible(NamedTuple):
+    x: int
+
+[file driver.py]
+from typing import ForwardRef, Optional
+from native import ClassIR, FuncIR, Record
+
+assert Record.__annotations__ == {
+    'st_mtime': float,
+    'st_size': int,
+    'is_borrowed': bool,
+    'hash': str,
+    'python_path': tuple,
+    'type': ForwardRef('ClassIR'),
+    'method': FuncIR,
+    'shadow_method': type,
+    'classes': dict,
+    'steals': type,
+    'ordering': type,
+    'extra_int_constants': list,
+}, Record.__annotations__
+
+[case testTupleOps]
+from typing import Tuple, List, Any, Optional
+from typing_extensions import Final
+
+def f() -> Tuple[()]:
+    return ()
+
+def test_empty_tuple() -> None:
+    assert f() == ()
+
+def f2() -> Any:
+    return ()
+
+def test_empty_tuple_with_any_type():
+    assert f2() == ()
+
+def f3() -> int:
+    x = (False, 1)
+    return x[1]
+
+def test_new_tuple() -> None:
+    assert f3() == 1
+
+def f4(y: int) -> int:
+    x = (False, y)
+    return x[1]
+
+def test_new_tuple_boxed_int() -> None:
+    big_number = 1208925819614629174706176
+    assert f4(big_number) == big_number
+
+def f5(x: List[int]) -> int:
+    return tuple(x)[1]
+
+def test_sequence_tuple() -> None:
+    assert f5([1,2,3,4]) == 2
+
+def f6(x: List[int]) -> int:
+    return len(tuple(x))
+
+def test_sequence_tuple_len() -> None:
+    assert f6([1,2,3,4]) == 4
+
+def f7(x: List[Tuple[int, int]]) -> int:
+    a, b = x[0]
+    return a + b
+
+def test_unbox_tuple() -> None:
+    assert f7([(5, 6)]) == 11
+
+# Test that order is irrelevant to unions. Really I only care that this builds.
+
+class A:
+    pass
+
+def lol() -> A:
+    return A()
+
+def foo(x: bool, y: bool) -> Tuple[Optional[A], bool]:
+    z = lol()
+
+    return None if y else z, x
+
+def test_slicing() -> None:
+    # Use dummy adds to avoid constant folding
+    zero = int()
+    two = zero + 2
+    s: Tuple[str, ...] = ("f", "o", "o", "b", "a", "r")
+    assert s[two:] == ("o", "b", "a", "r")
+    assert s[:two] == ("f", "o")
+    assert s[two:-two] == ("o", "b")
+    assert s[two:two] == ()
+    assert s[two:two + 1] == ("o",)
+    assert s[-two:] == ("a", "r")
+    assert s[:-two] == ("f", "o", "o", "b")
+    assert s[:] == ("f", "o", "o", "b", "a", "r")
+    assert s[two:333] == ("o", "b", "a", "r")
+    assert s[333:two] == ()
+    assert s[two:-333] == ()
+    assert s[-333:two] == ("f", "o")
+    long_int: int = 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000
+    assert s[1:long_int] == ("o", "o", "b", "a", "r")
+    assert s[long_int:] == ()
+    assert s[-long_int:-1] == ("f", "o", "o", "b", "a")
+
+def f8(val: int) -> bool:
+    return val % 2 == 0
+
+def test_sequence_generator() -> None:
+    source_list = [1, 2, 3]
+    a = tuple(f8(x) for x in source_list)
+    assert a == (False, True, False)
+
+    source_tuple: Tuple[int, ...] = (1, 2, 3)
+    a = tuple(f8(x) for x in source_tuple)
+    assert a == (False, True, False)
+
+    source_fixed_length_tuple = (1, 2, 3, 4)
+    a = tuple(f8(x) for x in source_fixed_length_tuple)
+    assert a == (False, True, False, True)
+
+    source_str = 'abbc'
+    b = tuple('s:' + x for x in source_str)
+    assert b == ('s:a', 's:b', 's:b', 's:c')
+
+TUPLE: Final[Tuple[str, ...]] = ('x', 'y')
+
+def test_final_boxed_tuple() -> None:
+    t = TUPLE
+    assert t == ('x', 'y')