refactor corefud.Delete

martinpopel · martinpopel · commit c28dfd34a6ad · 2024-04-15T20:11:37.000+02:00
It may be subjective, but I find this easier to understand the code.
diff --git a/udapi/block/corefud/delete.py b/udapi/block/corefud/delete.py
@@ -25,19 +25,15 @@ def is_root_reachable_by_deps(self, node, parents_to_ignore=None):
             proc_node, path = stack.pop()
             # root is reachable
             if proc_node == node.root:
-                break
+                return True
             # path forms a cycle, the root cannot be reached through this branch
-            if proc_node in path:
-                continue
-            for dep in proc_node.deps:
-                # the root cannot be reached through ignored nodes
-                if dep['parent'] in parents_to_ignore:
-                    continue
-                # process the parent recursively
-                stack.append((dep['parent'], path + [proc_node]))
-        else:
-            return False
-        return True
+            if proc_node not in path:
+                for dep in proc_node.deps:
+                    # the root cannot be reached through ignored nodes
+                    if dep['parent'] not in parents_to_ignore:
+                        # process the parent recursively
+                        stack.append((dep['parent'], path + [proc_node]))
+        return False
 
     def _deps_ignore_nodes(self, node, parents_to_ignore):
         """ Retrieve deps from the node, recursively ignoring specified parents.
@@ -46,18 +42,16 @@ def _deps_ignore_nodes(self, node, parents_to_ignore):
         stack = [(node, [])]
         while stack:
             proc_node, skipped_nodes = stack.pop()
-            # if there is a cycle of skipped nodes, ground the subtree to the root
-            if proc_node in skipped_nodes:
-                newdeps.append({'parent': node.root, 'deprel': 'root'})
-                continue
-            for dep in proc_node.deps:
-                # keep deps with a parent that shouldn't be ignored
-                if not dep['parent'] in parents_to_ignore:
-                    newdeps.append(dep)
-                    continue
-                # process the ignored parent recursively
-                stack.append((dep['parent'], skipped_nodes + [proc_node]))
-        return newdeps
+            if proc_node not in skipped_nodes:
+                for dep in proc_node.deps:
+                    if dep['parent'] in parents_to_ignore:
+                        # process the ignored parent recursively
+                        stack.append((dep['parent'], skipped_nodes + [proc_node]))
+                    else:
+                        # keep deps with a parent that shouldn't be ignored
+                        newdeps.append(dep)
+        # If no newdeps were found (because of a cycle), return the root.
+        return newdeps if newdeps else [{'parent': node.root, 'deprel': 'root'}]
 
     def process_document(self, doc):
         # This block should work both with coreference loaded (deserialized) and not.
