def test_comparisons_equivalence(self):
t = TupleOf(OneOf(None, str, bytes, float, int, bool, TupleOf(int)),)
def lt(a,b): return a < b
def le(a,b): return a <= b
def eq(a,b): return a == b
def ne(a,b): return a != b
def gt(a,b): return a > b
def ge(a,b): return a >= b
funcs = [lt,le,eq,ne,gt,ge]
tgroups = [
[1.0,2.0,3.0],
[1,2,3],
[True,False],
["a","b","ab","bb","ba","aaaaaaa","","asdf"],
["1","2","3","12","13","23","24","123123", "0", ""],
[b"a",b"b",b"ab",b"bb",b"ba",b"aaaaaaa",b"",b"asdf"],
[(1,2),(1,2,3),(),(1,1),(1,)]
]
for ts in tgroups:
for f in funcs:
for t1 in ts:
for t2 in ts:
self.assertTrue(f(t1,t2) is f(t((t1,)),t((t2,))),
(f, t1,t2, f(t1,t2), f(t((t1,)),t((t2,))))
)
def test_serialize_core_python_objects(self):
self.check_idempotence(0)
self.check_idempotence(10)
self.check_idempotence(-10)
self.check_idempotence(-0.0)
self.check_idempotence(0.0)
self.check_idempotence(10.5)
self.check_idempotence(-10.5)
self.check_idempotence(None)
self.check_idempotence(True)
self.check_idempotence(False)
self.check_idempotence("")
self.check_idempotence("a string")
self.check_idempotence(b"")
self.check_idempotence(b"some bytes")
self.check_idempotence(())
self.check_idempotence((1,))
self.check_idempotence([])
self.check_idempotence({})
self.check_idempotence({"key": "value"})
self.check_idempotence({"key": "value", "key2": "value2"})
self.check_idempotence([])
self.check_idempotence([1, 2, 3])
self.check_idempotence(set())
self.check_idempotence({1, 2, 3})
self.check_idempotence(frozenset())
self.check_idempotence(frozenset({1, 2, 3}))
self.check_idempotence(int)
self.check_idempotence(object)
self.check_idempotence(type)
self.check_idempotence(TupleOf(int))
self.check_idempotence(TupleOf(int)([0x08]))
def test_tuple_of_float(self):
def f(x: TupleOf(float), y: TupleOf(float)) -> float:
j = 0
res = 0.0
i = 0
while j < len(y):
i = 0
while i < len(x):
res = res + x[i] * y[j]
i = i + 1
j = j + 1
return res
aTupleOfFloat = TupleOf(float)(list(range(1000)))
aTupleOfFloat2 = TupleOf(float)(list(range(1000)))
self.assertEqual(_types.refcount(aTupleOfFloat), 1)
t_py, t_fast = self.checkFunction(f, [(aTupleOfFloat, aTupleOfFloat2)])
self.assertEqual(_types.refcount(aTupleOfFloat), 1)
# I get around 150x
self.assertTrue(t_py / t_fast > 50.0)
print(t_py / t_fast, " speedup")
def test_one_of_composite(self):
t = OneOf(TupleOf(str), TupleOf(float))
self.assertIsInstance(t((1.0,2.0)), TupleOf(float))
self.assertIsInstance(t(("1.0","2.0")), TupleOf(str))
with self.assertRaises(TypeError):
t((1.0,"2.0"))
def test_deep_forwards_work(self):
X = TupleOf(TupleOf(TupleOf(TupleOf(OneOf(None, lambda: X)))))
xStr = str(X)
anX = X(((((None, ), ), ), ))
anotherX = X(((((anX, ), ), ), ))
self.assertEqual(anotherX[0][0][0][0], anX)
def test_forward_type_resolution_sequential(self):
F0 = Forward("f0")
T0 = TupleOf(F0)
F1 = Forward("f1")
T1 = TupleOf(F1)
F1.define(T0)
F0.define(int)
self.assertEqual(T1.__name__, "TupleOf(TupleOf(Int64))")
def test_serialize_stream_integers(self):
for someInts in [(1, 2), TupleOf(int)((1, 2)), [1, 2]]:
self.assertEqual(
serializeStream(int, someInts),
b"".join([serialize(int, x) for x in someInts])
)
self.assertEqual(
deserializeStream(int, serializeStream(int, someInts)),
TupleOf(int)(someInts)
)
def test_deep_forwards_work(self):
X = Forward("X")
X = X.define(TupleOf(TupleOf(TupleOf(TupleOf(OneOf(None, X))))))
str(X)
anX = X( ((((None,),),),) )
anotherX = X( ((((anX,),),),) )
self.assertEqual(anotherX[0][0][0][0], anX)
def test_recursive_oneof(self):
OneOfTupleOfSelf = Forward("OneOfTupleOfSelf")
OneOfTupleOfSelf = OneOfTupleOfSelf.define(OneOf(None, TupleOf(OneOfTupleOfSelf)))
self.assertEqual(OneOfTupleOfSelf.__qualname__, "OneOfTupleOfSelf")
self.assertEqual(OneOf(None, TupleOf(OneOfTupleOfSelf)).__qualname__, "OneOf(NoneType, TupleOf(OneOfTupleOfSelf))")
TO = Forward("TO")
TO = TO.define(TupleOf(OneOf(None, TO)))
self.assertEqual(TO.__qualname__, "TO")
self.assertIs(TO.ElementType.Types[1], TO)
self.assertEqual(TO.ElementType.__qualname__, "OneOf(NoneType, TO)")
def test_embedded_messages(self):
T = NamedTuple(x=TupleOf(int))
T_with_message = NamedTuple(x=EmbeddedMessage)
T_with_two_messages = NamedTuple(x=EmbeddedMessage, y=EmbeddedMessage)
T2 = NamedTuple(x=TupleOf(int), y=TupleOf(int))
t = T(x=(1, 2, 3, 4))
tm = deserialize(T_with_message, serialize(T, t))
tm2 = T_with_two_messages(x=tm.x, y=tm.x)
t2 = deserialize(T2, serialize(T_with_two_messages, tm2))
self.assertEqual(t2.x, t.x)
self.assertEqual(t2.y, t.x)
def f(x: TupleOf(float), y: TupleOf(float)) -> float:
j = 0
res = 0.0
i = 0
while j < len(y):
i = 0
while i < len(x):
res = res + x[i] * y[j]
i = i + 1
j = j + 1
return res
def test_serialization(self):
ints = TupleOf(int)((1,2,3,4))
self.assertEqual(
len(serialize(TupleOf(int), ints)),
36
)
while len(ints) < 1000000:
ints = ints + ints
t0 = time.time()
self.assertEqual(len(serialize(TupleOf(int), ints)), len(ints) * 8 + 4)
print(time.time() - t0, " for ", len(ints))
def test_list_resize(self):
T = ListOf(TupleOf(int))
aTup = TupleOf(int)((1, 2, 3))
@Compiled
def f(x: T, y: TupleOf(int)):
x.resize(len(x) + 10, y)
aList = T()
aList.resize(10)
f(aList, aTup)
self.assertEqual(_types.refcount(aTup), 11)
def test_create_function_with_kwargs_and_star_args_and_defaults(self):
@Function
def f(
x: int,
y=30,
z: None = None,
*args: TupleOf(float),
**kwargs: ConstDict(str, float)
) -> int:
return x + 1
self.assertEqual(len(f.overloads), 1)
o = f.overloads[0]
self.assertEqual(len(o.args), 5)
self.assertEqual([a.name for a in o.args],
['x', 'y', 'z', 'args', 'kwargs'])
self.assertEqual(
[a.typeFilter for a in o.args],
[Int64, None, NoneType,
TupleOf(float),
ConstDict(str, float)])
self.assertEqual([a.defaultValue for a in o.args],
[None, (30, ), (None, ), None, None])
self.assertEqual([a.isStarArg for a in o.args],
[False, False, False, True, False])
self.assertEqual([a.isKwarg for a in o.args],
[False, False, False, False, True])
def test_serializing_named_tuples_in_loop(self):
NT = Forward("NT")
NT = NT.define(NamedTuple(x=OneOf(int, float), y=OneOf(int, TupleOf(NT))))
context = SerializationContext({'NT': NT})
self.serializeInLoop(lambda: NT(x=10, y=(NT(x=20, y=2),)), context=context)
def test_subclassing(self):
BaseTuple = NamedTuple(x=int,y=float)
class NTSubclass(BaseTuple):
def f(self):
return self.x + self.y
def __repr__(self):
return "ASDF"
inst = NTSubclass(x=10,y=20)
self.assertTrue(isinstance(inst, BaseTuple))
self.assertTrue(isinstance(inst, NTSubclass))
self.assertTrue(type(inst) is NTSubclass)
self.assertEqual(repr(inst), "ASDF")
self.assertNotEqual(BaseTuple.__repr__(inst), "ASDF")
self.assertEqual(inst.x, 10)
self.assertEqual(inst.f(), 30)
TupleOfSubclass = TupleOf(NTSubclass)
instTup = TupleOfSubclass((inst,BaseTuple(x=20,y=20.0)))
self.assertTrue(isinstance(instTup[0], NTSubclass))
self.assertTrue(isinstance(instTup[1], NTSubclass))
self.assertEqual(instTup[0].f(), 30)
self.assertEqual(instTup[1].f(), 40)
self.assertEqual(BaseTuple(inst).x, 10)
self.assertTrue(OneOf(None, NTSubclass)(None) is None)
self.assertTrue(OneOf(None, NTSubclass)(inst) == inst)
class LoginPlugin:
name = Indexed(str)
# auth plugin
login_plugin_factory = object # factory for LoginPluginInterface objects
auth_plugins = TupleOf(OneOf(None, AuthPluginBase))
codebase = OneOf(None, service_schema.Codebase)
config = ConstDict(str, str)
def test_class_in_forward(self):
class C(Class):
x = Member(int)
Fwd = Forward("Forward")
Fwd = Fwd.define(OneOf(None, C, TupleOf(Fwd), ListOf(Fwd), ConstDict(str, Fwd)))
Fwd(C())
def f(
x: int,
y=30,
z: None = None,
*args: TupleOf(float),
**kwargs: ConstDict(str, float)
) -> int:
return x + 1
def test_tuple_of_various_things(self):
for thing, typeOfThing in [("hi", str), (b"somebytes", bytes),
(1.0, float), (2, int),
(None, type(None))
]:
tupleType = TupleOf(typeOfThing)
t = tupleType((thing,))
self.assertTrue(type(t[0]) is typeOfThing)
self.assertEqual(t[0], thing)
def test_tuple_of_one_of_fixed_size(self):
t = TupleOf(OneOf(0,1,2,3,4))
ints = tuple([x % 5 for x in range(1000000)])
typedInts = t(ints)
self.assertEqual(len(serialize(t, typedInts)), len(ints) + 4)
self.assertEqual(tuple(typedInts), ints)
def test_add_tuple_of(self):
tupleOfInt = TupleOf(int)
tups = [(),(1,2),(1,),(1,2,3,4)]
for tup1 in tups:
for tup2 in tups:
self.assertEqual(tupleOfInt(tup1) + tupleOfInt(tup2), tupleOfInt(tup1+tup2))
self.assertEqual(tupleOfInt(tup1) + tup2, tupleOfInt(tup1+tup2))
def test_add_transaction(self):
for inType in [list, set, tuple, TupleOf(int)]:
s = VersionedIdSet()
s.addTransaction(100, inType([10]), inType([]))
s.addTransaction(101, inType([]), inType([10]))
self.assertTrue(s.isActive(100, 10))
self.assertFalse(s.isActive(101, 10))
def test_serializing_anonymous_recursive_types(self):
NT = Forward("NT")
NT = NT.define(TupleOf(NT))
# right now we don't allow this. When we move to a more proper model for declarint
# forward types, this should work better.
with self.assertRaises(Exception):
ping_pong(NT)
def test_basic_forward_type_resolution(self):
f = Forward("f")
T = TupleOf(f)
f.define(int)
self.assertEqual(T.__name__, "TupleOf(Int64)")
self.assertEqual(f.get(), Int64)
def test_tuple_assign(self):
@Compiled
def f(x: TupleOf(int)) -> TupleOf(int):
y = x
return y
t = TupleOf(int)((1, 2, 3))
self.assertEqual(f(t), t)
self.assertEqual(_types.refcount(t), 1)
def test_serialize_primitive_compound_types(self):
class A:
pass
B = Alternative("B", X={'a': A})
ts = SerializationContext({'A': A, 'B': B})
for t in [ ConstDict(int, float),
NamedTuple(x=int, y=str),
TupleOf(bool),
Tuple(int, int, bool),
OneOf(int, float),
OneOf(1, 2, 3, "hi", b"goodbye"),
TupleOf(NamedTuple(x=int)),
TupleOf(object),
TupleOf(A),
TupleOf(B)
]:
self.assertIs(ping_pong(t, ts), t)
def test_class_dispatch_on_tuple_vs_list(self):
class WithTwoFunctions(Class):
def f(self, x: TupleOf(int)):
return "Tuple"
def f(self, x: ListOf(int)): # noqa: F811
return "List"
c = WithTwoFunctions()
self.assertEqual(c.f(TupleOf(int)((1, 2, 3))), "Tuple")
self.assertEqual(c.f(ListOf(int)((1, 2, 3))), "Tuple")
def expr_concatenate(self, other):
if self.matches.Constant:
return other
if self.matches.Sequence and other.matches.Sequence:
return Expression.Sequence(vals=self.vals + other.vals)
if self.matches.Sequence:
return Expression.Sequence(vals=self.vals + (other, ))
if other.matches.Sequence:
return Expression.Sequence(vals=TupleOf(Expression)((self, )) +
other.vals)
return Expression.Sequence(vals=(self, other))
def test_one_of_with_refcounts(self):
@Compiled
def f(x: OneOf(None, TupleOf(int))) -> OneOf(None, TupleOf(int)):
y = x
return y
self.assertIs(f(None), None)
aTup = TupleOf(int)((1, 2, 3))
self.assertEqual(f(aTup), aTup)
self.assertEqual(_types.refcount(aTup), 1)
