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

jaclang/vendor/mypyc/test-data/run-mypy-sim.test

@@ -1,138 +0,0 @@
--- Some test code that tries to simulate important/interesting parts of mypy itself!
-[case testSimulateMypy]
-from mypy_extensions import trait
-from typing import List, TypeVar, cast, Generic
-from abc import abstractmethod
-import other_strconv as strconv
-#from other_visitor import ExpressionVisitor, StatementVisitor, NodeVisitor
-import other_visitor as visitor
-
-T = TypeVar('T')
-
-############ nodes.py
-
-class Context:
-    def __init__(self) -> None:
-        self.line = -1
-    def set_line(self, line: int) -> None:
-        self.line = line
-
-class Node(Context):
-    def accept(self, visitor: visitor.NodeVisitor[T]) -> T: return cast(T, None)
-    def to_str(self) -> str:
-        return self.accept(strconv.StrConv())
-
-@trait
-class Statement(Node):
-    def accept(self, visitor: visitor.StatementVisitor[T]) -> T: return cast(T, None)
-
-@trait
-class Expression(Node):
-    def accept(self, visitor: visitor.ExpressionVisitor[T]) -> T: return cast(T, None)
-
-@trait
-class SymbolNode(Node):
-    """Nodes that can be stored in a symbol table."""
-    @abstractmethod
-    def name(self) -> str: return cast(str, None)
-
-class FuncBase(Node):
-    def __init__(self) -> None:
-        super().__init__()
-        self.is_static = False
-
-class Block(Statement):
-    def __init__(self, stmts: List[Statement]) -> None:
-        self.stmts = stmts
-
-    def accept(self, visitor: visitor.StatementVisitor[T]) -> T:
-        return visitor.visit_block(self)
-
-class ExprStmt(Statement):
-    def __init__(self, expr: Expression) -> None:
-        self.expr = expr
-
-    def accept(self, visitor: visitor.StatementVisitor[T]) -> T:
-        return visitor.visit_expr_stmt(self)
-
-class FuncItem(FuncBase):
-    def __init__(self, body: Block) -> None:
-        self.body = body
-
-class FuncDef(FuncItem, SymbolNode, Statement):
-    def __init__(self, name: str, body: Block) -> None:
-        super().__init__(body)
-        self._name = name
-    def accept(self, visitor: visitor.StatementVisitor[T]) -> T:
-        return visitor.visit_func_def(self)
-    def name(self) -> str:
-        return self._name
-
-class LambdaExpr(FuncItem, Expression):
-    def accept(self, visitor: visitor.ExpressionVisitor[T]) -> T:
-        return visitor.visit_lambda_expr(self)
-
-def lol(x: Statement) -> int:
-    return x.line
-
-[file other_visitor.py]
-from mypy_extensions import trait
-from typing import TypeVar, cast, Generic
-from abc import abstractmethod
-import native as nodes
-
-T = TypeVar('T')
-
-@trait
-class ExpressionVisitor(Generic[T]):
-    @abstractmethod
-    def visit_lambda_expr(self, o: 'nodes.LambdaExpr') -> T:
-        return cast(T, None)
-
-@trait
-class StatementVisitor(Generic[T]):
-    @abstractmethod
-    def visit_block(self, o: 'nodes.Block') -> T:
-        return cast(T, None)
-
-    @abstractmethod
-    def visit_func_def(self, o: 'nodes.FuncDef') -> T:
-        return cast(T, None)
-
-    @abstractmethod
-    def visit_expr_stmt(self, o: 'nodes.ExprStmt') -> T:
-        return cast(T, None)
-
-@trait
-class NodeVisitor(Generic[T], ExpressionVisitor[T], StatementVisitor[T]):
-    pass
-
-[file other_strconv.py]
-from typing import List
-import native as nodes
-from other_visitor import NodeVisitor
-
-class StrConv(NodeVisitor[str]):
-    def visit_block(self, b: nodes.Block) -> str:
-        # we really need comprehensions!
-        # TODO: PartialType unsupported
-        things = []  # type: List[str]
-        for s in b.stmts:
-            things.append(s.accept(self))
-        return "{" + "; ".join(things) + "}"
-
-    def visit_func_def(self, f: nodes.FuncDef) -> str:
-        return "def " + f.name() + "(): " + f.body.accept(self)
-
-    def visit_expr_stmt(self, e: nodes.ExprStmt) -> str:
-        return e.expr.accept(self)
-
-    def visit_lambda_expr(self, b: nodes.LambdaExpr) -> str:
-        return "(fn: " + b.body.accept(self) + ")"
-
-[file driver.py]
-from native import *
-
-block = Block([Block([]), ExprStmt(LambdaExpr(Block([])))])
-fn = FuncDef('test', block)
-assert fn.to_str() == "def test(): {{}; (fn: {})}"

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

@@ -1,375 +0,0 @@
-# Test cases for misc primitives (compile and run)
-#
-# Please only add tests that don't have an obvious place in type-specific test
-# files such as run-strings.test, run-lists.test, etc.
-
-[case testGenericEquality]
-def eq(a: object, b: object) -> bool:
-    if a == b:
-        return True
-    else:
-        return False
-def ne(a: object, b: object) -> bool:
-    if a != b:
-        return True
-    else:
-        return False
-def f(o: object) -> bool:
-    if [1, 2] == o:
-        return True
-    else:
-        return False
-[file driver.py]
-from native import eq, ne, f
-assert eq('xz', 'x' + 'z')
-assert not eq('x', 'y')
-assert not ne('xz', 'x' + 'z')
-assert ne('x', 'y')
-assert f([1, 2])
-assert not f([2, 2])
-assert not f(1)
-
-[case testGenericBinaryOps]
-from typing import Any
-def add(x: Any, y: Any) -> Any:
-    return x + y
-def subtract(x: Any, y: Any) -> Any:
-    return x - y
-def multiply(x: Any, y: Any) -> Any:
-    return x * y
-def floor_div(x: Any, y: Any) -> Any:
-    return x // y
-def true_div(x: Any, y: Any) -> Any:
-    return x / y
-def remainder(x: Any, y: Any) -> Any:
-    return x % y
-def power(x: Any, y: Any) -> Any:
-    return x ** y
-def lshift(x: Any, y: Any) -> Any:
-    return x << y
-def rshift(x: Any, y: Any) -> Any:
-    return x >> y
-def num_and(x: Any, y: Any) -> Any:
-    return x & y
-def num_xor(x: Any, y: Any) -> Any:
-    return x ^ y
-def num_or(x: Any, y: Any) -> Any:
-    return x | y
-def lt(x: Any, y: Any) -> Any:
-    if x < y:
-        return True
-    else:
-        return False
-def le(x: Any, y: Any) -> Any:
-    if x <= y:
-        return True
-    else:
-        return False
-def gt(x: Any, y: Any) -> Any:
-    if x > y:
-        return True
-    else:
-        return False
-def ge(x: Any, y: Any) -> Any:
-    if x >= y:
-        return True
-    else:
-        return False
-def contains(x: Any, y: Any) -> Any:
-    if x in y:
-        return True
-    else:
-        return False
-def identity(x: Any, y: Any) -> Any:
-    if x is y:
-        return True
-    else:
-        return False
-def disidentity(x: Any, y: Any) -> Any:
-    if x is not y:
-        return True
-    else:
-        return False
-def not_eq_cond(a: Any, b: Any) -> bool:
-    if not (a == b):
-        return True
-    else:
-        return False
-def eq2(a: Any, b: Any) -> bool:
-    return a == b
-def slice1(x: Any) -> Any:
-    return x[:]
-def slice2(x: Any, y: Any) -> Any:
-    return x[y:]
-def slice3(x: Any, y: Any) -> Any:
-    return x[:y]
-def slice4(x: Any, y: Any, z: Any) -> Any:
-    return x[y:z]
-def slice5(x: Any, y: Any, z: Any, zz: Any) -> Any:
-    return x[y:z:zz]
-[file driver.py]
-from native import *
-assert add(5, 6) == 11
-assert add('x', 'y') == 'xy'
-assert subtract(8, 3) == 5
-assert multiply(8, 3) == 24
-assert floor_div(8, 3) == 2
-assert true_div(7, 2) == 3.5
-assert remainder(11, 4) == 3
-assert remainder('%.3d', 5) == '005'
-assert remainder('%d-%s', (5, 'xy')) == '5-xy'
-assert power(3, 4) == 81
-assert lshift(5, 3) == 40
-assert rshift(41, 3) == 5
-assert num_and(99, 56) == 32
-assert num_xor(99, 56) == 91
-assert num_or(99, 56) == 123
-assert lt('a', 'b')
-assert not lt('a', 'a')
-assert not lt('b', 'a')
-assert not gt('a', 'b')
-assert not gt('a', 'a')
-assert gt('b', 'a')
-assert le('a', 'b')
-assert le('a', 'a')
-assert not le('b', 'a')
-assert not ge('a', 'b')
-assert ge('a', 'a')
-assert ge('b', 'a')
-assert contains('x', 'axb')
-assert not contains('X', 'axb')
-assert contains('x', {'x', 'y'})
-a = [1, 3, 5]
-assert slice1(a) == a
-assert slice1(a) is not a
-assert slice2(a, 1) == [3, 5]
-assert slice3(a, -1) == [1, 3]
-assert slice4(a, 1, -1) == [3]
-assert slice5(a, 2, 0, -1) == [5, 3]
-o1, o2 = object(), object()
-assert identity(o1, o1)
-assert not identity(o1, o2)
-assert not disidentity(o1, o1)
-assert disidentity(o1, o2)
-assert eq2('xz', 'x' + 'z')
-assert not eq2('x', 'y')
-assert not not_eq_cond('xz', 'x' + 'z')
-assert not_eq_cond('x', 'y')
-
-[case testGenericMiscOps]
-from typing import Any
-def neg(x: Any) -> Any:
-    return -x
-def pos(x: Any) -> Any:
-    return +x
-def invert(x: Any) -> Any:
-    return ~x
-def get_item(o: Any, k: Any) -> Any:
-    return o[k]
-def set_item(o: Any, k: Any, v: Any) -> Any:
-    o[k] = v
-[file driver.py]
-from native import *
-assert neg(6) == -6
-assert pos(6) == 6
-assert invert(6) == -7
-d = {'x': 5}
-assert get_item(d, 'x') == 5
-set_item(d, 'y', 6)
-assert d['y'] == 6
-
-[case testAnyAttributeAndMethodAccess]
-from typing import Any, List
-class C:
-    a: int
-    def m(self, x: int, a: List[int]) -> int:
-        return self.a + x + a[0]
-def get_a(x: Any) -> Any:
-    return x.a
-def set_a(x: Any, y: Any) -> None:
-    x.a = y
-def call_m(x: Any) -> Any:
-    return x.m(1, [3])
-[file driver.py]
-from native import C, get_a, set_a, call_m
-class D:
-    def m(self, x, a):
-        return self.a + x + a[0]
-
-c = C()
-c.a = 6
-d = D()
-d.a = 2
-assert get_a(c) == 6
-assert get_a(d) == 2
-assert call_m(c) == 10
-assert call_m(d) == 6
-set_a(c, 5)
-assert c.a == 5
-set_a(d, 4)
-assert d.a == 4
-try:
-    get_a(object())
-except AttributeError:
-    pass
-else:
-    assert False
-try:
-    call_m(object())
-except AttributeError:
-    pass
-else:
-    assert False
-try:
-    set_a(object(), 5)
-except AttributeError:
-    pass
-else:
-    assert False
-
-[case testFloat]
-def assign_and_return_float_sum() -> float:
-    f1 = 1.0
-    f2 = 2.0
-    f3 = 3.0
-    return f1 * f2 + f3
-
-def from_int(i: int) -> float:
-    return float(i)
-
-def to_int(x: float) -> int:
-    return int(x)
-
-def get_complex() -> complex:
-    return 5.2j + 3.5 + 1j
-
-[file driver.py]
-from native import assign_and_return_float_sum, from_int, to_int, get_complex
-sum = 0.0
-for i in range(10):
-    sum += assign_and_return_float_sum()
-assert sum == 50.0
-
-assert str(from_int(10)) == '10.0'
-assert str(to_int(3.14)) == '3'
-assert str(to_int(3)) == '3'
-assert get_complex() == 3.5 + 6.2j
-
-[case testDel]
-from typing import List
-from testutil import assertRaises
-
-def printDict(dict) -> None:
-    l = list(dict.keys()) # type: List[str]
-    l.sort()
-    for key in l:
-        print(key, dict[key])
-    print("#########")
-
-def delList() -> None:
-    l = [1, 2, 3]
-    print(tuple(l))
-    del l[1]
-    print(tuple(l))
-
-def delDict() -> None:
-    d = {"one":1, "two":2}
-    printDict(d)
-    del d["one"]
-    printDict(d)
-
-def delListMultiple() -> None:
-    l = [1, 2, 3, 4, 5, 6, 7]
-    print(tuple(l))
-    del l[1], l[2], l[3]
-    print(tuple(l))
-
-def delDictMultiple() -> None:
-    d = {"one":1, "two":2, "three":3, "four":4}
-    printDict(d)
-    del d["two"], d["four"]
-    printDict(d)
-
-class Dummy():
-    __deletable__ = ('x', 'y')
-
-    def __init__(self, x: int, y: int) -> None:
-        self.x = x
-        self.y = y
-
-def delAttribute() -> None:
-    dummy = Dummy(1, 2)
-    del dummy.x
-    with assertRaises(AttributeError):
-        dummy.x
-
-def delAttributeMultiple() -> None:
-    dummy = Dummy(1, 2)
-    del dummy.x, dummy.y
-    with assertRaises(AttributeError):
-        dummy.x
-    with assertRaises(AttributeError):
-        dummy.y
-
-def delLocal(b: bool) -> int:
-    dummy = 10
-    if b:
-        del dummy
-    return dummy
-
-def delLocalLoop() -> None:
-    # Try deleting a local in a loop to make sure the control flow analysis works
-    dummy = 1
-    for i in range(10):
-        print(dummy)
-        dummy *= 2
-        if i == 4:
-            del dummy
-
-global_var = 10
-del global_var
-
-[file driver.py]
-from native import (
-    delList, delDict, delListMultiple, delDictMultiple, delAttribute,
-    delAttributeMultiple, delLocal, delLocalLoop,
-)
-import native
-from testutil import assertRaises
-
-delList()
-delDict()
-delListMultiple()
-delDictMultiple()
-delAttribute()
-delAttributeMultiple()
-with assertRaises(AttributeError):
-    native.global_var
-with assertRaises(NameError, 'local variable "dummy" referenced before assignment'):
-    delLocal(True)
-assert delLocal(False) == 10
-with assertRaises(NameError, 'local variable "dummy" referenced before assignment'):
-    delLocalLoop()
-[out]
-(1, 2, 3)
-(1, 3)
-one 1
-two 2
-#########
-two 2
-#########
-(1, 2, 3, 4, 5, 6, 7)
-(1, 3, 5, 7)
-four 4
-one 1
-three 3
-two 2
-#########
-one 1
-three 3
-#########
-1
-2
-4
-8
-16

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

@@ -1,159 +0,0 @@
--- Test cases for Python 3.7 features
-
-[case testRunDataclass]
-import dataclasses
-from dataclasses import dataclass, field
-from typing import Set, FrozenSet, List, Callable, Any
-
-@dataclass
-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
-
-@dataclass
-class Person1b(Person1):
-    id: str = '000'
-
-@dataclass
-class Person2:
-    age : int
-    name : str = field(default='robot')
-
-@dataclasses.dataclass
-class Person2b:
-    age : int
-    name : str = dataclasses.field(default='robot')
-
-@dataclass(order = True)
-class Person3:
-    age : int = field(default = 6)
-    friendIDs : List[int] = field(default_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
-
-@dataclass
-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
-
-@dataclass
-class Person5:
-    weight: float
-    friends: Set[str] = field(default_factory=set)
-    parents: FrozenSet[str] = frozenset()
-
-[file other.py]
-from native import Person1, Person1b, Person2, Person3, Person4, Person5, testBool
-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 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}
-assert Person5.__annotations__ == {'weight': float, 'friends': set,
-                                       'parents': frozenset}
-
-[file driver.py]
-import sys
-
-# Dataclasses introduced in 3.7
-version = sys.version_info[:2]
-if version[0] < 3 or version[1] < 7:
-    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)