LineageTree 1.7.0__tar.gz → 1.8.0__tar.gz

{lineagetree-1.7.0/src/LineageTree.egg-info → lineagetree-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: LineageTree
-Version: 1.7.0
+Version: 1.8.0
 Summary: Lineage tree structure
 Home-page: https://github.com/leoguignard/LineageTree
 Author: Léo Guignard
@@ -59,6 +59,7 @@ With LineageTree you can read from:
 - MaMuT files described in [Wolff et al. 2018](https://doi.org/10.7554/eLife.34410)
 - SVF algorithm outputs described in [McDole, Guignard et al. 2018](https://doi.org/10.1016/j.cell.2018.09.031)
 - ASTEC algorithm outputs described in [Guignard, Fiuza et al. 2020](https://doi.org/10.1126/science.aar5663)
+- Data from the [Digital development Database](http://digital-development.org/index.html) described in [Du et al. 2014](https://www.cell.com/fulltext/S0092-8674(13)01542-0) and [Du et al. 2015](https://www.sciencedirect.com/science/article/pii/S1534580715004876?via%3Dihub)
 - and few others
 
 ## Basic usage

{lineagetree-1.7.0 → lineagetree-1.8.0}/README.md

@@ -8,6 +8,7 @@ With LineageTree you can read from:
 - MaMuT files described in [Wolff et al. 2018](https://doi.org/10.7554/eLife.34410)
 - SVF algorithm outputs described in [McDole, Guignard et al. 2018](https://doi.org/10.1016/j.cell.2018.09.031)
 - ASTEC algorithm outputs described in [Guignard, Fiuza et al. 2020](https://doi.org/10.1126/science.aar5663)
+- Data from the [Digital development Database](http://digital-development.org/index.html) described in [Du et al. 2014](https://www.cell.com/fulltext/S0092-8674(13)01542-0) and [Du et al. 2015](https://www.sciencedirect.com/science/article/pii/S1534580715004876?via%3Dihub)
 - and few others
 
 ## Basic usage

{lineagetree-1.7.0 → lineagetree-1.8.0}/pyproject.toml

@@ -10,7 +10,7 @@ profile = "black"
 line_length = 79
 
 [tool.bumpver]
-current_version = "1.7.0"
+current_version = "1.8.0"
 version_pattern = "MAJOR.MINOR.PATCH[-TAG]"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true
@@ -40,13 +40,15 @@ select = [
     "G", # flake8-logging-format
     "PIE", # flake8-pie
     "SIM", # flake8-simplify
-    "I"
+    "I", # imports
+    "T201", # print statements
+    "ERA001", #commented out code
 ]
 ignore = [
     "E501", # line too long. let black handle this
     "UP006", "UP007", # type annotation. As using magicgui require runtime type annotation then we disable this.
     "SIM117", # flake8-simplify - some of merged with statements are not looking great with black, reanble after drop python 3.9
-    "SIM300"
+    "SIM300", # yoda conditions
 ]
 
 exclude = [

{lineagetree-1.7.0 → lineagetree-1.8.0}/src/LineageTree/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.7.0"
+__version__ = "1.8.0"
 from .lineageTree import lineageTree
 from .lineageTreeManager import lineageTreeManager
 

{lineagetree-1.7.0 → lineagetree-1.8.0}/src/LineageTree/lineageTree.py

@@ -70,7 +70,12 @@ class lineageTree(lineageTreeLoaders):
             sub = set(self.get_sub_tree(node))
             specific_leaves = sub.intersection(self.leaves)
             for leaf in specific_leaves:
-                self.add_branch(leaf, self.t_e - self.time[leaf], reverse=True)
+                self.add_branch(
+                    leaf,
+                    (self.t_e - self.time[leaf]),
+                    reverse=True,
+                    move_timepoints=True,
+                )
 
     ###TODO pos can be callable and stay motionless (copy the position of the succ node, use something like optical flow)
     def add_branch(
@@ -88,7 +93,7 @@ class lineageTree(lineageTreeLoaders):
             pred (int): Id of the successor (predecessor if reverse is False)
             length (int): The length of the new branch.
             pos (np.ndarray, optional): The new position of the branch. Defaults to None.
-            move_timepoints (bool): Moves the ti Important only if reverse= True
+            move_timepoints (bool): Moves the time, important only if reverse= True
             reverese (bool): If True will create a branch that goes forwards in time otherwise backwards.
         Returns:
             (int): Id of the first node of the sublineage.
@@ -138,14 +143,12 @@ class lineageTree(lineageTreeLoaders):
                     reverse=False,
                 )
                 pred = _next
+            self.successor[self.get_cycle(pred)[-1]] = []
             self.labels[pred] = "New branch"
         if self.time[pred] == self.t_b:
-            self.roots.add(pred)
             self.labels[pred] = "New branch"
         if original in self.roots and reverse is True:
-            self.roots.add(pred)
             self.labels[pred] = "New branch"
-            self.roots.remove(original)
             self.labels.pop(original, -1)
         self.t_e = max(self.time_nodes)
         return pred
@@ -167,9 +170,7 @@ class lineageTree(lineageTreeLoaders):
             self.predecessor.pop(new_lT)
             label_of_root = self.labels.get(cycle[0], cycle[0])
             self.labels[cycle[0]] = f"L-Split {label_of_root}"
-            new_tr = self.add_branch(
-                new_lT, len(cycle) + 1, move_timepoints=False
-            )
+            new_tr = self.add_branch(new_lT, len(cycle), move_timepoints=False)
             self.roots.add(new_tr)
             self.labels[new_tr] = f"R-Split {label_of_root}"
             return new_tr
@@ -209,7 +210,10 @@ class lineageTree(lineageTreeLoaders):
         self.remove_nodes(new_root1)
         self.successor[new_root2].append(next_root1)
         self.predecessor[next_root1] = [new_root2]
-        new_branch = self.add_branch(new_root2, length)
+        new_branch = self.add_branch(
+            new_root2,
+            length - 1,
+        )
         self.labels[new_branch] = f"Fusion of {new_root1} and {new_root2}"
         return new_branch
 
@@ -321,7 +325,7 @@ class lineageTree(lineageTreeLoaders):
             new_length (int): The new length of the tree.
         """
         if new_length <= 1:
-            warnings.warn("New length should be more than 1")
+            warnings.warn("New length should be more than 1", stacklevel=2)
             return None
         cycle = self.get_cycle(node)
         length = len(cycle)
@@ -383,14 +387,29 @@ class lineageTree(lineageTreeLoaders):
         if time_resolution is not None:
             self._time_resolution = int(time_resolution * 10)
         else:
-            warnings.warn("Time resolution set to default 1", stacklevel=2)
+            warnings.warn("Time resolution set to default 0", stacklevel=2)
             self._time_resolution = 10
 
+    @property
+    def depth(self):
+        if not hasattr(self, "_depth"):
+            self._depth = {}
+            for leaf in self.leaves:
+                self._depth[leaf] = 1
+                while leaf in self.predecessor:
+                    parent = self.predecessor[leaf][0]
+                    current_depth = self._depth.get(parent, 0)
+                    self._depth[parent] = max(
+                        self._depth[leaf] + 1, current_depth
+                    )
+                    leaf = parent
+            for root in self.roots - set(self._depth):
+                self._depth[root] = 1
+        return self._depth
+
     @property
     def roots(self):
-        if not hasattr(self, "_roots"):
-            self._roots = set(self.nodes).difference(self.predecessor)
-        return self._roots
+        return set(self.nodes).difference(self.predecessor)
 
     @property
     def edges(self):
@@ -398,7 +417,7 @@ class lineageTree(lineageTreeLoaders):
 
     @property
     def leaves(self):
-        return set(self.predecessor).difference(self.successor)
+        return {p for p, s in self.successor.items() if s == []}
 
     @property
     def labels(self):
@@ -409,10 +428,10 @@ class lineageTree(lineageTreeLoaders):
                 }
             else:
                 self._labels = {
-                    i: "Unlabeled"
-                    for i in self.roots
-                    for l in self.find_leaves(i)
-                    if abs(self.time[l] - self.time[i])
+                    root: "Unlabeled"
+                    for root in self.roots
+                    for leaf in self.find_leaves(root)
+                    if abs(self.time[leaf] - self.time[root])
                     >= abs(self.t_e - self.t_b) / 4
                 }
         return self._labels
@@ -504,7 +523,7 @@ class lineageTree(lineageTreeLoaders):
 
                 f.write("@5\n")
                 for C in self.to_take_time[t]:
-                    f.write("%f\n" % (manual_labels.get(C, default_label)))
+                    f.write(f"{manual_labels.get(C, default_label):f}\n")
                     f.write(f"{0:f}\n")
 
                 f.write("@6\n")
@@ -523,8 +542,7 @@ class lineageTree(lineageTreeLoaders):
                 f.write("@7\n")
                 for C in self.to_take_time[t]:
                     f.write(
-                        "%f\n"
-                        % (np.linalg.norm(points_v[C][0] - points_v[C][-1]))
+                        f"{np.linalg.norm(points_v[C][0] - points_v[C][-1]):f}\n"
                     )
 
                 f.write("@8\n")
@@ -953,10 +971,10 @@ class lineageTree(lineageTreeLoaders):
             if node_properties:
                 for p_name, (p_dict, default) in node_properties.items():
                     if isinstance(list(p_dict.values())[0], str):
-                        f.write('(property 0 string "%s"\n' % p_name)
+                        f.write(f'(property 0 string "{p_name}"\n')
                         f.write(f"\t(default {default} {default})\n")
                     elif isinstance(list(p_dict.values())[0], Number):
-                        f.write('(property 0 double "%s"\n' % p_name)
+                        f.write(f'(property 0 double "{p_name}"\n')
                         f.write('\t(default "0" "0")\n')
                     for n in nodes_to_use:
                         f.write(
@@ -1030,148 +1048,6 @@ class lineageTree(lineageTreeLoaders):
 
             f.close()
 
-    def read_from_binary(self, fname: str):
-        """
-        Reads a binary lineageTree file name.
-        Format description: see self.to_binary
-
-        Args:
-            fname: string, path to the binary file
-            reverse_time: bool, not used
-        """
-        q_size = struct.calcsize("q")
-        H_size = struct.calcsize("H")
-        d_size = struct.calcsize("d")
-
-        with open(fname, "rb") as f:
-            len_tree = struct.unpack("q", f.read(q_size))[0]
-            len_time = struct.unpack("q", f.read(q_size))[0]
-            len_pos = struct.unpack("q", f.read(q_size))[0]
-            number_sequence = list(
-                struct.unpack("q" * len_tree, f.read(q_size * len_tree))
-            )
-            time_sequence = list(
-                struct.unpack("H" * len_time, f.read(H_size * len_time))
-            )
-            pos_sequence = np.array(
-                struct.unpack("d" * len_pos, f.read(d_size * len_pos))
-            )
-
-            f.close()
-
-        successor = {}
-        predecessor = {}
-        time = {}
-        time_nodes = {}
-        time_edges = {}
-        pos = {}
-        is_root = {}
-        nodes = []
-        edges = []
-        waiting_list = []
-        print(number_sequence[0])
-        i = 0
-        done = False
-        if max(number_sequence[::2]) == -1:
-            tmp = number_sequence[1::2]
-            if len(tmp) * 3 == len(pos_sequence) == len(time_sequence) * 3:
-                time = dict(list(zip(tmp, time_sequence)))
-                for c, t in time.items():
-                    time_nodes.setdefault(t, set()).add(c)
-                pos = dict(
-                    list(zip(tmp, np.reshape(pos_sequence, (len_time, 3))))
-                )
-                is_root = {c: True for c in tmp}
-                nodes = tmp
-                done = True
-        while (
-            i < len(number_sequence) and not done
-        ):  # , c in enumerate(number_sequence[:-1]):
-            c = number_sequence[i]
-            if c == -1:
-                if waiting_list != []:
-                    prev_mother = waiting_list.pop()
-                    successor[prev_mother].insert(0, number_sequence[i + 1])
-                    edges.append((prev_mother, number_sequence[i + 1]))
-                    time_edges.setdefault(t, set()).add(
-                        (prev_mother, number_sequence[i + 1])
-                    )
-                    is_root[number_sequence[i + 1]] = False
-                    t = time[prev_mother] + 1
-                else:
-                    t = time_sequence.pop(0)
-                    is_root[number_sequence[i + 1]] = True
-
-            elif c == -2:
-                successor[waiting_list[-1]] = [number_sequence[i + 1]]
-                edges.append((waiting_list[-1], number_sequence[i + 1]))
-                time_edges.setdefault(t, set()).add(
-                    (waiting_list[-1], number_sequence[i + 1])
-                )
-                is_root[number_sequence[i + 1]] = False
-                pos[waiting_list[-1]] = pos_sequence[:3]
-                pos_sequence = pos_sequence[3:]
-                nodes.append(waiting_list[-1])
-                time[waiting_list[-1]] = t
-                time_nodes.setdefault(t, set()).add(waiting_list[-1])
-                t += 1
-
-            elif number_sequence[i + 1] >= 0:
-                successor[c] = [number_sequence[i + 1]]
-                edges.append((c, number_sequence[i + 1]))
-                time_edges.setdefault(t, set()).add(
-                    (c, number_sequence[i + 1])
-                )
-                is_root[number_sequence[i + 1]] = False
-                pos[c] = pos_sequence[:3]
-                pos_sequence = pos_sequence[3:]
-                nodes.append(c)
-                time[c] = t
-                time_nodes.setdefault(t, set()).add(c)
-                t += 1
-
-            elif number_sequence[i + 1] == -2:
-                waiting_list += [c]
-
-            elif number_sequence[i + 1] == -1:
-                pos[c] = pos_sequence[:3]
-                pos_sequence = pos_sequence[3:]
-                nodes.append(c)
-                time[c] = t
-                time_nodes.setdefault(t, set()).add(c)
-                t += 1
-                i += 1
-                if waiting_list != []:
-                    prev_mother = waiting_list.pop()
-                    successor[prev_mother].insert(0, number_sequence[i + 1])
-                    edges.append((prev_mother, number_sequence[i + 1]))
-                    time_edges.setdefault(t, set()).add(
-                        (prev_mother, number_sequence[i + 1])
-                    )
-                    if i + 1 < len(number_sequence):
-                        is_root[number_sequence[i + 1]] = False
-                    t = time[prev_mother] + 1
-                else:
-                    if len(time_sequence) > 0:
-                        t = time_sequence.pop(0)
-                    if i + 1 < len(number_sequence):
-                        is_root[number_sequence[i + 1]] = True
-            i += 1
-
-        predecessor = {vi: [k] for k, v in successor.items() for vi in v}
-
-        self.successor = successor
-        self.predecessor = predecessor
-        self.time = time
-        self.time_nodes = time_nodes
-        self.time_edges = time_edges
-        self.pos = pos
-        self.nodes = set(nodes)
-        self.t_b = min(time_nodes.keys())
-        self.t_e = max(time_nodes.keys())
-        self.is_root = is_root
-        self.max_id = max(self.nodes)
-
     def write(self, fname: str):
         """
         Write a lineage tree on disk as an .lT file.
@@ -1186,7 +1062,7 @@ class lineageTree(lineageTreeLoaders):
             f.close()
 
     @classmethod
-    def load(clf, fname: str, rm_empty_lists=True):
+    def load(clf, fname: str, rm_empty_lists=False):
         """
         Loading a lineage tree from a ".lT" file.
 
@@ -1201,18 +1077,6 @@ class lineageTree(lineageTreeLoaders):
             f.close()
         if not hasattr(lT, "time_resolution"):
             lT.time_resolution = None
-        if rm_empty_lists:
-            if [] in lT.successor.values():
-                for node, succ in lT.successor.items():
-                    if succ == []:
-                        lT.successor.pop(node)
-            if [] in lT.predecessor.values():
-                for node, succ in lT.predecessor.items():
-                    if succ == []:
-                        lT.predecessor.pop(node)
-            lT.t_e = max(lT.time_nodes)
-            lT.t_b = min(lT.time_nodes)
-            warnings.warn("Empty lists have been removed")
         return lT
 
     def get_idx3d(self, t: int) -> tuple:
@@ -1474,11 +1338,10 @@ class lineageTree(lineageTreeLoaders):
         leaves = set()
         while to_do:
             curr = to_do.pop()
-            succ = self.successor.get(curr)
-            if succ is not None:
+            succ = self.successor.get(curr, [])
+            if not succ:
                 leaves.add(curr)
-            else:
-                to_do += succ
+            to_do += succ
         return leaves
 
     def get_sub_tree(
@@ -1883,7 +1746,6 @@ class lineageTree(lineageTreeLoaders):
         color_of_edges=None,
         size=10,
         ax=None,
-        figure=None,
         default_color="black",
         **kwargs,
     ):
@@ -1940,7 +1802,7 @@ class lineageTree(lineageTreeLoaders):
         )
         ax.get_yaxis().set_visible(False)
         ax.get_xaxis().set_visible(False)
-        return figure, ax
+        return ax.get_figure(), ax
 
     def to_simple_graph(self, node=None, start_time: int = None):
         """Generates a dictionary of graphs where the keys are the index of the graph and
@@ -1975,8 +1837,8 @@ class lineageTree(lineageTreeLoaders):
         figsize=(10, 15),
         dpi=100,
         fontsize=15,
-        figure=None,
         axes=None,
+        vert_gap=1,
         **kwargs,
     ):
         """Plots all lineages.
@@ -2006,14 +1868,24 @@ class lineageTree(lineageTreeLoaders):
             )
         pos = {
             i: hierarchical_pos(
-                g, g["root"], ycenter=-int(self.time[g["root"]])
+                g,
+                g["root"],
+                ycenter=-int(self.time[g["root"]]),
+                vert_gap=vert_gap,
             )
             for i, g in graphs.items()
         }
-        ncols = int(len(graphs) // nrows) + (+np.sign(len(graphs) % nrows))
-        figure, axes = plt.subplots(
-            figsize=figsize, nrows=nrows, ncols=ncols, dpi=dpi, sharey=True
-        )
+        if axes is None:
+            ncols = int(len(graphs) // nrows) + (+np.sign(len(graphs) % nrows))
+            figure, axes = plt.subplots(
+                figsize=figsize, nrows=nrows, ncols=ncols, dpi=dpi, sharey=True
+            )
+        else:
+            figure, axes = axes.flatten()[0].get_figure(), axes
+            if len(axes.flatten()) < len(graphs):
+                raise Exception(
+                    f"Not enough axes, they should be at least {len(graphs)}."
+                )
         flat_axes = axes.flatten()
         ax2root = {}
         min_width, min_height = float("inf"), float("inf")
@@ -2051,9 +1923,17 @@ class lineageTree(lineageTreeLoaders):
                 },
             )
         [figure.delaxes(ax) for ax in axes.flatten() if not ax.has_data()]
-        return figure, axes, ax2root
+        return axes.flatten()[0].get_figure(), axes, ax2root
 
-    def plot_node(self, node, figsize=(4, 7), dpi=150, vert_gap=2, **kwargs):
+    def plot_node(
+        self,
+        node,
+        figsize=(4, 7),
+        dpi=150,
+        vert_gap=2,
+        ax=None,
+        **kwargs,
+    ):
         """Plots the subtree spawn by a node.
 
         Args:
@@ -2064,7 +1944,10 @@ class lineageTree(lineageTreeLoaders):
         if len(graph) > 1:
             raise Warning("Please enter only one node")
         graph = graph[0]
-        figure, ax = plt.subplots(nrows=1, ncols=1, figsize=figsize, dpi=dpi)
+        if not ax:
+            figure, ax = plt.subplots(
+                nrows=1, ncols=1, figsize=figsize, dpi=dpi
+            )
         self.draw_tree_graph(
             hier=hierarchical_pos(
                 graph,
@@ -2074,9 +1957,8 @@ class lineageTree(lineageTreeLoaders):
             ),
             lnks_tms=graph,
             ax=ax,
-            **kwargs,
         )
-        return figure, ax
+        return ax.get_figure(), ax
 
     # def DTW(self, t1, t2, max_w=None, start_delay=None, end_delay=None,
     #         metric='euclidian', **kwargs):
@@ -2729,6 +2611,7 @@ class lineageTree(lineageTreeLoaders):
             warnings.warn(
                 "Error: not possible to show alignment in PCA projection !",
                 UserWarning,
+                stacklevel=2,
             )
 
         return distance, fig
@@ -2824,6 +2707,8 @@ class lineageTree(lineageTreeLoaders):
                 self.read_from_ASTEC(file_format, eigen)
             elif file_type == "csv":
                 self.read_from_csv(file_format, z_mult, link=1, delim=delim)
+            elif file_type == "bao":
+                self.read_C_elegans_bao(file_format)
             elif file_format and file_format.endswith(".lT"):
                 with open(file_format, "br") as f:
                     tmp = pkl.load(f)
@@ -2834,15 +2719,5 @@ class lineageTree(lineageTreeLoaders):
             if self.name is None:
                 try:
                     self.name = Path(file_format).stem
-                except:
+                except TypeError:
                     self.name = Path(file_format[0]).stem
-        if [] in self.successor.values():
-            successors = list(self.successor.keys())
-            for succ in successors:
-                if self[succ] == []:
-                    self.successor.pop(succ)
-        if [] in self.predecessor.values():
-            predecessors = list(self.predecessor.keys())
-            for succ in predecessors:
-                if self[succ] == []:
-                    self.predecessor.pop(succ)

{lineagetree-1.7.0 → lineagetree-1.8.0}/src/LineageTree/lineageTreeManager.py

@@ -2,6 +2,7 @@ import os
 import pickle as pkl
 import warnings
 from functools import partial
+
 import numpy as np
 
 try:
@@ -21,21 +22,19 @@ class lineageTreeManager:
         self.lineagetrees = {}
         self.lineageTree_counter = 0
         self.registered = {}
-        self.greatest_common_divisors = {}
 
     def __next__(self):
         self.lineageTree_counter += 1
         return self.lineageTree_counter - 1
 
-    def gcd_update(self, new_embryo):
-        if len(self.lineagetrees) > 1:
-            for lineagetree in self.lineagetrees:
-                self.greatest_common_divisors[lineagetree, new_embryo.name] = (
-                    np.gcd(
-                        self.lineagetrees[lineagetree].time_resolution,
-                        new_embryo.time_resolution,
-                    )
-                )
+    @property
+    def gcd(self):
+        if len(self.lineagetrees) >= 1:
+            all_time_res = [
+                embryo._time_resolution
+                for embryo in self.lineagetrees.values()
+            ]
+            return np.gcd.reduce(all_time_res)
 
     def add(
         self, other_tree: lineageTree, name: str = "", classification: str = ""
@@ -64,7 +63,6 @@ class lineageTreeManager:
                     name = f"Lineagetree {next(self)}"
                     self.lineagetrees[name] = other_tree
                     self.lineagetrees[name].name = name
-                    # self.greatest_common_divisors[name] = gcd
         else:
             raise Exception(
                 "Please add a LineageTree object or add time resolution to the LineageTree added."
@@ -120,7 +118,7 @@ class lineageTreeManager:
         n2: int,
         embryo_2,
         end_time2: int,
-        style="fragmented",
+        style="simple",
         downsample: int = 2,
         registration=None,  # will be added as a later feature
     ):
@@ -141,21 +139,48 @@ class lineageTreeManager:
         """
 
         tree = tree_style[style].value
+        lcm = (
+            self.lineagetrees[embryo_1]._time_resolution
+            * self.lineagetrees[embryo_2]._time_resolution
+        ) / self.gcd
+        if style == "downsampled":
+            if downsample % (lcm / 10) != 0:
+                raise Exception(
+                    f"Use a valid downsampling rate (multiple of {lcm/10})"
+                )
+            time_res = [
+                downsample / self.lineagetrees[embryo_2].time_resolution,
+                downsample / self.lineagetrees[embryo_1].time_resolution,
+            ]
+        elif style == "full":
+            time_res = [
+                lcm / 10 / self.lineagetrees[embryo_2].time_resolution,
+                lcm / 10 / self.lineagetrees[embryo_1].time_resolution,
+            ]
+        else:
+            time_res = [
+                self.lineagetrees[embryo_1]._time_resolution,
+                self.lineagetrees[embryo_2]._time_resolution,
+            ]
+            time_res = [i / self.gcd for i in time_res]
         tree1 = tree(
             lT=self.lineagetrees[embryo_1],
             downsample=downsample,
             end_time=end_time1,
             root=n1,
+            time_scale=time_res[0],
         )
         tree2 = tree(
             lT=self.lineagetrees[embryo_2],
             downsample=downsample,
             end_time=end_time2,
             root=n2,
+            time_scale=time_res[1],
         )
         delta = tree1.delta
         _, times1 = tree1.tree
         _, times2 = tree2.tree
+
         nodes1, adj1, corres1 = tree1.edist
         nodes2, adj2, corres2 = tree2.edist
         if len(nodes1) == len(nodes2) == 0: