verysimpletree 1.0__tar.gz → 1.2__tar.gz

{verysimpletree-1.0 → verysimpletree-1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: verysimpletree
-Version: 1.0
+Version: 1.2
 Summary: lightweight tree data structure for musicxml and musicscore
 Home-page: https://github.com/alexgorji/verysimpletree.git
 License: MIT

{verysimpletree-1.0 → verysimpletree-1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name="verysimpletree"
-version="1.0"
+version="1.2"
 description = "lightweight tree data structure for musicxml and musicscore"
 authors = ["Alex Gorji <aligorji@hotmail.com>"]
 license = "MIT"

{verysimpletree-1.0 → verysimpletree-1.2}/verysimpletree/test_tree.py

@@ -15,8 +15,8 @@ class BContent:
 
 
 class A(Tree[Any]):
-    def __init__(self, name, parent=None, *args, **keyword):
-        super().__init__(*args, **keyword)
+    def __init__(self, name, parent=None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self._children = []
         self._parent = parent
         self.name = name
@@ -35,8 +35,8 @@ class A(Tree[Any]):
 
 
 class B(Tree[Any]):
-    def __init__(self, name, *args, **keyword):
-        super().__init__(*args, **keyword)
+    def __init__(self, name, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.name = name
         self.content = BContent(value=10)
 
@@ -44,8 +44,17 @@ class B(Tree[Any]):
         if not isinstance(child, Tree):
             raise TypeError
 
+class C(Tree[Any]):
+    def __init__(self, name, value, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.name = name
+        self.value = value
 
-class TestTree(TestCase):
+    def _check_child_to_be_added(self, child):  # pragma: no cover
+        if not isinstance(child, Tree):
+            raise TypeError
+
+class TreeTestCase(TestCase):
     def setUp(self) -> None:
         self.root = A(name='root')
         self.child1 = self.root.add_child_by_name('child1')
@@ -57,6 +66,7 @@ class TestTree(TestCase):
         self.grandchild3 = self.child4.add_child_by_name('grandchild3')
         self.greatgrandchild1 = self.grandchild2.add_child_by_name('greatgrandchild1')
 
+class Test(TreeTestCase):
     def test_is_last_child(self):
         t = self.root
         for node in t.traverse():
@@ -206,6 +216,52 @@ class TestTree(TestCase):
         with self.assertRaises(ValueError):
             self.root.get_tree_representation(space=0)
 
+    def test_get_tree_representation(self):
+        expected = """└── root
+    ├── child1
+    ├── child2
+    │   ├── grandchild1
+    │   └── grandchild2
+    │       └── greatgrandchild1
+    ├── child3
+    └── child4
+        └── grandchild3
+"""
+
+        assert self.root.get_tree_representation() == expected
+
+
+class TreeListRepresentationTestCase(TreeTestCase):
+
+    def test_get_list_representation_all(self):
+        assert self.root.get_list_representation(key=lambda node: node.name) == ['root', ['child1'], ['child2', ['grandchild1'], ['grandchild2', ['greatgrandchild1']]], ['child3'], ['child4', ['grandchild3']]]
+
+    def test_get_list_representation_only_root(self):
+        a = A(name='root')
+        assert a.get_list_representation(key=lambda node: node.name) == ['root']
+
+    def test_create_tree_from_list(self):
+        tree = A.create_tree_from_list(self.root.get_list_representation(key=lambda node: node.name), 'name')
+        assert tree.get_list_representation(key=lambda node: node.name) == self.root.get_list_representation(key=lambda node: node.name)
+
+    def test_create_tree_from_list_only_root(self):
+        tree = A.create_tree_from_list(self.root.get_list_representation(key=lambda node: node.name), 'name')
+        assert tree.get_list_representation(key=lambda node: node.name) == self.root.get_list_representation(key=lambda node: node.name)
+
+    def test_create_tree_from_list_with_name_and_value(self):
+        def _copy_node(node, current_value):
+            copied = C(name=node.name, value=current_value)
+            current_value += 1
+            for child in node.get_children():
+                copied.add_child(_copy_node(child, current_value=current_value))
+            return copied
+        
+        copied_c = _copy_node(self.root, 0)
+        representation = copied_c.get_list_representation(key=lambda node: [node.name, node.value])
+        assert representation == [['root', 0], [['child1', 1]], [['child2', 1], [['grandchild1', 2]], [['grandchild2', 2], [['greatgrandchild1', 3]]]], [['child3', 1]], [['child4', 1], [['grandchild3', 2]]]]
+        tree = C.create_tree_from_list(representation, ['name', 'value'])
+        assert tree.get_list_representation(key=lambda node: [node.name, node.value]) == copied_c.get_list_representation(key=lambda node: [node.name, node.value])
+
 
 class TestNodeReturnValue(TestCase):
 

{verysimpletree-1.0 → verysimpletree-1.2}/verysimpletree/tree.py

@@ -1,6 +1,8 @@
 from abc import ABC, abstractmethod
 from typing import Optional, Callable, Iterator, TypeVar, Any, Generic, cast, Union
 
+from verysimpletree.util import make_list
+
 
 class TreeException(Exception):
     pass
@@ -41,7 +43,7 @@ class Tree(ABC, Generic[T]):
 
     def _raw_traverse(self: T) -> Iterator[T]:
         yield self
-        for child in self.get_children():
+        for child in self._children:
             for node in child._raw_traverse():
                 yield node
 
@@ -74,7 +76,7 @@ class Tree(ABC, Generic[T]):
     def is_first_child(self) -> bool:
         if self.is_root:
             return True
-        if cast(T, self.up).get_children()[0] == self:
+        if cast(T, self.up)._children[0] == self:
             return True
         return False
 
@@ -90,7 +92,7 @@ class Tree(ABC, Generic[T]):
         """
         if self.is_root:
             return True
-        if cast(T, self.up).get_children()[-1] == self:
+        if cast(T, self.up)._children[-1] == self:
             return True
         return False
 
@@ -122,8 +124,8 @@ class Tree(ABC, Generic[T]):
         :return: next sibling. ``None`` if this is the last current child of the parent.
         :rtype: :obj:`~tree.tree.Tree`
         """
-        if self.up and self != self.up.get_children()[-1]:
-            return cast(T, self.up.get_children()[self.up.get_children().index(self) + 1])
+        if self.up and self != self.up._children[-1]:
+            return cast(T, self.up._children[self.up._children.index(self) + 1])
         else:
             return None
 
@@ -135,8 +137,8 @@ class Tree(ABC, Generic[T]):
         :return: previous sibling. ``None`` if this is the first child of the parent.
         :rtype: :obj:`~tree.tree.Tree`
         """
-        if self.up and self != self.up.get_children()[0]:
-            return cast(T, self.up.get_children()[self.up.get_children().index(self) - 1])
+        if self.up and self != self.up._children[0]:
+            return cast(T, self.up._children[self.up._children.index(self) - 1])
         else:
             return None
 
@@ -167,7 +169,22 @@ class Tree(ABC, Generic[T]):
         if self._is_leaf is True:
             self._is_leaf = False
         return child
-
+    
+    # typing with T and Generic[T] etc. seems to be faulty. Return value of _create_node is Tree[T].
+    @classmethod
+    def create_tree_from_list(cls, tree_list_representation: list[list[Any]], represented_attribute_names: list[str]) -> T:
+        represented_attribute_names = make_list(represented_attribute_names)
+        def _create_node(represented_values: list[Any]) -> T:
+            if len(represented_values) != len(represented_attribute_names):
+                raise ValueError(f'create_tree_from_list: represented_attribute_names must be of length {len(represented_values)}.')
+            root_kwargs = {attr:val for attr, val in zip(represented_attribute_names, represented_values)}
+            return cast(T, cls(**root_kwargs))
+        node = _create_node(make_list(tree_list_representation[0]))
+        for child_list_representation in tree_list_representation [1:]:
+            child = cls.create_tree_from_list(child_list_representation, represented_attribute_names)
+            node.add_child(child)
+        return node
+    
     def get_children(self: T) -> list[T]:
         """
         :obj:`~tree.tree.Tree` method
@@ -183,7 +200,7 @@ class Tree(ABC, Generic[T]):
         :return: list of added children of type.d
         :rtype: list[:obj:`~tree.tree.Tree`]
         """
-        return [cast(T, ch) for ch in self.get_children() if isinstance(ch, type_)]
+        return [cast(T, ch) for ch in self._children if isinstance(ch, type_)]
 
     def get_distance(self, reference: Optional[T] = None) -> int:
         """
@@ -233,14 +250,14 @@ class Tree(ABC, Generic[T]):
         if level == 0:
             output = [self]
         elif level == 1:
-            output = self.get_children()
+            output = self._children
         else:
             output = []
             for child in self.get_layer(level - 1):
                 if child.is_leaf:
                     output.append(child)
                 else:
-                    output.extend(child.get_children())
+                    output.extend(child._children)
 
         if key is None:
             return output
@@ -262,7 +279,7 @@ class Tree(ABC, Generic[T]):
         """
         output: list[Union[Any, list[Any]]] = []
         child: T
-        for child in self.get_children():
+        for child in self._children:
             if not child.is_leaf:
                 output.append(child.get_leaves(key=key))
             else:
@@ -333,9 +350,9 @@ class Tree(ABC, Generic[T]):
         if parent is None:
             return '0'
         elif self.get_level() == 1:
-            return str(parent.get_children().index(self) + 1)
+            return str(parent._children.index(self) + 1)
         else:
-            return f"{parent.get_position_in_tree()}.{parent.get_children().index(self) + 1}"
+            return f"{parent.get_position_in_tree()}.{parent._children.index(self) + 1}"
 
     def get_reversed_path_to_root(self) -> list[T]:
         """
@@ -406,6 +423,12 @@ class Tree(ABC, Generic[T]):
         if key:
             tree_representation.key = cast(Callable[[Tree[Any]], Any], key)
         return tree_representation.get_representation()
+    
+    def get_list_representation(self, key: Callable[["Tree[T]"], Any]) -> list[list[Any]]:
+        result: list[list[Any]] = [key(self)]
+        for child in self._children:
+            result.append(child.get_list_representation(key=key))
+        return result
 
     def get_number_of_layers(self) -> int:
         """
@@ -453,10 +476,10 @@ class Tree(ABC, Generic[T]):
         :param child:
         :return: None
         """
-        if child not in self.get_children():
+        if child not in self._children:
             raise ChildNotFoundError
         child._parent = None
-        self.get_children().remove(child)
+        self._children.remove(child)
         self._reset_iterators()
 
     def remove_children(self) -> None:
@@ -467,7 +490,7 @@ class Tree(ABC, Generic[T]):
 
         :return: None
         """
-        for child in self.get_children()[:]:
+        for child in self._children[:]:
             parent = child.get_parent()
             if parent is not None:
                 parent.remove(child)
@@ -482,16 +505,16 @@ class Tree(ABC, Generic[T]):
         :return: None
         """
         if hasattr(old, '__call__'):
-            list_of_olds = [ch for ch in self.get_children() if old(ch)]
+            list_of_olds = [ch for ch in self._children if old(ch)]
         else:
-            list_of_olds = [ch for ch in self.get_children() if ch == old]
+            list_of_olds = [ch for ch in self._children if ch == old]
         if not list_of_olds:
             raise ValueError(f"{old} not in list.")
         self._check_child_to_be_added(new)
-        old_index = self.get_children().index(list_of_olds[index])
-        old_child = self.get_children()[old_index]
-        self.get_children().remove(old_child)
-        self.get_children().insert(old_index, new)
+        old_index = self._children.index(list_of_olds[index])
+        old_child = self._children[old_index]
+        self._children.remove(old_child)
+        self._children.insert(old_index, new)
         old_child._parent = None
         self._reset_iterators()
         new._parent = self

verysimpletree-1.2/verysimpletree/util.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+
+def make_list(input: Any) -> list[Any]:
+    if isinstance(input, list):
+        return input
+    if isinstance(input, str):
+        return [input]
+    try:
+        return list(input)
+    except TypeError:
+        return [input]