def testMultiple(self):
simpsons = das.read(self.SimpsonsInput)
homer = das.read(self.HomerInput)
ned = das.make_default("csv.Person")
ned.name.given = "ned"
ned.name.family = "flanders"
rod = das.make_default("csv.Relationship")
todd = das.make_default("csv.Relationship")
rod.data.name.given = "rod"
rod.data.name.family = "flanders"
todd.data.name.given = "todd"
todd.data.name.family = "flanders"
ned.family = [rod, todd]
das.write_csv([simpsons, homer, ned],
self.MultipleOutput,
alias={
"csv.Person": "p",
"csv.Family": "f"
})
read_data = das.read_csv(self.MultipleOutput)
self.assertEqual(read_data[0], simpsons)
self.assertEqual(read_data[1], homer)
self.assertEqual(read_data[2], ned)
self.assertNotEqual(read_data[2], homer)
self.assertNotEqual(read_data[1], ned)
def do_shopping():
b = das.make_default("shopping.basket")
b.items.append(das.make("shopping.item", name="carottes", value=110))
b.items.append(das.make("shopping.item", name="meat", value=320))
das.pprint(b)
for c in ["yen", "euro", "dollar"]:
print("%f %s(s)" % (b.value_in(c), c))
def testAssignInvalid2(self):
v = das.make_default("validation.SomeType")
v.valid_keys.extend(["weight", "index"])
v.accepted_values.real = False
v.value_pairs["index"] = 10
with self.assertRaises(das.ValidationError):
v.value_pairs["weight"] = 2.0
def test2(self):
r0 = das.make_default("testmultiline.MyStruct")
r0.comment = u"""hello
world.
Be happy!"""
das.write(r0, self.OutputFile)
r1 = das.read(self.OutputFile)
self.assertEqual(r0.comment, r1.comment)
def test3(self):
r0 = das.make_default("testmultiline.MyStruct")
r0.comment = u"""昨日
今日
明日"""
das.write(r0, self.OutputFile)
r1 = das.read(self.OutputFile)
self.assertEqual(r0.comment, r1.comment)
def testAssign2(self):
obj = das.make_default("orswitch.Test")
obj.resolution = {
"base": (1920, 1080),
"margins": {
"10p": (1.1, 1.1)
},
"defaultMargin": ""
}
def print_types():
print("=== Print default for all 'hud' schema types")
stl = das.list_schema_types("hud")
for st in stl:
print("=== %s" % st)
v = das.make_default(st)
print(type(v).__name__)
das.pprint(v)
if hasattr(v, "_schema_type"):
print(v._schema_type)
def testInheritStatic(self):
sr = das.make_default("extend.ScaledResolution")
sr.width = 20
sr.height = 10
self.assertTrue(sr.pixel_count() == 200)
sr.scale = {"x": 2, "y": 1}
sx = int(round(sr.width * sr.scale.x))
sy = int(round(sr.height * sr.scale.y))
self.assertTrue((sx * sy) == 400)
self.assertFalse(sr.scale.is_uniform())
def process(self):
st = self.input("schemaType").receive()
if st.isEOP():
return False
rv = das.make_default(st.value())
st.drop()
self.output("outDasObj").send(rv)
return True
def run(self):
if UseDas:
st = das.make_default("dasTest.struct")
st["i"] = self.param("int").get()
st["f"] = self.param("flt").get()
st["s"] = self.param("str").get()
else:
st = {
"i": self.param("int").get(),
"f": self.param("flt").get(),
"s": self.param("str").get()
}
self.output("dasStruct").send(st)
def name_conflicts():
print("=== Name conflict resolution ===")
d = das.make_default("conflicts.DictMethod")
das.pprint(d)
print("keys = %s" % d.keys)
print("_keys() -> %s" % d._keys())
print("values = %s" % d.values)
print("_values() -> %s" % d._values())
print("items() -> %s" % d.items())
for k, v in d.items():
print("%s = %s" % (k, v))
das.pprint(d)
d._clear()
das.pprint(d)
def do_multior():
b = das.make_default("multior.Parameter")
das.pprint(b)
b.min = 1
b.max = 10.0
b.softMin = False
b.softMax = "hello"
try:
b.min = [0]
except:
pass
das.pprint(b)
print(b._get_schema_type())
print(das.get_schema_type("multior.Value"))
def test_mixin2():
class Fn(das.mixin.Mixin):
@classmethod
def get_schema_type(klass):
return "timeline.ClipSource"
def __init__(self, *args, **kwargs):
super(Fn, self).__init__()
def _copy(self):
print("Fn._copy")
return self
def pprint(self):
das.pprint(self)
class Fn2(das.mixin.Mixin):
@classmethod
def get_schema_type(klass):
return "timeline.ClipSource"
def __init__(self, *args, **kwargs):
super(Fn2, self).__init__()
def echo(self):
print("From Fn2 Mixin")
class Fn3(das.mixin.Mixin):
@classmethod
def get_schema_type(klass):
return "timeline.Range"
def __init__(self, *args, **kwargs):
super(Fn3, self).__init__()
def echo(self):
print("From Fn3 Mixin")
data = das.make_default("timeline.ClipSource")
try:
data.pprint()
except Exception, e:
print(str(e))
def test_mixin1():
print("=== Mixin tests using timeline.ClipSource schema type ===")
class Range(das.Mixin):
@classmethod
def get_schema_type(klass):
return "timeline.Range"
def __init__(self, *args, **kwargs):
super(Range, self).__init__(*args, **kwargs)
def expand(self, start, end):
cs, ce = self[0], self[1]
if start < cs:
cs = start
if end > ce:
ce = end
self[0], self[1] = cs, ce
class ClipSource(das.Mixin):
@classmethod
def get_schema_type(klass):
return "timeline.ClipSource"
def __init__(self, *args, **kwargs):
super(ClipSource, self).__init__(*args, **kwargs)
def set_media(self, path):
_, ext = map(lambda x: x.lower(), os.path.splitext(path))
if ext == ".fbx":
print("Get range from FBX file")
elif ext == ".abc":
print("Get range from Alembic file")
elif ext == ".mov":
print("Get range from Movie file")
self.media = os.path.abspath(path).replace("\\", "/")
def set_clip_offsets(self, start, end):
data_start, data_end = self.dataRange
clip_start = min(data_end, data_start + max(0, start))
clip_end = max(data_start, data_end + min(end, 0))
if clip_start == data_start and clip_end == data_end:
self.clipRange = None
else:
self.clipRange = (clip_start, clip_end)
das.register_mixins(Range, ClipSource)
print("-- make def (1)")
dv = das.make_default("timeline.ClipSource")
print("-- write (1)")
das.write(dv, "./out.tl")
print("-- make def (2)")
cs = das.make_default("timeline.ClipSource")
print("-- read (1)")
cs = das.read("./out.tl")
das.pprint(cs)
cs.dataRange = (100, 146)
cs.dataRange.expand(102, 150)
cs.set_media("./source.mov")
cs.set_clip_offsets(1, -1)
das.pprint(cs)
print("-- write (2)")
das.write(cs, "./out.tl")
c = das.copy(cs)
das.pprint(c)
for k, v in c.iteritems():
print("%s = %s" % (k, v))
os.remove("./out.tl")
def testExtend(self):
v = das.make_default("xtend.ext")
v.creator = "Me"
v.description = "WTF?!"
def testAssignValid(self):
v = das.make_default("validation.SomeType")
v.valid_keys.append("weight")
v.value_pairs["weight"] = 2.0
def testAssignInvalid(self):
v = das.make_default("validation.SomeType")
with self.assertRaises(das.ValidationError):
v.value_pairs["weight"] = 1.0
def testSetInvalid(self):
v = das.make_default("validation.SomeType")
v.valid_keys.extend(["weight", "index"])
v.accepted_values.real = False
with self.assertRaises(das.ValidationError):
v.value_pairs = {"index": 10, "weight": 2.0}
def testAssign3(self):
obj = das.make_default("orswitch.Test")
with self.assertRaises(das.ValidationError):
obj.resolution = {"base": (1280, 720)}
def _makeValue(self):
r = das.make_default("testset.MySet")
r |= (1, 3.3, "hello", "world")
return r
def testDynamicChoice(self):
v = das.make_default("enumchoices.All")
v.dchoice = "ccc"
self.assertEqual(v.dchoice, "ccc")
def testSetEnumFromInvalidString(self):
v = das.make_default("enumchoices.All")
with self.assertRaises(das.ValidationError):
v.enum = "Undefined"
def _makeOne(self):
v = das.make_default("comparetest.CompareType")
v.attribs.extend([{"weight1": 0.1, "weight2": -1.4}, {"distance1": 10.2, "distance2": 3.9}])
v.people = (das.Struct(name="Alfred", age=28), das.Struct(name="Ingrid", age=24))
return v
def testSetEnumFromValidString(self):
v = das.make_default("enumchoices.All")
v.enum = "On"
self.assertEqual(v.enum, 1)
def testStrictStaticChoice(self):
v = das.make_default("enumchoices.All")
with self.assertRaises(das.ValidationError):
v.sschoice = "goodbye"
def testAssign1(self):
obj = das.make_default("orswitch.Test")
obj.resolution = (1920, 1080)
def testSet(self):
r = das.make_default("compatibility.SomeType")
r.oldField = ["hello", "world"]
def testStaticChoice(self):
v = das.make_default("enumchoices.All")
v.schoice = "goodbye"
self.assertEqual(v.schoice, "goodbye")
def testStrictDynamicChoice(self):
v = das.make_default("enumchoices.All")
with self.assertRaises(das.ValidationError):
v.sdchoice = "ccc"
def _makeOne(self):
v = das.make_default("unicode.Person")
v.firstname = u"太郎"
v.lastname = u"北川"
v.gender = u"男"
return v
