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))