jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test-data/run-async.test

@@ -1,173 +0,0 @@
-# async test cases (compile and run)
-
-[case testAsync]
-import asyncio
-
-async def h() -> int:
-    return 1
-
-async def g() -> int:
-    await asyncio.sleep(0)
-    return await h()
-
-async def f() -> int:
-    return await g()
-
-[file asyncio/__init__.pyi]
-async def sleep(t: float) -> None: ...
-
-[typing fixtures/typing-full.pyi]
-
-[file driver.py]
-from native import f
-import asyncio
-
-result = asyncio.run(f())
-assert result == 1
-
-[case testAsyncWith]
-from testutil import async_val
-
-class async_ctx:
-    async def __aenter__(self) -> str:
-        await async_val("enter")
-        return "test"
-
-    async def __aexit__(self, x, y, z) -> None:
-        await async_val("exit")
-
-
-async def async_with() -> str:
-    async with async_ctx() as x:
-        return await async_val("body")
-
-
-[file driver.py]
-from native import async_with
-from testutil import run_generator
-
-yields, val = run_generator(async_with(), [None, 'x', None])
-assert yields == ('enter', 'body', 'exit'), yields
-assert val == 'x', val
-
-
-[case testAsyncReturn]
-from testutil import async_val
-
-async def async_return() -> str:
-    try:
-        return 'test'
-    finally:
-        await async_val('foo')
-
-[file driver.py]
-from native import async_return
-from testutil import run_generator
-
-yields, val = run_generator(async_return())
-assert yields == ('foo',)
-assert val == 'test', val
-
-
-[case testAsyncFor]
-from typing import AsyncIterable, List, Set, Dict
-
-async def async_iter(xs: AsyncIterable[int]) -> List[int]:
-    ys = []
-    async for x in xs:
-        ys.append(x)
-    return ys
-
-async def async_comp(xs: AsyncIterable[int]) -> List[int]:
-    ys = [x async for x in xs]
-    return ys
-
-async def async_comp_set(xs: AsyncIterable[int]) -> Set[int]:
-    return {x async for x in xs}
-
-async def async_comp_dict(xs: AsyncIterable[int]) -> Dict[int, str]:
-    return {x: str(x) async for x in xs}
-
-[typing fixtures/typing-full.pyi]
-
-[file driver.py]
-from native import async_iter, async_comp, async_comp_set, async_comp_dict
-from testutil import run_generator, async_val
-from typing import AsyncIterable, List
-
-# defined here since we couldn't do it inside the test yet...
-async def foo() -> AsyncIterable[int]:
-    for x in range(3):
-        await async_val(x)
-        yield x
-
-yields, val = run_generator(async_iter(foo()))
-assert val == [0,1,2], val
-assert yields == (0,1,2), yields
-
-yields, val = run_generator(async_comp(foo()))
-assert val == [0,1,2], val
-assert yields == (0,1,2), yields
-
-yields, val = run_generator(async_comp_set(foo()))
-assert val == {0,1,2}, val
-assert yields == (0,1,2), yields
-
-yields, val = run_generator(async_comp_dict(foo()))
-assert val == {0: '0',1: '1', 2: '2'}, val
-assert yields == (0,1,2), yields
-
-[case testAsyncFor2]
-from typing import AsyncIterable, List
-
-async def async_iter(xs: AsyncIterable[int]) -> List[int]:
-    ys = []
-    async for x in xs:
-        ys.append(x)
-    return ys
-
-[typing fixtures/typing-full.pyi]
-
-[file driver.py]
-from native import async_iter
-from testutil import run_generator, async_val
-from typing import AsyncIterable, List
-
-# defined here since we couldn't do it inside the test yet...
-async def foo() -> AsyncIterable[int]:
-    for x in range(3):
-        await async_val(x)
-        yield x
-    raise Exception('lol no')
-
-yields, val = run_generator(async_iter(foo()))
-assert yields == (0,1,2), yields
-assert val == 'lol no', val
-
-[case testAsyncWithVarReuse]
-class ConMan:
-    async def __aenter__(self) -> int:
-        return 1
-    async def __aexit__(self, *exc: object):
-        pass
-
-class ConManB:
-    async def __aenter__(self) -> int:
-        return 2
-    async def __aexit__(self, *exc: object):
-        pass
-
-async def x() -> None:
-    value = 2
-    async with ConMan() as f:
-        value += f
-    assert value == 3, value
-    async with ConManB() as f:
-        value += f
-    assert value == 5, value
-
-[typing fixtures/typing-full.pyi]
-[file driver.py]
-import asyncio
-import native
-asyncio.run(native.x())

jaclang/vendor/mypyc/test-data/run-attrs.test

@@ -1,318 +0,0 @@
--- Test cases for dataclasses based on the attrs library, where auto_attribs=True
-
-[case testRunAttrsclass]
-import attr
-from typing import Set, List, Callable, Any
-
-@attr.s(auto_attribs=True)
-class Person1:
-    age : int
-    name : str
-
-    def __bool__(self) -> bool:
-        return self.name == 'robot'
-
-def testBool(p: Person1) -> bool:
-    if p:
-        return True
-    else:
-        return False
-
-@attr.s(auto_attribs=True)
-class Person1b(Person1):
-    id: str = '000'
-
-@attr.s(auto_attribs=True)
-class Person2:
-    age : int
-    name : str = attr.ib(default='robot')
-
-@attr.s(auto_attribs=True, order=True)
-class Person3:
-    age : int = attr.ib(default = 6)
-    friendIDs : List[int] = attr.ib(factory = list)
-
-    def get_age(self) -> int:
-        return (self.age)
-
-    def set_age(self, new_age : int) -> None:
-        self.age = new_age
-
-    def add_friendID(self, fid : int) -> None:
-        self.friendIDs.append(fid)
-
-    def get_friendIDs(self) -> List[int]:
-        return self.friendIDs
-
-def get_next_age(g: Callable[[Any], int]) -> Callable[[Any], int]:
-    def f(a: Any) -> int:
-        return g(a) + 1
-    return f
-
-@attr.s(auto_attribs=True)
-class Person4:
-    age : int
-    _name : str = 'Bot'
-
-    @get_next_age
-    def get_age(self) -> int:
-        return self.age
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-@attr.s(auto_attribs=True)
-class Point:
-     x : int = attr.ib(converter=int)
-     y : int = attr.ib(init=False)
-
-     def __attrs_post_init__(self):
-         self.y = self.x + 1
-
-
-[file other.py]
-from native import Person1, Person1b, Person2, Person3, Person4, testBool, Point
-i1 = Person1(age = 5, name = 'robot')
-assert i1.age == 5
-assert i1.name == 'robot'
-assert testBool(i1) == True
-assert testBool(Person1(age = 5, name = 'robo')) == False
-i1b = Person1b(age = 5, name = 'robot')
-assert i1b.age == 5
-assert i1b.name == 'robot'
-assert i1b.id == '000'
-assert testBool(i1b) == True
-assert testBool(Person1b(age = 5, name = 'robo')) == False
-i1c = Person1b(age = 20, name = 'robot', id = 'test')
-assert i1c.age == 20
-assert i1c.id == 'test'
-
-i2 = Person2(age = 5)
-assert i2.age == 5
-assert i2.name == 'robot'
-i3 = Person2(age = 5, name = 'new_robot')
-assert i3.age == 5
-assert i3.name == 'new_robot'
-i4 = Person3()
-assert i4.age == 6
-assert i4.friendIDs == []
-i5 = Person3(age = 5)
-assert i5.age == 5
-assert i5.friendIDs == []
-i6 = Person3(age = 5, friendIDs = [1,2,3])
-assert i6.age == 5
-assert i6.friendIDs == [1,2,3]
-assert i6.get_age() == 5
-i6.set_age(10)
-assert i6.get_age() == 10
-i6.add_friendID(4)
-assert i6.get_friendIDs() == [1,2,3,4]
-i7 = Person4(age = 5)
-assert i7.get_age() == 6
-i7.age += 3
-assert i7.age == 8
-assert i7.name == 'Bot'
-i8 = Person3(age = 1, friendIDs = [1,2])
-i9 = Person3(age = 1, friendIDs = [1,2])
-assert i8 == i9
-i8.age = 2
-assert i8 > i9
-
-assert Person1.__annotations__ == {'age': int, 'name': str}
-assert Person2.__annotations__ == {'age': int, 'name': str}
-
-p1 = Point(2)
-assert p1.x == 2
-assert p1.y == 3
-p2 = Point('2')
-assert p2.x == 2
-assert p2.y == 3
-
-assert Point.__annotations__ == {'x': int, 'y': int}
-
-[file driver.py]
-import sys
-
-# PEP 526 introduced in 3.6
-version = sys.version_info[:2]
-if version[0] < 3 or version[1] < 6:
-    exit()
-
-# Run the tests in both interpreted and compiled mode
-import other
-import other_interpreted
-
-# Test for an exceptional cases
-from testutil import assertRaises
-from native import Person1, Person1b, Person3
-from types import BuiltinMethodType
-
-with assertRaises(TypeError, "missing 1 required positional argument"):
-    Person1(0)
-
-with assertRaises(TypeError, "missing 2 required positional arguments"):
-    Person1b()
-
-with assertRaises(TypeError, "int object expected; got str"):
-    Person1('nope', 'test')
-
-p = Person1(0, 'test')
-with assertRaises(TypeError, "int object expected; got str"):
-    p.age = 'nope'
-
-assert isinstance(Person3().get_age, BuiltinMethodType)
-
-
-[case testRunAttrsclassNonAuto]
-import attr
-from typing import Set, List, Callable, Any
-
-@attr.s
-class Person1:
-    age = attr.ib(type=int)
-    name = attr.ib(type=str)
-
-    def __bool__(self) -> bool:
-        return self.name == 'robot'
-
-def testBool(p: Person1) -> bool:
-    if p:
-        return True
-    else:
-        return False
-
-@attr.s
-class Person1b(Person1):
-    id = attr.ib(type=str, default='000')
-
-@attr.s
-class Person2:
-    age = attr.ib(type=int)
-    name = attr.ib(type=str, default='robot')
-
-@attr.s(order=True)
-class Person3:
-    age = attr.ib(type=int, default=6)
-    friendIDs = attr.ib(factory=list, type=List[int])
-
-    def get_age(self) -> int:
-        return (self.age)
-
-    def set_age(self, new_age : int) -> None:
-        self.age = new_age
-
-    def add_friendID(self, fid : int) -> None:
-        self.friendIDs.append(fid)
-
-    def get_friendIDs(self) -> List[int]:
-        return self.friendIDs
-
-def get_next_age(g: Callable[[Any], int]) -> Callable[[Any], int]:
-    def f(a: Any) -> int:
-        return g(a) + 1
-    return f
-
-@attr.s
-class Person4:
-    age = attr.ib(type=int)
-    _name = attr.ib(type=str, default='Bot')
-
-    @get_next_age
-    def get_age(self) -> int:
-        return self.age
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-@attr.s
-class Point:
-     x = attr.ib(type=int, converter=int)
-     y = attr.ib(type=int, init=False)
-
-     def __attrs_post_init__(self):
-         self.y = self.x + 1
-
-
-[file other.py]
-from native import Person1, Person1b, Person2, Person3, Person4, testBool, Point
-i1 = Person1(age = 5, name = 'robot')
-assert i1.age == 5
-assert i1.name == 'robot'
-assert testBool(i1) == True
-assert testBool(Person1(age = 5, name = 'robo')) == False
-i1b = Person1b(age = 5, name = 'robot')
-assert i1b.age == 5
-assert i1b.name == 'robot'
-assert i1b.id == '000'
-assert testBool(i1b) == True
-assert testBool(Person1b(age = 5, name = 'robo')) == False
-i1c = Person1b(age = 20, name = 'robot', id = 'test')
-assert i1c.age == 20
-assert i1c.id == 'test'
-
-i2 = Person2(age = 5)
-assert i2.age == 5
-assert i2.name == 'robot'
-i3 = Person2(age = 5, name = 'new_robot')
-assert i3.age == 5
-assert i3.name == 'new_robot'
-i4 = Person3()
-assert i4.age == 6
-assert i4.friendIDs == []
-i5 = Person3(age = 5)
-assert i5.age == 5
-assert i5.friendIDs == []
-i6 = Person3(age = 5, friendIDs = [1,2,3])
-assert i6.age == 5
-assert i6.friendIDs == [1,2,3]
-assert i6.get_age() == 5
-i6.set_age(10)
-assert i6.get_age() == 10
-i6.add_friendID(4)
-assert i6.get_friendIDs() == [1,2,3,4]
-i7 = Person4(age = 5)
-assert i7.get_age() == 6
-i7.age += 3
-assert i7.age == 8
-assert i7.name == 'Bot'
-i8 = Person3(age = 1, friendIDs = [1,2])
-i9 = Person3(age = 1, friendIDs = [1,2])
-assert i8 == i9
-i8.age = 2
-assert i8 > i9
-
-p1 = Point(2)
-assert p1.x == 2
-assert p1.y == 3
-p2 = Point('2')
-assert p2.x == 2
-assert p2.y == 3
-
-[file driver.py]
-import sys
-
-# Run the tests in both interpreted and compiled mode
-import other
-import other_interpreted
-
-# Test for an exceptional cases
-from testutil import assertRaises
-from native import Person1, Person1b, Person3
-from types import BuiltinMethodType
-
-with assertRaises(TypeError, "missing 1 required positional argument"):
-    Person1(0)
-
-with assertRaises(TypeError, "missing 2 required positional arguments"):
-    Person1b()
-
-with assertRaises(TypeError, "int object expected; got str"):
-    Person1('nope', 'test')
-
-p = Person1(0, 'test')
-with assertRaises(TypeError, "int object expected; got str"):
-    p.age = 'nope'
-
-assert isinstance(Person3().get_age, BuiltinMethodType)

jaclang/vendor/mypyc/test-data/run-bench.test

@@ -1,196 +0,0 @@
--- TODO: build some generic benchmark harness
-[case testBenchmarkTree]
-from typing import Optional
-class Node:
-    def __init__(self, value: int) -> None:
-        self.value = value
-        self.left = None  # type: Optional[Node]
-        self.right = None  # type: Optional[Node]
-    def sum(self) -> int:
-        left = 0
-        if self.left is not None:
-            left = self.left.sum()
-        right = 0
-        if self.right is not None:
-            right = self.right.sum()
-        return self.value + left + right
-def sum_tree(x: Optional[Node]) -> int:
-    if x is None:
-        return 0
-    return x.value + sum_tree(x.left) + sum_tree(x.right)
-def build(n: int) -> Optional[Node]:
-    if n == 0:
-        return None
-    x = Node(n)
-    x.left = build(n - 1)
-    x.right = x.left
-    return x
-
-def bench_sum(x: Optional[Node]) -> None:
-    for i in range(1000000):
-        sum_tree(x)
-def bench_sum_method(x: Node) -> None:
-    for i in range(1000000):
-        x.sum()
-[file driver.py]
-from typing import Optional
-import native
-import interpreted
-from timeit import timeit
-from time import time
-import os
-
-def dumb_time(f):
-    t0 = time()
-    f()
-    t1 = time()
-    return t1 - t0
-
-def basic_test(m):
-    tree = m.build(5)
-    assert(m.sum_tree(tree) == 57)
-    assert(tree.sum() == 57)
-    return tree
-
-def test(m):
-    tree = basic_test(m)
-
-    g = {**globals(), **locals()}
-    sum = timeit('m.sum_tree(tree)', globals=g)
-    sum2 = timeit('tree.sum()', globals=g)
-    fsum = dumb_time(lambda: m.bench_sum(tree))
-    fsum2 = dumb_time(lambda: m.bench_sum_method(tree))
-    build = timeit('m.build(5)', globals=g)
-    return (sum, sum2, fsum, fsum2, build)
-
-# Basic functionality test
-basic_test(native)
-
-# Benchmark if we are benchmarking
-if os.environ.get('MYPYC_RUN_BENCH') == '1':
-    nsum, nsum2, nfsum, nfsum2, nbuild = test(native)
-    isum, isum2, ifsum, ifsum2, ibuild = test(interpreted)
-    print(nsum, nsum2, nfsum, nbuild)
-    print("Sum speedup:", isum/nsum)
-    print("Sum method speedup:", isum2/nsum2)
-    print("Sum (fast) speedup:", ifsum/nfsum)
-    print("Sum (fast) method speedup:", ifsum2/nfsum2)
-    print("Build speedup:", ibuild/nbuild)
-
-[case testBenchmarkVisitorTree]
-from mypy_extensions import trait
-from typing import cast, Generic, TypeVar, Any
-
-T = TypeVar('T')
-class Tree:
-    def accept(self, v: 'TreeVisitor[T]') -> T:
-        pass
-class Leaf(Tree):
-    def accept(self, v: 'TreeVisitor[T]') -> T:
-        return v.visit_leaf(self)
-class Node(Tree):
-    def __init__(self, value: int, left: Tree, right: Tree) -> None:
-        self.value = value
-        self.left = left
-        self.right = right
-    def accept(self, v: 'TreeVisitor[T]') -> T:
-        return v.visit_node(self)
-
-@trait
-class TreeVisitor(Generic[T]):
-    def visit_leaf(self, x: Leaf) -> T: return cast(T, None)
-    def visit_node(self, x: Node) -> T: return cast(T, None)
-
-class SumVisitor(TreeVisitor[int]):
-    def sum(self, x: Tree) -> int:
-        return x.accept(self)
-    def visit_leaf(self, x: Leaf) -> int:
-        return 0
-    def visit_node(self, x: Node) -> int:
-        return x.value + self.sum(x.left) + self.sum(x.right)
-
-def equal(x: Tree, y: Tree) -> bool:
-    return EqualVisitor(x).equal(y)
-
-class EqualVisitor(TreeVisitor[bool]):
-    def __init__(self, left: Tree) -> None:
-        self.left = left
-    def equal(self, right: Tree) -> bool:
-        return right.accept(self)
-    def visit_leaf(self, right: Leaf) -> bool:
-        return isinstance(self.left, Leaf)
-    def visit_node(self, right: Node) -> bool:
-        if isinstance(self.left, Node):
-            # our boolean stuff is crap
-            if (self.left.value == right.value and equal(self.left.left, right.left)
-                    and equal(self.left.right, right.right)):
-                return True
-        return False
-
-def sum_tree(x: Tree) -> int:
-    return SumVisitor().sum(x)
-
-def build(n: int) -> Tree:
-    if n == 0:
-        return Leaf()
-    return Node(n, build(n - 1), build(n - 1))
-
-def bench_sum_tree(x: Tree) -> None:
-    for i in range(100000):
-        sum_tree(x)
-def bench_equal_tree(x: Tree, y: Tree) -> None:
-    for i in range(100000):
-        equal(x, y)
-
-[file driver.py]
-from typing import Optional
-import interpreted
-import native
-from timeit import timeit
-from time import time
-import os
-import sys
-
-# Side test: some stuff about MROs and generics
-if sys.version_info[:3] > (3, 5, 2):
-    assert tuple(x.__name__ for x in interpreted.SumVisitor.mro()) == ('SumVisitor', 'TreeVisitor', 'Generic', 'object')
-    assert tuple(x.__name__ for x in native.SumVisitor.mro()) == ('SumVisitor', 'TreeVisitor', 'Generic', 'object')
-    assert str(native.TreeVisitor[native.T]) == "native.TreeVisitor[~T]"
-
-assert native.TreeVisitor.__name__ == "TreeVisitor"
-assert native.SumVisitor.__name__ == "SumVisitor"
-
-def dumb_time(f):
-    t0 = time()
-    f()
-    t1 = time()
-    return t1 - t0
-
-def basic_test(m):
-    tree = m.build(5)
-    tree2 = m.build(5)
-    tree2.right.right.right.value = 10
-    assert m.sum_tree(tree) == 57
-    assert m.equal(tree, tree)
-    assert not m.equal(tree, tree2)
-
-    assert isinstance(native.SumVisitor(), native.TreeVisitor)
-
-    return tree
-
-def test(m):
-    tree = basic_test(m)
-
-    g = {**globals(), **locals()}
-    fsum = dumb_time(lambda: m.bench_sum_tree(tree))
-    feq = dumb_time(lambda: m.bench_equal_tree(tree, tree))
-    return fsum, feq
-
-basic_test(native)
-
-if os.environ.get('MYPYC_RUN_BENCH') == '1':
-    nfsum, nfeq = test(native)
-    ifsum, ifeq = test(interpreted)
-    print(nfsum)
-    print("Sum speedup:", ifsum/nfsum)
-    print("Equal speedup:", ifeq/nfeq)