def spine_scene(path): tree = deftree.DefTree() root = tree.get_root() root.add_attribute("spine_json", path.as_posix()) root.add_attribute("atlas", "") root.add_attribute("sample_rate", 30) tree.write(_fix_path(path, ".spinescene"))
def test_attribute_length(self): tree = deftree.DefTree() root = tree.get_root() my_string = "string_my_long_test_string" string_test = root.add_attribute("string", my_string) number_test = root.add_attribute("number", 10) self.assertTrue(len(string_test) == len(my_string))
def test_attribute_enum_representation(self): tree = deftree.DefTree() root = tree.get_root() d_enum = root.add_attribute("enum", "ENUM") self.assertTrue(d_enum == "ENUM") self.assertTrue(d_enum.value == "ENUM") self.assertTrue(d_enum.string == "ENUM")
def test_attribute_bool_representation(self): tree = deftree.DefTree() root = tree.get_root() d_bool = root.add_attribute("bool", True) self.assertTrue(d_bool == True) self.assertTrue(d_bool.value is True) self.assertTrue(d_bool.string == "true")
def test_asserts(self): tree = deftree.DefTree() root = tree.get_root() attribute = root.add_attribute("attr", 1) element = root.add_element("element") with self.assertRaises(TypeError): deftree.assert_is_element_or_attribute("str") with self.assertRaises(TypeError): deftree.assert_is_element(attribute) with self.assertRaises(TypeError): deftree.assert_is_attribute(element) try: deftree.assert_is_element_or_attribute(element) deftree.assert_is_element_or_attribute(attribute) except TypeError: self.fail() try: deftree.assert_is_element(element) except TypeError: self.fail() try: deftree.assert_is_attribute(attribute) except TypeError: self.fail()
def spine_model(path): tree = deftree.DefTree() root = tree.get_root() root.add_attribute("spine_scene", path.as_posix()) root.add_attribute("default_animation", "") root.add_attribute("skin", "") tree.write(_fix_path(path, ".spinemodel"))
def test_iterating_attributes(self): tree = deftree.DefTree() root = tree.get_root() parent_element = root.add_element("parent") child_element = parent_element.add_element("child") child_attribute = child_element.add_attribute("id", True) self.assertIn(child_attribute, parent_element.iter_attributes("id"))
def test_iterating_direct_attributes(self): tree = deftree.DefTree() root = tree.get_root() parent_element = root.add_element("parent") child_attribute = parent_element.add_attribute("id", True) self.assertIn(child_attribute, parent_element.attributes()) self.assertNotIn(parent_element, root.attributes())
def test_attribute_string_representation(self): tree = deftree.DefTree() root = tree.get_root() d_string = root.add_attribute("string", "deftree") self.assertTrue(d_string == "deftree") self.assertTrue(d_string.value == "deftree") self.assertTrue(d_string.string == '"deftree"')
def test_attribute_number_representation(self): tree = deftree.DefTree() root = tree.get_root() d_number = root.add_attribute("number", 10) self.assertTrue(d_number == 10) self.assertTrue(d_number.value == 10) self.assertTrue(d_number.string == "10")
def test_clear_element(self): tree = deftree.DefTree() root = tree.get_root() parent = root.add_element("parent") parent.add_attribute("id", "true") parent.add_attribute("name", "element") parent.clear() self.assertIsNone(parent.get_attribute("id"), "Failed clearing element")
def test_attribute_change_value(self): tree = deftree.DefTree() root = tree.get_root() attribute = root.add_attribute("attribute", 1) self.assertTrue(attribute == 1) attribute.value = 2 self.assertTrue(attribute == 2)
def test_index_return_value_error(self): tree = deftree.DefTree() root = tree.get_root() attr = root.add_attribute("first", "bah") parent = root.add_element("parent") parent.add_attribute("second", "bah") with self.assertRaises(ValueError): parent.index(attr)
def test_removing_children(self): tree = deftree.DefTree() root = tree.get_root() parent = root.add_element("parent") child1 = parent.add_element("child1") child2 = parent.add_element("child2") parent.remove(child2) self.assertIn(child1, parent, "child1 is not found") self.assertNotIn(child2, root, "Failed deleting child")
def test_getting_stop_iteration_on_next(self): tree = deftree.DefTree() root = tree.get_root() check_against = ["first", "second", "missing"] root.add_attribute("first", "bah") root.add_attribute("second", "true") with self.assertRaises(StopIteration): for _ in check_against: next(root)
def test_deftree_attribute_string_comparision(self): tree = deftree.DefTree() root = tree.get_root() the_string = "my_string" fake_parsed_string = root.add_attribute("Attribute", '"{}"'.format(the_string)) self.assertTrue(fake_parsed_string == the_string, "Comparing strings, fake parsed") my_string_attribute = root.add_attribute("Attribute2", the_string) self.assertTrue(my_string_attribute == the_string, "Comparing strings, normally added") self.assertTrue(isinstance(fake_parsed_string, deftree.DefTreeString)) self.assertTrue(isinstance(my_string_attribute, deftree.DefTreeString))
def test_copy_element(self): tree = deftree.DefTree() root = tree.get_root() parent = root.add_element("parent") child1 = parent.add_attribute("child", True) copy_of_parent = parent.copy() self.assertTrue(parent.get_attribute("child").value == copy_of_parent.get_attribute("child").value) child1.value = False self.assertFalse(hex(id(parent.get_attribute("child"))) == hex(id(copy_of_parent.get_attribute("child")))) self.assertTrue(len(root) == 1)
def test_deftree_attribute_enum_comparision(self): tree = deftree.DefTree() root = tree.get_root() the_enum = "MY_FAKE_ENUM" not_an_enum = "nOT_AN_ENUM" my_enum = root.add_attribute("Attribute", the_enum) self.assertTrue(my_enum == the_enum, "Comparing enums") not_enum = root.add_attribute("Attribute2", not_an_enum) self.assertTrue(isinstance(my_enum, deftree.DefTreeEnum)) self.assertFalse(isinstance(not_enum, deftree.DefTreeEnum))
def sound(path): tree = deftree.DefTree() root = tree.get_root() root.add_attribute("sound", path.as_posix()) root.add_attribute("looping", 0) root.add_attribute("group", "master") root.add_attribute("gain", 1.0) root.add_attribute("pan", 0.0) root.add_attribute("speed", 1.0) tree.write(_fix_path(path, ".sound"))
def collection(name, gui_scene): tree = deftree.DefTree() root = tree.get_root() root.add_attribute("name", name) root.add_attribute("scale_along_z", 0) go = embedded_instance("go") data = go.get_element("data") data.append(components(name, gui_scene)) root.append(go) return tree
def test_getting_the_next_child(self): tree = deftree.DefTree() root = tree.get_root() check_against = ["first", "second", "third", "forth", "fifth"] root.add_attribute("first", "bah") root.add_attribute("second", "true") root.add_attribute("third", "atr") root.add_attribute("forth", "atr") root.add_attribute("fifth", "atr") for name in check_against: self.assertTrue(next(root).name == name)
def test_deftree_attribute_bool_comparision(self): tree = deftree.DefTree() root = tree.get_root() my_string_true = root.add_attribute("Attribute1", "true") my_string_false = root.add_attribute("Attribute2", "false") my_bool_true = root.add_attribute("Attribute3", True) my_bool_false = root.add_attribute("Attribute4", False) self.assertTrue(my_string_true == True) self.assertTrue(my_bool_true == True) self.assertTrue(my_string_false == False) self.assertTrue(my_bool_false == False) self.assertFalse(isinstance(my_string_true.__class__, deftree.DefTreeBool))
def test_attribute_string_manipulation(self): tree = deftree.DefTree() root = tree.get_root() string_test_1 = root.add_attribute("string", "string_my_long_test_string") string_test_2 = root.add_attribute("string", " string_my_long_test_string ") self.assertTrue(string_test_1.endswith("string")) self.assertTrue(string_test_1.startswith("string_my_")) self.assertTrue(string_test_1.index("string") == 0) self.assertTrue(string_test_1.rindex("string") == 20) self.assertTrue(string_test_1.count("_") == 4) self.assertTrue(string_test_1.replace("long", "cool") == "string_my_cool_test_string") self.assertTrue(string_test_2.strip() == "string_my_long_test_string") self.assertTrue(string_test_2.rstrip() == " string_my_long_test_string")
def test_parse_from_string(self): string_doc = """profiles {\n name: "Landscape"\n qualifiers {\n width: 1280\n height: 720\n }\n}""" string_tree = deftree.from_string(string_doc) string_root = string_tree.get_root() tree = deftree.DefTree() root = tree.get_root() profiles = root.add_element("profiles") profiles.add_attribute("name", '"Landscape"') qualifiers = profiles.add_element("qualifiers") qualifiers.add_attribute("width", "1280") qualifiers.add_attribute("height", "720") self.assertTrue(deftree.validate(deftree.to_string(string_root), deftree.to_string(root)))
def test_deftree_attribute_numbers_assignment(self): tree = deftree.DefTree() root = tree.get_root() number = root.add_attribute("number", 0) self.assertTrue(number == 0, "Comparing number to int") number += 4 self.assertTrue(number == 4, "Number after adding not correct") number -= 1 self.assertTrue(number == 3, "Comparing number to int") number *= 3 self.assertTrue(number == 9, "Comparing number to int") self.assertTrue(isinstance(number, deftree.DefTreeNumber), "DefTreeNumber after arithmetics are not DefTreeNumber")
def test_deftree_attribute_numbers_comparision(self): tree = deftree.DefTree() root = tree.get_root() number = root.add_attribute("number", 0.0) science = root.add_attribute("science", "4.1751063E-15") science2 = root.add_attribute("science2", "4.6049512E-4") self.assertTrue(science == 4.1751063e-15, "Comparing number to int") self.assertTrue(science2 == 4.6049512E-4, "Comparing number to int") self.assertTrue(number == 0, "Comparing number to int") self.assertTrue(number == 0.0, "Comparing number to float") self.assertTrue(number < 1.0, "Less than comparision") self.assertTrue(number > -1.0, "More than comparision") self.assertTrue(number >= 0, "More or equal to comparision") self.assertTrue(number <= 0, "More or equal to comparision")
def test_attribute_set_enum(self): tree = deftree.DefTree() root = tree.get_root() the_enum = "MY_FAKE_ENUM" not_an_enum = "nOT_AN_ENUM" my_enum = root.add_attribute("Attribute", the_enum) self.assertTrue(my_enum == the_enum, "Comparing enums") with self.assertRaises(ValueError): root.set_attribute("Attribute", not_an_enum) with self.assertRaises(ValueError): root.set_attribute("Attribute", 1.0) with self.assertRaises(ValueError): root.set_attribute("Attribute", False)
def atlas(paths): first_path = paths[0] tree = deftree.DefTree() root = tree.get_root() for path in paths: images = root.add_element("images") images.add_attribute("image", path.as_posix()) root.add_attribute("margin", 0) root.add_attribute("extrude_borders", 2) root.add_attribute("inner_padding", 0) if first_path.anchor == _anchor: first_path = Path(str(first_path)[1:]) first_path = Path().cwd() / first_path.with_name("NEW_ATLAS.atlas") tree.write(first_path)
def test_attribute_set_string(self): tree = deftree.DefTree() root = tree.get_root() the_string = "my_string" root.add_attribute("Attribute", '"{}"'.format(the_string)) root.set_attribute("Attribute", "str") self.assertTrue(root.get_attribute("Attribute") == "str") root.set_attribute("Attribute", '"str"') self.assertTrue(root.get_attribute("Attribute") == "str") with self.assertRaises(ValueError): root.set_attribute("Attribute", False) with self.assertRaises(ValueError): root.set_attribute("Attribute", 1.0)
def remove_duplicates(atlas): """Remove all duplicated image entries in the atlas""" tree = deftree.DefTree() root = tree.parse(atlas) duplicated_images = [] duplicated_images.extend(list_duplicates(root)) for animation in root.elements("animations"): duplicated_images.extend(list_duplicates(animation)) for duplicate in duplicated_images: print(" Removed {}".format(duplicate.value)) image_element = duplicate.get_parent() image_element.get_parent().remove(image_element) tree.write(atlas)