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

LineageTree/tree_styles.py

@@ -1,334 +0,0 @@
-import warnings
-from abc import ABC, abstractmethod
-from enum import Enum
-
-import numpy as np
-
-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,
-        downsample: int,
-        end_time: int = None,
-        time_scale: int = 1,
-    ):
-        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
-    def get_tree(self):
-        """
-        Get a tree version of the tree spawned by the node `r`
-
-        Args:
-            r (int): root of the tree to spawn
-            end_time (int): the last time point to consider
-            time_resolution (float): the time between two consecutive time points
-
-        Returns:
-            (dict) {m (int): [d1 (int), d2 (int)]}: an adjacency dictionnary
-                where the ids are the ids of the cells in the original tree
-                at their first time point (except for the cell `r` if it was
-                not the first time point).
-            (dict) {m (int): duration (float)}: life time duration of the cell `m`
-        """
-
-    @abstractmethod
-    def delta(self, x, y, corres1, corres2, times1, times2):
-        """The distance of two nodes inside a tree. Behaves like a staticmethod.
-            The corres1/2 and time1/2 should always be provided and will be handled accordingly by the specific
-            delta of each tree style.
-
-        Args:
-            x (int): The first node to compare, takes the names provided by the edist.
-            y (int): The second node to compare, takes the names provided by the edist
-            corres1 (dict): Correspondance between node1 and its name in the real tree.
-            corres2 (dict): Correspondance between node2 and its name in the real tree.
-            times1 (dict): The dictionary of the branch lengths of the tree that n1 is spawned from.
-            times2 (dict): The dictionary of the branch lengths of the tree that n2 is spawned from.
-
-        Returns:
-            (int|float): The diatance between these 2 nodes.
-        """
-        if x is None and y is None:
-            return 0
-        if x is None:
-            return times2[corres2[y]]
-        if y is None:
-            return times1[corres1[x]]
-        len_x = times1[corres1[x]]
-        len_y = times2[corres2[y]]
-        return np.abs(len_x - len_y)
-
-    @abstractmethod
-    def get_norm(self):
-        """
-        Returns the valid value for normalizing the edit distance.
-        Returns:
-            (int|float): The number of nodes of each tree according to each style.
-        """
-
-    def _edist_format(self, adj_dict: dict):
-        """Formating the custom tree style to the format needed by edist.
-        SHOULD NOT BE CHANGED.
-
-        Args:
-            adj_dict (dict): _description_
-
-        Returns:
-            _type_: _description_
-        """
-        inv_adj = {vi: k for k, v in adj_dict.items() for vi in v}
-        roots = set(adj_dict).difference(inv_adj)
-        nid2list = {}
-        list2nid = {}
-        nodes = []
-        adj_list = []
-        curr_id = 0
-        for r in roots:
-            to_do = [r]
-            while to_do:
-                curr = to_do.pop(0)
-                nid2list[curr] = curr_id
-                list2nid[curr_id] = curr
-                nodes.append(curr_id)
-                to_do = adj_dict.get(curr, []) + to_do
-                curr_id += 1
-            adj_list = [
-                [nid2list[d] for d in adj_dict.get(list2nid[_id], [])]
-                for _id in nodes
-            ]
-        return nodes, adj_list, list2nid
-
-
-class mini_tree(abstract_trees):
-    """Each branch is converted to a node of length 1, it is useful for comparing synchronous developing cells, extremely fast.
-    Mainly used for testing.
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def get_tree(self):
-        if self.end_time is None:
-            self.end_time = self.lT.t_e
-        out_dict = {}
-        self.times = {}
-        to_do = [self.root]
-        while to_do:
-            current = to_do.pop()
-            cycle = np.array(self.lT.get_successors(current))
-            cycle_times = np.array([self.lT.time[c] for c in cycle])
-            cycle = cycle[cycle_times <= self.end_time]
-            if cycle.size:
-                _next = self.lT[cycle[-1]]
-                if 1 < len(_next):
-                    out_dict[current] = _next
-                    to_do.extend(_next)
-                else:
-                    out_dict[current] = []
-        self.length = len(out_dict)
-        return out_dict, None
-
-    def get_norm(self):
-        return len(
-            self.lT.get_all_branches_of_node(self.root, end_time=self.end_time)
-        )
-
-    def _edist_format(self, adj_dict: dict):
-        return super()._edist_format(adj_dict)
-
-    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 0
-
-
-class simple_tree(abstract_trees):
-    """Each branch is converted to one node with length the same as the life cycle of the cell.
-    This method is fast, but imprecise, especialy for small trees (recommended height of the trees should be 100 at least).
-    Use with CAUTION.
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def get_tree(self):
-        if self.end_time is None:
-            self.end_time = self.lT.t_e
-        out_dict = {}
-        self.times = {}
-        to_do = [self.root]
-        while to_do:
-            current = to_do.pop()
-            cycle = np.array(self.lT.get_successors(current))
-            cycle_times = np.array([self.lT.time[c] for c in cycle])
-            cycle = cycle[cycle_times <= self.end_time]
-            if cycle.size:
-                _next = self.lT[cycle[-1]]
-                if len(_next) > 1 and self.lT.time[cycle[-1]] < self.end_time:
-                    out_dict[current] = _next
-                    to_do.extend(_next)
-                else:
-                    out_dict[current] = []
-            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))
-            * self.time_scale
-        )
-
-
-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):
-        self.out_dict = {}
-        self.times = {}
-        to_do = [self.root]
-        while to_do:
-            current = to_do.pop()
-            _next = self.lT.get_cells_at_t_from_root(
-                current,
-                self.lT.time[current] + (self.downsample / self.time_scale),
-            )
-            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.times.values()) * self.downsample / self.time_scale
-
-    def delta(self, 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):
-    """No approximations the whole tree is used here. Perfect accuracy, but heavy on ram and speed.
-    Not recommended to use on napari.
-
-    """
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    def get_tree(self) -> dict:
-        self.out_dict = {}
-        self.times = {}
-        to_do = [self.root]
-        while to_do:
-            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.times) * self.time_scale
-
-    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 0
-
-
-class tree_style(Enum):
-    mini = mini_tree
-    simple = simple_tree
-    normalized_simple = normalized_simple_tree
-    downsampled = downsample_tree
-    full = full_tree
-
-    @classmethod
-    def list_names(self):
-        return [style.name for style in self]

LineageTree-1.8.0.dist-info/METADATA

@@ -1,156 +0,0 @@
-Metadata-Version: 2.2
-Name: LineageTree
-Version: 1.8.0
-Summary: Lineage tree structure
-Home-page: https://github.com/leoguignard/LineageTree
-Author: Léo Guignard
-Author-email: leo.guignard@univ-amu.fr
-License: MIT
-Project-URL: Bug Tracker, https://github.com/leoguignard/LineageTree/issues
-Project-URL: Documentation, https://github.com/leoguignard/LineageTree#README.md
-Project-URL: Source Code, https://github.com/leoguignard/LineageTree
-Project-URL: User Support, https://github.com/leoguignard/LineageTree/issues
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Topic :: Scientific/Engineering :: Image Processing
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: scipy>=1.9
-Requires-Dist: numpy>=1.23
-Requires-Dist: mastodon-reader
-Requires-Dist: matplotlib
-Provides-Extra: svg
-Requires-Dist: svgwrite; extra == "svg"
-Requires-Dist: matplotlib; extra == "svg"
-Provides-Extra: test
-Requires-Dist: svgwrite; extra == "test"
-Requires-Dist: matplotlib; extra == "test"
-Requires-Dist: tox; extra == "test"
-Requires-Dist: pytest; extra == "test"
-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
-
-This library allows to import and work with cell (but not limited to cells) lineage trees.
-With LineageTree you can read from:
-
-- TGMM algorithm outputs described in [Fernando et al. 2014](https://www.nature.com/articles/nmeth.3036)
-- TrackMate files described in [Tinevez et al. 2017](https://doi.org/10.1016/j.ymeth.2016.09.016)
-- 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
-
-Once installed the library can be called the following way (as an example):
-
-```python
-from LineageTree import lineageTree
-```
-
-and one can then load lineage trees the following way:
-
-For `.lT` files:
-
-```python
-lT = lineageTree('path/to/file.lT')
-```
-
-For ASTEC data:
-
-```python
-lT = lineageTree('path/to/ASTEC.pkl', file_type='ASTEC')
-```
-
-or
-
-```python
-lT = lineageTree('path/to/ASTEC.xml', file_type='ASTEC')
-```
-
-For SVF:
-
-```python
-lT = lineageTree('path/to/SVF.bin')
-```
-
-For MaMuT:
-
-```python
-lT = lineageTree('path/to/MaMuT.xml', file_type='MaMuT')
-```
-
-For TrackMate:
-
-```python
-lT = lineageTree('path/to/MaMuT.xml', file_type='TrackMate')
-```
-
-For TGMM:
-
-```python
-lT = lineageTree('path/to/single_time_file{t:04d}.xml', tb=0, te=500, file_type='TGMM')
-```
-
-For Mastodon:
-
-```python
-lT = lineageTree('path/to/Mastodon.mastodon', file_type='mastodon')
-```
-
-or, for Mastodon csv file:
-
-```python
-lT = lineageTree(['path/to/nodes.csv', 'path/to/links.csv'], file_type='mastodon')
-```
-
-## Dependencies
-
-Some dependecies are requiered:
-
-- general python dependecies:
-  - numpy, scipy
-- specific dependency:
-  - svgwrite if svg output is needed
-
-## Quick install
-
-To quickly install the library together with its dependencies one can run:
-
-```shell
-pip install LineageTree
-```
-
-or, for the latest version if you have cloned the directory:
-
-```shell
-pip install .
-```
-
-or for the latest version wihtout cloning the directory
-
-```shell
-pip install git+https://github.com/leoguignard/LineageTree
-```

LineageTree-1.8.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-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,,