lineagetree 3.0.0__tar.gz

lineagetree-3.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 leoguignard
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lineagetree-3.0.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: lineagetree
+Version: 3.0.0
+Summary: Structure for Lineage Trees
+Author: Giannis Liaskas, Christopher Mazzerbo
+Author-email: Léo Guignard <leo.guignard@univ-amu.fr>
+Maintainer-email: Léo Guignard <leo.guignard@univ-amu.fr>
+License-Expression: MIT
+Project-URL: Bug Tracker, https://github.com/GuignardLab/LineageTree/issues
+Project-URL: Documentation, https://github.com/GuignardLab/LineageTree#README.md
+Project-URL: Source Code, https://github.com/GuignardLab/LineageTree
+Project-URL: User Support, https://github.com/GuignardLab/LineageTree/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scipy>=1.9
+Requires-Dist: numpy>=1.23
+Requires-Dist: matplotlib
+Requires-Dist: edist
+Requires-Dist: svgwrite
+Requires-Dist: Micro-Mastodon-Reader
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: sphinx-rtd-theme; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: sphinx_book_theme; extra == "doc"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# 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 [Amat 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.load('path/to/file.lT')
+```
+
+For ASTEC data:
+
+```python
+from lineagetree import read_from_ASTEC
+lT = read_from_ASTEC('path/to/ASTEC.pkl')
+```
+
+For MaMuT or TrackMate:
+
+```python
+from lineagetree import read_from_mamut_xml
+lT = read_from_mamut_xml('path/to/MaMuT.xml')
+```
+
+For TGMM:
+
+```python
+from lineagetree import read_from_tgmm_xml
+lT = read_from_tgmm_xml('path/to/single_time_file{t:04d}.xml', tb=0, te=500)
+```
+
+For Mastodon:
+
+```python
+from lineagetree import read_from_mastodon
+lT = read_from_mastodon('path/to/Mastodon.mastodon')
+```
+
+or, for Mastodon csv file:
+
+```python
+from lineagetree import read_from_mastodon_csv
+lT = read_from_mastodon_csv(['path/to/nodes.csv', 'path/to/links.csv'])
+```
+
+## 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-3.0.0/README.md

@@ -0,0 +1,83 @@
+# 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 [Amat 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.load('path/to/file.lT')
+```
+
+For ASTEC data:
+
+```python
+from lineagetree import read_from_ASTEC
+lT = read_from_ASTEC('path/to/ASTEC.pkl')
+```
+
+For MaMuT or TrackMate:
+
+```python
+from lineagetree import read_from_mamut_xml
+lT = read_from_mamut_xml('path/to/MaMuT.xml')
+```
+
+For TGMM:
+
+```python
+from lineagetree import read_from_tgmm_xml
+lT = read_from_tgmm_xml('path/to/single_time_file{t:04d}.xml', tb=0, te=500)
+```
+
+For Mastodon:
+
+```python
+from lineagetree import read_from_mastodon
+lT = read_from_mastodon('path/to/Mastodon.mastodon')
+```
+
+or, for Mastodon csv file:
+
+```python
+from lineagetree import read_from_mastodon_csv
+lT = read_from_mastodon_csv(['path/to/nodes.csv', 'path/to/links.csv'])
+```
+
+## 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-3.0.0/pyproject.toml

@@ -0,0 +1,136 @@
+[build-system]
+requires = ["setuptools>=42.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project]
+authors = [
+    { name = "Léo Guignard", email = "leo.guignard@univ-amu.fr"},
+    { name = "Giannis Liaskas"},
+    { name = "Christopher Mazzerbo"},
+]
+maintainers = [
+    {name = "Léo Guignard", email = "leo.guignard@univ-amu.fr"}
+]
+name = "lineagetree"
+description = "Structure for Lineage Trees"
+version = "3.0.0"
+license = "MIT"
+license-files = [ "LICENSE" ]
+readme = {file = "README.md", content-type = "text/markdown"}
+requires-python = ">= 3.10"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+dependencies = [
+    "scipy>=1.9",
+    "numpy>=1.23",
+    "matplotlib",
+    "edist",
+    "svgwrite",
+    "Micro-Mastodon-Reader",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "black",
+    "ruff",
+    "bumpver",
+]
+doc = [
+    "sphinx-rtd-theme",
+    "myst-parser",
+    "sphinx_book_theme",
+]
+test = [
+    "pytest",
+    "pytest-cov",
+]
+
+[project.urls]
+"Bug Tracker" = "https://github.com/GuignardLab/LineageTree/issues"
+"Documentation" = "https://github.com/GuignardLab/LineageTree#README.md"
+"Source Code" = "https://github.com/GuignardLab/LineageTree"
+"User Support" = "https://github.com/GuignardLab/LineageTree/issues"
+
+[tool.black]
+line-length = 79
+
+[tool.isort]
+profile = "black"
+line_length = 79
+
+[tool.bumpver]
+current_version = "3.0.0"
+version_pattern = "MAJOR.MINOR.PATCH[-TAG]"
+commit_message = "bump version {old_version} -> {new_version}"
+commit = true
+tag = true
+push = false
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = [
+    'current_version = "{version}"',
+    'version = "{version}"',
+]
+"src/lineagetree/__init__.py" = [
+    '__version__ = "{version}"',
+]
+
+[tool.ruff]
+line-length = 79
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".mypy_cache",
+    ".pants.d",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "*vendored*",
+    "*_vendor*",
+]
+
+target-version = "py313"
+
+[tool.ty.environment]
+root = ["./src", ]
+
+[tool.ty.rules]
+unresolved-import = "ignore"
+
+[tool.coverage.run]
+source = ["lineagetree"]
+
+[tool.coverage.report]
+omit = [
+    "*/test/*",
+    "*/.vscode/*",
+    "*/site-packages/*",
+    "*/_io/*",
+    "*/_methodize.py",
+]

lineagetree-3.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lineagetree-3.0.0/src/LineageTree/__init__.py

@@ -0,0 +1,30 @@
+__version__ = "3.0.0"
+from .lineage_tree import LineageTree
+from ._io._loaders import (
+    read_from_ASTEC,
+    read_from_binary,
+    read_from_csv,
+    read_from_mamut_xml,
+    read_from_mastodon,
+    read_from_mastodon_csv,
+    read_from_tgmm_xml,
+    read_from_txt_for_celegans,
+    read_from_txt_for_celegans_BAO,
+    read_from_txt_for_celegans_CAO,
+)
+from .lineage_tree_manager import LineageTreeManager
+
+__all__ = (
+    "LineageTree",
+    "LineageTreeManager",
+    "read_from_tgmm_xml",
+    "read_from_txt_for_celegans_BAO",
+    "read_from_ASTEC",
+    "read_from_binary",
+    "read_from_csv",
+    "read_from_mamut_xml",
+    "read_from_mastodon_csv",
+    "read_from_mastodon",
+    "read_from_txt_for_celegans",
+    "read_from_txt_for_celegans_CAO",
+)

lineagetree-3.0.0/src/LineageTree/_core/_modifier.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+from functools import wraps
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..lineage_tree import LineageTree
+
+
+def modifier(wrapped_func):
+    @wraps(wrapped_func)
+    def raising_flag(self, *args, **kwargs):
+        should_reset = (
+            not hasattr(self, "_has_been_reset") or not self._has_been_reset
+        )
+        out_func = wrapped_func(self, *args, **kwargs)
+        if should_reset:
+            for prop in self._protected_dynamic_properties:
+                self.__dict__[prop] = None
+            self._has_been_reset = True
+        return out_func
+
+    return raising_flag
+
+
+###TODO pos can be callable and stay motionless (copy the position of the succ node, use something like optical flow)
+@modifier
+def add_chain(
+    lT: LineageTree,
+    node: int,
+    length: int,
+    downstream: bool,
+    pos: Callable | None = None,
+) -> int:
+    """Adds a chain of specific length to a node either as a successor or as a predecessor.
+    If it is placed on top of a tree all the nodes will move timepoints #length down.
+
+    Parameters
+    ----------
+    node : int
+        Id of the successor (predecessor if `downstream==False`)
+    length : int
+        The length of the new chain.
+    downstream : bool, default=True
+        If `True` will create a chain that goes forwards in time otherwise backwards.
+    pos : np.ndarray, optional
+        The new position of the chain. Defaults to None.
+
+    Returns
+    -------
+    int
+        Id of the first node of the sublineage.
+    """
+    if length == 0:
+        return node
+    if length < 1:
+        raise ValueError("Length cannot be <1")
+    if downstream:
+        for _ in range(int(length)):
+            old_node = node
+            node = lT._add_node(pred=[old_node])
+            lT._time[node] = lT._time[old_node] + 1
+    else:
+        if lT._predecessor[node]:
+            raise Warning("The node already has a predecessor.")
+        if lT._time[node] - length < lT.t_b:
+            raise Warning(
+                "A node cannot created outside the lower bound of the dataset. (It is possible to change it by lT.t_b = int(...))"
+            )
+        for _ in range(int(length)):
+            old_node = node
+            node = lT._add_node(succ=[old_node])
+            lT._time[node] = lT._time[old_node] - 1
+    return node
+
+
+@modifier
+def add_root(lT: LineageTree, t: int, pos: list | None = None) -> int:
+    """Adds a root to a specific timepoint.
+
+    Parameters
+    ----------
+    lT : LineageTree
+        The LineageTree instance.
+    t :int
+        The timepoint the node is going to be added.
+    pos : list
+        The position of the new node.
+    Returns
+    -------
+    int
+        The id of the new root.
+    """
+    C_next = lT.get_next_id()
+    lT._successor[C_next] = ()
+    lT._predecessor[C_next] = ()
+    lT._time[C_next] = t
+    lT.pos[C_next] = pos if isinstance(pos, list) else []
+    lT._changed_roots = True
+    return C_next
+
+
+def get_next_id(lT) -> int:
+    """Computes the next authorized id and assign it.
+
+    Returns
+    -------
+    int
+        next authorized id
+    """
+    if not hasattr(lT, "max_id") or (lT.max_id == -1 and lT.nodes):
+        lT.max_id = max(lT.nodes) if len(lT.nodes) else 0
+    if not hasattr(lT, "next_id") or lT.next_id == []:
+        lT.max_id += 1
+        return lT.max_id
+    else:
+        return lT.next_id.pop()
+
+
+@modifier
+def _add_node(
+    lT: LineageTree,
+    succ: list | None = None,
+    pred: list | None = None,
+    pos: Iterable | None = None,
+    nid: int | None = None,
+) -> int:
+    """Adds a node to the LineageTree object that is either a successor or a predecessor of another node.
+    Does not handle time! You cannot enter both a successor and a predecessor.
+
+    Parameters
+    ----------
+    lT : LineageTree
+        The LineageTree instance.
+    succ : list
+        list of ids of the nodes the new node is a successor to
+    pred : list
+        list of ids of the nodes the new node is a predecessor to
+    pos : np.ndarray, optional
+        position of the new node
+    nid : int, optional
+        id value of the new node, to be used carefully,
+        if None is provided the new id is automatically computed.
+
+    Returns
+    -------
+    int
+        id of the new node.
+    """
+    if not succ and not pred:
+        raise Warning(
+            "Please enter a successor or a predecessor, otherwise use the add_roots() function."
+        )
+    C_next = lT.get_next_id() if nid is None else nid
+    if succ:
+        lT._successor[C_next] = succ
+        for suc in succ:
+            lT._predecessor[suc] = (C_next,)
+    else:
+        lT._successor[C_next] = ()
+    if pred:
+        lT._predecessor[C_next] = pred
+        lT._successor[pred[0]] = lT._successor.setdefault(pred[0], ()) + (
+            C_next,
+        )
+    else:
+        lT._predecessor[C_next] = ()
+    if isinstance(pos, list):
+        lT.pos[C_next] = pos
+    return C_next
+
+
+@modifier
+def remove_nodes(lT: LineageTree, group: int | set | list) -> None:
+    """Removes a group of nodes from the LineageTree
+
+    Parameters
+    ----------
+    lT : LineageTree
+        The LineageTree instance.
+    group : set of int or list of int or int
+        One or more nodes that are to be removed.
+    """
+    if isinstance(group, int | float):
+        group = {group}
+    if isinstance(group, list):
+        group = set(group)
+    group = lT.nodes.intersection(group)
+    for node in group:
+        for attr in lT.__dict__:
+            attr_value = lT.__getattribute__(attr)
+            if isinstance(attr_value, dict) and attr not in [
+                "successor",
+                "predecessor",
+                "_successor",
+                "_predecessor",
+            ]:
+                attr_value.pop(node, ())
+        if lT._predecessor.get(node):
+            lT._successor[lT._predecessor[node][0]] = tuple(
+                set(lT._successor[lT._predecessor[node][0]]).difference(group)
+            )
+        for p_node in lT._successor.get(node, []):
+            lT._predecessor[p_node] = ()
+        lT._predecessor.pop(node, ())
+        lT._successor.pop(node, ())