verysimpletree 1.2__tar.gz → 1.2.1__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name="verysimpletree"
-version="1.2"
+version="1.2.1"
 description = "lightweight tree data structure for musicxml and musicscore"
 authors = ["Alex Gorji <aligorji@hotmail.com>"]
 license = "MIT"
@@ -23,6 +23,10 @@ pytest-xdist = "^3.6.1"
 pytest-cov = "^6.0.0"
 
 
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.8.4"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

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

@@ -167,7 +167,12 @@ class Test(TreeTestCase):
                                           self.grandchild3]
 
     def test_get_farthest_leaf(self):
-        pass
+        self.assertEqual(self.root.get_farthest_leaf(), self.greatgrandchild1)
+        self.assertEqual(self.child1.get_farthest_leaf(), self.child1)
+        self.assertEqual(self.child2.get_farthest_leaf(), self.greatgrandchild1)
+        self.assertEqual(self.child3.get_farthest_leaf(), self.child3)
+        self.assertEqual(self.child4.get_farthest_leaf(), self.grandchild3)
+        self.assertEqual(self.grandchild2.get_farthest_leaf(), self.greatgrandchild1)   
 
     def test_find_grandchild(self):
         assert [n for n in self.root.traverse() if n.get_level() == 2] == [self.grandchild1, self.grandchild2,
@@ -185,6 +190,36 @@ class Test(TreeTestCase):
         with self.assertRaises(TreeReferenceError):
             assert self.greatgrandchild1.get_distance(self.child1) == 'bla'
 
+    def test_get_distance(self):
+        self.assertEqual(self.root.get_distance(self.root), 0)
+        self.assertEqual(self.root.get_distance(self.child1), 1)
+        self.assertEqual(self.root.get_distance(self.child2), 1)
+        self.assertEqual(self.root.get_distance(self.child3), 1)
+        self.assertEqual(self.root.get_distance(self.child4), 1)
+        self.assertEqual(self.root.get_distance(self.grandchild1), 2)
+        self.assertEqual(self.root.get_distance(self.grandchild2), 2)
+        self.assertEqual(self.root.get_distance(self.grandchild3), 2)
+        self.assertEqual(self.root.get_distance(self.greatgrandchild1), 3)
+
+        self.assertEqual(self.child1.get_distance(self.child1), 0)
+        self.assertEqual(self.child1.get_distance(self.root), 1)
+
+        self.assertEqual(self.child2.get_distance(self.child2), 0)
+        self.assertEqual(self.child2.get_distance(self.root), 1)
+        self.assertEqual(self.child2.get_distance(self.grandchild1), 1)
+        self.assertEqual(self.child2.get_distance(self.grandchild2), 1)
+        self.assertEqual(self.child2.get_distance(self.greatgrandchild1), 2)
+
+
+        self.assertEqual(self.child3.get_distance(self.child3), 0)
+        self.assertEqual(self.child3.get_distance(self.root), 1)
+
+        self.assertEqual(self.child4.get_distance(self.child4), 0)
+        self.assertEqual(self.child4.get_distance(self.root), 1)
+        self.assertEqual(self.child4.get_distance(self.grandchild3), 1)
+
+
+
     def test_get_farthest_leave_of_root_without_children(self):
         root = A('root')
         assert root.get_farthest_leaf() == root
@@ -229,6 +264,15 @@ class Test(TreeTestCase):
 """
 
         assert self.root.get_tree_representation() == expected
+        
+    def test_get_number_of_layers(self):
+        self.assertEqual(self.root.get_number_of_layers(), 3)
+        self.assertEqual(self.child1.get_number_of_layers(), 0)
+        self.assertEqual(self.child2.get_number_of_layers(), 2)
+        self.assertEqual(self.child4.get_number_of_layers(), 1)
+        self.assertEqual(self.grandchild1.get_number_of_layers(), 0)
+        self.assertEqual(self.grandchild2.get_number_of_layers(), 1)
+        self.assertEqual(self.greatgrandchild1.get_number_of_layers(), 0)
 
 
 class TreeListRepresentationTestCase(TreeTestCase):

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

@@ -211,21 +211,29 @@ class Tree(ABC, Generic[T]):
         >>> greatgrandchild1.get_distance(child2)
         2
         """
+        if not reference:
+            reference = self.get_root()
 
-        if self.is_root:
+        if reference == self:
             return 0
+        
+        count = 0
 
-        if reference is None:
-            reference = self.get_root()
+        for node in self.get_reversed_path_to_root():
+            if node == reference:
+                return count
+            else:
+                count += 1
+        
+        count = 0
+        for node in reference.get_reversed_path_to_root():
+            print(node)
+            if node == self:
+                return count
+            else:
+                count += 1
 
-        parent = self.up
-        count = 1
-        while parent is not None and parent is not reference:
-            parent = parent.up
-            count += 1
-            if parent is not None and parent.is_root and parent is not reference:
-                raise TreeReferenceError(f"Wrong reference {reference} not in path to root.")
-        return count
+        raise TreeReferenceError(f"Wrong reference {reference} not in path to root.")
 
     def get_farthest_leaf(self: T) -> T:
         """
@@ -233,7 +241,7 @@ class Tree(ABC, Generic[T]):
         greatgrandchild1
         """
         leaves: list[T] = list(self.iterate_leaves())
-        return max(leaves, key=lambda leaf: leaf.get_distance())
+        return max(leaves, key=lambda leaf: leaf.get_distance(self))
 
     def get_layer(self: T, level: int, key: Optional[Callable[[T], Any]] = None) -> Any:
         """