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

LineageTree/utils.py

@@ -1,122 +1,88 @@
-import csv
-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.",
-        stacklevel=2,
-    )
-
-
-def to_motile(
-    lT: lineageTree, crop: int = None, max_dist=200, max_skip_frames=1
-):
-    try:
-        import networkx as nx
-    except ImportError:
-        raise Warning("Please install networkx")  # noqa: B904
-
-    fmt = nx.DiGraph()
-    if not crop:
-        crop = lT.t_e
-    for time in range(crop):
-        for time_node in lT.time_nodes[time]:
-            fmt.add_node(
-                time_node,
-                t=lT.time[time_node],
-                pos=lT.pos[time_node],
-                score=1,
-            )
-
-    motile.add_cand_edges(fmt, max_dist, max_skip_frames=max_skip_frames)
-
-    return fmt
-
-
-def write_csv_from_lT_to_lineaja(
-    lT, path_to, start: int = 0, finish: int = 300
-):
-    csv_dict = {}
-    for time in range(start, finish):
-        for node in lT.time_nodes[time]:
-            csv_dict[node] = {"pos": lT.pos[node], "t": time}
-    with open(path_to, "w", newline="\n") as file:
-        fieldnames = [
-            "time",
-            "positions_x",
-            "positions_y",
-            "positions_z",
-            "id",
-        ]
-        writer = csv.DictWriter(file, fieldnames=fieldnames)
-        writer.writeheader()
-        for node in csv_dict:
-            writer.writerow(
-                {
-                    "time": csv_dict[node]["t"],
-                    "positions_z": csv_dict[node]["pos"][0],
-                    "positions_y": csv_dict[node]["pos"][1],
-                    "positions_x": csv_dict[node]["pos"][2],
-                    "id": node,
-                }
-            )
-
-
-def create_links_and_cycles(lT: lineageTree, roots=None):
-    """Generates a dictionary containing the links and the lengths of each branch.
-    Similar to simple tree, mainly used for tree manip app.
-
-    Args:
-        roots (Union[list,set,int]): The roots from which the tree will be generated.
-
-    Returns:
-        dict: A dictionary with keys "links" and "times" which contains the connections all cells and their branch
-        length.
+from collections.abc import Iterable
+
+from LineageTree import lineageTree, tree_approximation
+
+
+def create_links_and_chains(
+    lT: lineageTree,
+    roots: int | Iterable | None = None,
+    end_time: int | None = None,
+) -> dict[str, dict]:
+    """Generates a dictionary containing all the edges (from start of lifetime to end not the intermediate timepoints)
+      of a subtree spawned by node/s and their duration
+
+
+    Parameters
+    ----------
+    lT : lineageTree
+        The lineagetree that the user is working on
+    roots : int or Iterable, optional
+        The root/s from which the tree/s will be generated, if 'None' all the roots will be selected.
+    end_time : int, optional
+        The last timepoint to be considered, if 'None' the last timepoint of the dataset (t_e) is considered, by default None.
+
+    Returns
+    -------
+    dict mapping str to set or dict mapping int to list or int
+        A dictionary that contains:
+            - "links": The dictionary that contains the hierarchy of the nodes (only start and end of each chain)
+            - "times": The time distance between the start and the end of a chain
+            - "roots": The roots used
     """
     if roots is None:
         to_do = set(lT.roots)
-    elif isinstance(roots, list):
+    elif isinstance(roots, Iterable):
         to_do = set(roots)
     else:
         to_do = {int(roots)}
+    if end_time is None:
+        end_time = lT.t_e
     times = {}
     links = {}
     while to_do:
         curr = to_do.pop()
-        cyc = lT.get_successors(curr)
-        last = cyc[-1]
-        times[curr] = len(cyc)
-        if last != curr:
-            links[curr] = [cyc[-1]]
-        else:
-            links[curr] = []
-        succ = lT.successor.get(last)
-        if succ:
-            times[cyc[-1]] = 0
-            to_do.update(succ)
+        cyc = lT.get_successors(curr, end_time=end_time)
+        if cyc[-1] != curr or lT.time[cyc[-1]] <= end_time:
+            last = cyc[-1]
+            times[curr] = len(cyc)
+            if last != curr:
+                links[curr] = [last]
+            else:
+                links[curr] = []
+            succ = lT._successor.get(last)
+            if succ:
+                times[cyc[-1]] = 0
+                to_do.update(succ)
             links[last] = succ
     return {"links": links, "times": times, "root": roots}
 
 
 def hierarchical_pos(
     lnks_tms: dict, root, width=1000, vert_gap=2, xcenter=0, ycenter=0
-):
-    """Calculates the position of each node on te tree graph.
-
-    Args:
-        lnks_tms (dict): a dictionary created by create_links_and_cycles.
-        root (_type_): The id of the node, usually it exists inside lnks_tms dictionary, however you may use your own root.
-        width (int, optional): Max width, will not change the graph but the interacting with the graph takes this distance into account. Defaults to 1000.
-        vert_gap (int, optional): How far downwards each timepoint will go. Defaults to 2.
-        xcenter (int, optional): Where the root will be placed on the x axis. Defaults to 0.
-        ycenter (int, optional): Where the root will be placed on the y axis. Defaults to 0.
-
-    Returns:
-        _type_: _description_
+) -> dict[int, list[float]] | None:
+    """Calculates the position of each node on the tree graph.
+
+    Parameters
+    ----------
+    lnks_tms : dict
+         a dictionary created by create_links_and_chains.
+    root : _type_
+        The id of the node, usually it exists inside lnks_tms dictionary, however you may use your own root.
+    width : int, optional
+        Max width, will not change the graph but interacting with the graph takes this distance into account, by default 1000
+    vert_gap : int, optional
+        How far downwards each timepoint will go, by default 2
+    xcenter : int, optional
+        Where the root will be placed on the x axis, by default 0
+    ycenter : int, optional
+        Where the root will be placed on the y axis, by default 0
+
+    Returns
+    -------
+    dict mapping int to list of float
+        Provides a dictionary that contains the id of each node as keys and its 2-d position on the
+        tree graph as values.
+        If the root requested does not exists, None is then returned
     """
     to_do = [root]
     if root not in lnks_tms["times"]:
@@ -152,3 +118,37 @@ def hierarchical_pos(
                 prev_width[curr] / 2,
             )
     return pos_node
+
+
+def convert_style_to_number(
+    style: str | tree_approximation.TreeApproximationTemplate,
+    downsample: int | None,
+) -> int:
+    """Converts tree_style and downsampling to a single number.
+
+    Parameters
+    ----------
+    style : str
+        the tree style
+    downsample : int
+        the downsampling factor
+
+    Returns
+    -------
+    int
+        A number which serves as ID if the tree style and downsampling used.
+    """
+    style_dict = {
+        "full": 0,
+        "simple": -1,
+        "normalized_simple": -2,
+        "mini": -1000,
+    }
+    if style == "downsampled" and downsample is not None:
+        return downsample
+    elif not isinstance(style, str) and issubclass(
+        style, tree_approximation.TreeApproximationTemplate
+    ):
+        return hash(style.__name__)
+    else:
+        return style_dict[style]

lineagetree-2.0.3.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: LineageTree
+Version: 2.0.3
+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: mastodon-reader
+Requires-Dist: matplotlib
+Requires-Dist: edist
+Requires-Dist: svgwrite
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: tox; 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-2.0.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+LineageTree/__init__.py,sha256=DBw4aJTm7ttYYm6FuL9b_Q1108W9YU_dox0oIoDiLUU,749
+LineageTree/lineageTree.py,sha256=3es3wPN9O0Eaqw-YC-uMq4tukpQPkW7DbTl9ujvZkXs,125993
+LineageTree/lineageTreeManager.py,sha256=kyHeoQ3EKMNnlSJG-v0K67j8RHECNIk-dUzdP0za3as,32406
+LineageTree/loaders.py,sha256=lcLEvLGA4Jn0QwBId__kHpQ3i4axDT5VEyACGnDNrBg,30255
+LineageTree/tree_approximation.py,sha256=61Omn0gUaRiNTDcIucDM4DUPBW5voXRxCZQ0uYGRDSg,16170
+LineageTree/utils.py,sha256=EOH2MGlBH3cFs8DVOX-3fJRwoj0ZmiE_nPkAjzWXK48,5124
+LineageTree/legacy/export_csv.py,sha256=cJ1R3GCGEy9Oey73jbFhoKRGTonNbqg229fVnGm_FuU,2009
+LineageTree/legacy/to_lineajea.py,sha256=iZyZTsrvWYHkGJ8npf91lQPrXPgKouiy7Zrywx5Lkkw,926
+LineageTree/legacy/to_motile.py,sha256=4AC9BmGa-hpqt8_x6HTR_XqCrTERlKo9WwYHUFtheM0,860
+LineageTree/test/test_lineageTree.py,sha256=d5uucokzE7OWQirsW7XxaGEgeRszQ5KICbAYhriXEQo,16492
+LineageTree/test/test_uted.py,sha256=Vl7uNGZp57XUD3v3SHRJtXhb0Lte8mDjpOtEKp_dxt0,6496
+lineagetree-2.0.3.dist-info/licenses/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
+lineagetree-2.0.3.dist-info/METADATA,sha256=GOrhmJPx3qWTCqszjsjHQ2vS-43DZ0gDurjfpUZ8US8,4081
+lineagetree-2.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lineagetree-2.0.3.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
+lineagetree-2.0.3.dist-info/RECORD,,

{LineageTree-1.8.0.dist-info → lineagetree-2.0.3.dist-info}/WHEEL

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