class TypeMap(Class):
fieldDefToId = Member(Dict(FieldDefinition, int))
fieldIdToDef = Member(Dict(int, FieldDefinition))
def __len__(self):
return len(self.fieldDefToId)
def lookupOrAdd(self, schema, typename, fieldname):
key = FieldDefinition(schema=schema,
typename=typename,
fieldname=fieldname)
if key not in self.fieldDefToId:
fieldId = len(self.fieldDefToId)
self.fieldDefToId[key] = fieldId
self.fieldIdToDef[fieldId] = key
return self.fieldDefToId[key]
def fieldIdFor(self, schema, typename, fieldname):
key = FieldDefinition(schema=schema,
typename=typename,
fieldname=fieldname)
return self.fieldDefToId.get(key)
class Exterior(Class):
x = Member(int)
i = Member(Interior)
iTup = Member(NamedTuple(x=Interior, y=Interior))
def __init__(self):
self.i = Interior()
class AClassWithInit(Class):
x = Member(int)
y = Member(float)
def __init__(self):
self.x = 100
self.y = 100.0
def __init__(self, x): # noqa: F811
self.x = x
self.y = 100.0
def __init__(self, x, y): # noqa: F811
self.x = x
self.y = y
class DefaultVal(Class):
x0 = Member(int)
x1 = Member(int, 5)
y0 = Member(bool)
y1 = Member(bool, True)
z0 = Member(float)
z1 = Member(float, 3.14)
b0 = Member(bytes)
b1 = Member(bytes, b"abc")
s0 = Member(str)
s1 = Member(str, "abc")
class ClassWithInit(Class):
x = Member(int)
y = Member(float)
z = Member(str)
cwi = Member(lambda: ClassWithInit)
def __init__(self):
pass
def __init__(self,x=1,cwi=None):
self.x = x
if cwi is not None:
self.cwi = cwi
def __init__(self,x):
self.x = x
class AClass(Class):
x = Member(int)
y = Member(float)
z = Member(TupleOf(int))
def f(self):
return self.x + self.y
def loop(self, count: int):
i = 0
res = self.y
while i < count:
res = res + self.y
i = i + 1
return res
class A(Class):
x = Member(int)
y = int #not a member. Just a value.
def f(self):
return 10
class ClassWithComplexDispatch(Class):
x = Member(int)
def f(self, x):
return 'x'
def f(self, y):
return 'y'
class WithLen(Class):
x = Member(int)
def __init__(self, x):
self.x = x
def __len__(self):
return self.x
class X(Class):
anything = Member(object)
pyclass = Member(OneOf(None, NormalPyClass))
pysubclass = Member(OneOf(None, NormalPySubclass))
holdsNT = Member(NT)
holdsNTSubclass = Member(NTSubclass)
def f(self, x: NTSubclass):
return "NTSubclass"
def f(self, x: NormalPySubclass):
return "NormalPySubclass"
def f(self, x: NormalPyClass):
return "NormalPyClass"
def f(self, x):
return "object"
class ClassWithProperty(Class):
_x = Member(int)
def __init__(self, x):
self._x = x
@property
def x(self):
return self._x + 1
class ClassWithBoundMethod(Class):
x = Member(OneOf(None, SomeClass))
def __init__(self):
self.x = None
def increment(self, y):
if self.x is None:
self.x = SomeSubclass(y)
else:
self.x = SomeSubclass(self.x.x + y)
def test_class_members_accessible(self):
class C(Class):
x = 10
y = Member(int)
c = C()
self.assertEqual(c.x, 10)
self.assertEqual(c.y, 0)
with self.assertRaisesRegex(AttributeError, "Cannot modify read-only class member"):
c.x = 20
with self.assertRaisesRegex(AttributeError, "cannot add attributes to instances of this type"):
c.z = 20
self.assertEqual(C.x, 10)
self.assertEqual(C.y, Member(int))
class ClassWithComparisons(Class):
x = Member(int)
def __init__(self, x):
self.x = x
def __eq__(self, other):
return self.x == other.x
def __ne__(self, other):
return self.x != other.x
def __lt__(self, other):
return self.x < other.x
def __gt__(self, other):
return self.x > other.x
def __le__(self, other):
return self.x <= other.x
def __ge__(self, other):
return self.x >= other.x
class A(Class):
bvals = Member(TupleOf(lambda: B))
class C(Class):
x = Member(int)
class A(Class):
bvals = Member(TupleOf(B0))
class AClassWithDefaults(Class):
x = Member(int, 123)
y = Member(int)
class AClassWithAnotherClass(Class):
x = Member(int)
y = Member(float)
ac = Member(AClass)
class B(Class):
avals = Member(TupleOf(A))
class X(Class):
i = Member(T)
y = Member(Y(T))
class Interior(Class):
x = Member(int)
y = Member(int)
class Y(Class):
i = Member(T)
x = Member(X(T))
class A(Class):
x = Member((1,2,3))
class C(Class):
x = 10
y = Member(int)
class AClass(Class):
x = Member(int)
y = Member(float)
class B(Class):
avals = Member(TupleOf(lambda: A))
class C(Class):
x = Member(int)
def setX(self, x):
self.x = x
class X(Class):
impossible = Member(OneOf(None, lambda: X))
class ASelfRecursiveClass(Class):
x = Member(OneOf(None, lambda: ASelfRecursiveClass))
