LineageTree 1.6.1__py3-none-any.whl → 1.8.0__py3-none-any.whl

LineageTree/tree_styles.py

@@ -1,3 +1,4 @@
+import warnings
 from abc import ABC, abstractmethod
 from enum import Enum
 
@@ -7,14 +8,32 @@ from LineageTree import lineageTree
 
 
 class abstract_trees(ABC):
+    """Template class to produce different techniques to comapare lineageTrees.
+    To add a new technique you need to iherit this class or one of its children
+    and add them to the tree_style enum.
+    For a class to be valid you need a
+    - tree constructor (get_tree) that produces one dictionary that contains
+    arbitary unique labels and one dictionary that contains the duration of each node.
+    - delta function: A function that handles the cost of comparing nodes to each other.
+    - normalization function, a function that returns the length of the tree or any interger.
+    """
+
     def __init__(
-        self, lT: lineageTree, root: int, node_length: int, end_time: int
+        self,
+        lT: lineageTree,
+        root: int,
+        downsample: int,
+        end_time: int = None,
+        time_scale: int = 1,
     ):
-        self.lT = lT
-        self.root = root
-        self.node_length = node_length
-        self.end_time = end_time
-        self.tree = self.get_tree()
+        self.lT: lineageTree = lT
+        self.root: int = root
+        self.downsample: int = downsample
+        self.end_time: int = end_time if end_time else self.lT.t_e
+        self.time_scale: int = int(time_scale) if time_scale else 1
+        if time_scale <= 0:
+            raise Exception("Please used a valid time_scale (Larger than 0)")
+        self.tree: tuple = self.get_tree()
         self.edist = self._edist_format(self.tree[0])
 
     @abstractmethod
@@ -124,7 +143,7 @@ class mini_tree(abstract_trees):
             cycle = cycle[cycle_times <= self.end_time]
             if cycle.size:
                 _next = self.lT[cycle[-1]]
-                if len(_next) > 1:
+                if 1 < len(_next):
                     out_dict[current] = _next
                     to_do.extend(_next)
                 else:
@@ -177,86 +196,84 @@ class simple_tree(abstract_trees):
                     to_do.extend(_next)
                 else:
                     out_dict[current] = []
-            self.times[current] = len(
-                cycle
-            )  # * time_resolution will be fixed when working on registered trees.
+            self.times[current] = len(cycle) * self.time_scale
         return out_dict, self.times
 
     def delta(self, x, y, corres1, corres2, times1, times2):
         return super().delta(x, y, corres1, corres2, times1, times2)
 
     def get_norm(self):
-        return len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+        return (
+            len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+            * self.time_scale
+        )
 
 
-class fragmented_tree(abstract_trees):
-    """Similar idea to simple tree, but tries to correct its flaws.
-    Instead of having branches with length == life cycle of cell,nodes of specific length are added on the
-    edges of the branch, providing both accuratr results and speed.
-    It's the recommended method for calculating edit distances on developing embryos.
-    """
+class downsample_tree(abstract_trees):
+    """Downsamples a tree so every n nodes are being used as one."""
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
+        if self.downsample == 0:
+            raise Exception("Please use a valid downsampling rate")
+        if self.downsample == 1:
+            warnings.warn(
+                "Downsampling rate of 1 is identical to the full tree.",
+                stacklevel=1,
+            )
 
     def get_tree(self):
-        if self.end_time is None:
-            self.end_time = self.lT.t_e
         self.out_dict = {}
         self.times = {}
         to_do = [self.root]
-        if not isinstance(self.node_length, list):
-            self.node_length = list(self.node_length)
         while to_do:
             current = to_do.pop()
-            cycle = np.array(
-                self.lT.get_successors(current, end_time=self.end_time)
+            _next = self.lT.get_cells_at_t_from_root(
+                current,
+                self.lT.time[current] + (self.downsample / self.time_scale),
             )
-            if cycle.size > 0:
-                cumul_sum_of_nodes = np.cumsum(self.node_length) * 2 + 1
-                max_number_fragments = len(
-                    cumul_sum_of_nodes[cumul_sum_of_nodes < len(cycle)]
-                )
-                if max_number_fragments > 0:
-                    current_node_lengths = self.node_length[
-                        :max_number_fragments
-                    ].copy()
-                    length_middle_node = (
-                        len(cycle) - sum(current_node_lengths) * 2
-                    )
-                    times_tmp = (
-                        current_node_lengths
-                        + [length_middle_node]
-                        + current_node_lengths[::-1]
-                    )
-                    pos_all_nodes = np.concatenate(
-                        [[0], np.cumsum(times_tmp[:-1])]
-                    )
-                    track = cycle[pos_all_nodes]
-                    self.out_dict.update(
-                        {k: [v] for k, v in zip(track[:-1], track[1:])}
-                    )
-                    self.times.update(zip(track, times_tmp))
-                else:
-                    for i, cell in enumerate(cycle[:-1]):
-                        self.out_dict[cell] = [cycle[i + 1]]
-                        self.times[cell] = 1
-                current = cycle[-1]
-                _next = self.lT[current]
-                self.times[current] = 1
-                if _next and self.lT.time[_next[0]] <= self.end_time:
-                    to_do.extend(_next)
-                    self.out_dict[current] = _next
-                else:
-                    self.out_dict[current] = []
-
+            if _next == [current]:
+                _next = None
+            if _next and self.lT.time[_next[0]] <= self.end_time:
+                self.out_dict[current] = _next
+                to_do.extend(_next)
+            else:
+                self.out_dict[current] = []
+            self.times[current] = 1  # self.downsample
         return self.out_dict, self.times
 
     def get_norm(self):
-        return len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+        return len(self.times.values()) * self.downsample / self.time_scale
 
     def delta(self, x, y, corres1, corres2, times1, times2):
-        return super().delta(x, y, corres1, corres2, times1, times2)
+        if x is None and y is None:
+            return 0
+        if x is None:
+            return self.downsample
+        if y is None:
+            return self.downsample
+        return 0
+
+
+class normalized_simple_tree(simple_tree):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def delta(self, x, y, corres1, corres2, times1, times2):
+        if x is None and y is None:
+            return 0
+        if x is None:
+            return 1
+        if y is None:
+            return 1
+        return abs(times1[corres1[x]] - times2[corres2[y]]) / (
+            times1[corres1[x]] + times2[corres2[y]]
+        )
+
+    def get_norm(self):
+        return len(
+            self.lT.get_all_branches_of_node(self.root, end_time=self.end_time)
+        )
 
 
 class full_tree(abstract_trees):
@@ -276,24 +293,40 @@ class full_tree(abstract_trees):
             current = to_do.pop()
             _next = self.lT.successor.get(current, [])
             if _next and self.lT.time[_next[0]] <= self.end_time:
+                if self.time_scale > 1:
+                    for _ in range(self.time_scale - 1):
+                        next_id = self.lT.get_next_id()
+                        self.out_dict[current] = [next_id]
+                        current = next_id
                 self.out_dict[current] = _next
                 to_do.extend(_next)
             else:
+                for _ in range(self.time_scale - 1):
+                    next_id = self.lT.get_next_id()
+                    self.out_dict[current] = [next_id]
+                    current = next_id
                 self.out_dict[current] = []
             self.times[current] = 1
         return self.out_dict, self.times
 
     def get_norm(self):
-        return len(self.lT.get_sub_tree(self.root, end_time=self.end_time))
+        return len(self.times) * self.time_scale
 
     def delta(self, x, y, corres1, corres2, times1, times2):
-        return super().delta(x, y, corres1, corres2, times1, times2)
+        if x is None and y is None:
+            return 0
+        if x is None:
+            return 1
+        if y is None:
+            return 1
+        return 0
 
 
 class tree_style(Enum):
     mini = mini_tree
     simple = simple_tree
-    fragmented = fragmented_tree
+    normalized_simple = normalized_simple_tree
+    downsampled = downsample_tree
     full = full_tree
 
     @classmethod

LineageTree/utils.py

@@ -1,15 +1,14 @@
 import csv
-import random
 import warnings
 
-
 from LineageTree import lineageTree
 
 try:
     import motile
 except ImportError:
     warnings.warn(
-        "No motile installed therefore you will not be able to produce links with motile."
+        "No motile installed therefore you will not be able to produce links with motile.",
+        stacklevel=2,
     )
 
 
@@ -18,16 +17,13 @@ def to_motile(
 ):
     try:
         import networkx as nx
-    except:
-        raise Warning("Please install networkx")
+    except ImportError:
+        raise Warning("Please install networkx")  # noqa: B904
 
     fmt = nx.DiGraph()
     if not crop:
         crop = lT.t_e
-    # time_nodes = [
     for time in range(crop):
-        #     time_nodes += lT.time_nodes[time]
-        # print(time_nodes)
         for time_node in lT.time_nodes[time]:
             fmt.add_node(
                 time_node,
@@ -35,8 +31,6 @@ def to_motile(
                 pos=lT.pos[time_node],
                 score=1,
             )
-            # for suc in lT.successor:
-            #     fmt.add_edge(time_node, suc, **{"score":0})
 
     motile.add_cand_edges(fmt, max_dist, max_skip_frames=max_skip_frames)
 
@@ -137,7 +131,9 @@ def hierarchical_pos(
         elif len(succ) == 1:
             pos_node[succ[0]] = [
                 pos_node[curr][0],
-                pos_node[curr][1] - lnks_tms["times"].get(curr, 0),
+                pos_node[curr][1]
+                - lnks_tms["times"].get(curr, 0)
+                + min(vert_gap, lnks_tms["times"].get(curr, 0)),
             ]
             to_do.extend(succ)
             prev_width[succ[0]] = prev_width[curr]

{LineageTree-1.6.1.dist-info → LineageTree-1.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: LineageTree
-Version: 1.6.1
+Version: 1.8.0
 Summary: Lineage tree structure
 Home-page: https://github.com/leoguignard/LineageTree
 Author: Léo Guignard
@@ -28,14 +28,6 @@ Requires-Dist: scipy>=1.9
 Requires-Dist: numpy>=1.23
 Requires-Dist: mastodon-reader
 Requires-Dist: matplotlib
-Provides-Extra: all
-Requires-Dist: svgwrite; extra == "all"
-Requires-Dist: matplotlib; extra == "all"
-Requires-Dist: tox; extra == "all"
-Requires-Dist: pytest; extra == "all"
-Requires-Dist: pytest-cov; extra == "all"
-Requires-Dist: edist; extra == "all"
-Requires-Dist: mastodon-reader; extra == "all"
 Provides-Extra: svg
 Requires-Dist: svgwrite; extra == "svg"
 Requires-Dist: matplotlib; extra == "svg"
@@ -48,6 +40,14 @@ Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: mastodon-reader; extra == "test"
 Provides-Extra: treeedit
 Requires-Dist: edist; extra == "treeedit"
+Provides-Extra: all
+Requires-Dist: svgwrite; extra == "all"
+Requires-Dist: matplotlib; extra == "all"
+Requires-Dist: tox; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: pytest-cov; extra == "all"
+Requires-Dist: edist; extra == "all"
+Requires-Dist: mastodon-reader; extra == "all"
 
 # LineageTree
 
@@ -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.8.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+LineageTree/__init__.py,sha256=888vRBgs18oExOHp7Q87HSH1GL60m-YLLjkMWYnZcBI,155
+LineageTree/lineageTree.py,sha256=SoxLcYXhr5wzuX9ZXMDsK5fePd_6_Boq-y4HVJ6mBBI,102326
+LineageTree/lineageTreeManager.py,sha256=bBhJrCUmLa6D6cZ95jT4hTnNfG7q-l_FiqOf2oaBc2o,6458
+LineageTree/loaders.py,sha256=eStgVrqYeUlYQ-r7EByCZo2t5cgn-mXARTWBzLSN12Q,32778
+LineageTree/tree_styles.py,sha256=ZEj0HcoEaWk8zyObboXW-qoM3uzKAQgiNzX2-UUa0cg,11337
+LineageTree/utils.py,sha256=sFIj1eDid1EKP09g_jrSgqk4NLdNVf7KjC5UwN0Fihc,4878
+LineageTree-1.8.0.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
+LineageTree-1.8.0.dist-info/METADATA,sha256=X9UUm6EP44N_O3Uv0JN4Bu9wXU9kXAB9Nh-lHkjHoEs,4469
+LineageTree-1.8.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+LineageTree-1.8.0.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
+LineageTree-1.8.0.dist-info/RECORD,,

{LineageTree-1.6.1.dist-info → LineageTree-1.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

LineageTree-1.6.1.dist-info/RECORD

@@ -1,11 +0,0 @@
-LineageTree/__init__.py,sha256=fIOwpoeHI19rwQShQ50iRXyRg4OXzVo_A4q_BUDBmsk,155
-LineageTree/lineageTree.py,sha256=lamlTaHtu3gPUCMKIvlCHQqGMbcQAHCvgS8MB6EHWTQ,102742
-LineageTree/lineageTreeManager.py,sha256=tQMNmxAvUEd4fNLJViB-9DGItpgCRnSF-bS2_IdebMo,5566
-LineageTree/loaders.py,sha256=hKd-69d_csjcsV0zabSTEOyy0NhprFqvnRAI18tYa9w,23718
-LineageTree/tree_styles.py,sha256=IUEq8RHfwXTv3WXylpLVa5XoThaWt1i1cRsgZGXdd50,10634
-LineageTree/utils.py,sha256=kC90fi8TFm8Pz7oom_bDsq7HPPKnFdJ6wI-x36fLvHE,4962
-LineageTree-1.6.1.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
-LineageTree-1.6.1.dist-info/METADATA,sha256=eDkg_GjSQtFDXXjmyagn-gXRosFsDq2n8706srcixA8,4195
-LineageTree-1.6.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-LineageTree-1.6.1.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
-LineageTree-1.6.1.dist-info/RECORD,,