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

LineageTree/loaders.py

@@ -3,894 +3,972 @@ import os
 import pickle as pkl
 import struct
 import xml.etree.ElementTree as ET
+from pathlib import Path
 from warnings import warn
 
 import numpy as np
 
-
-class lineageTreeLoaders:
-    implicit_l_t = {
-        "AB": "P0",
-        "P1": "P0",
-        "EMS": "P1",
-        "P2": "P1",
-        "MS": "EMS",
-        "E": "EMS",
-        "C": "P2",
-        "P3": "P2",
-        "D": "P3",
-        "P4": "P3",
-        "Z2": "P4",
-        "Z3": "P4",
-    }
-
-    def read_from_csv(
-        self, file_path: str, z_mult: float, link: int = 1, delim: str = ","
-    ):
-        """
-        TODO: write doc
-        """
-        with open(file_path) as f:
-            lines = f.readlines()
-            f.close()
-        self.time_nodes = {}
-        self.time_edges = {}
-        unique_id = 0
-        self.nodes = set()
-        self.edges = set()
-        self.successor = {}
-        self.predecessor = {}
-        self.pos = {}
-        self.time_id = {}
-        self.time = {}
-        self.lin = {}
-        self.C_lin = {}
-        if not link:
-            self.displacement = {}
-        lines_to_int = []
-        corres = {}
-        for line in lines:
-            lines_to_int += [[eval(v.strip()) for v in line.split(delim)]]
-        lines_to_int = np.array(lines_to_int)
-        if link == 2:
-            lines_to_int = lines_to_int[np.argsort(lines_to_int[:, 0])]
+from .lineageTree import lineageTree
+
+IMPLICIT_L_T = {
+    "AB": "P0",
+    "P1": "P0",
+    "EMS": "P1",
+    "P2": "P1",
+    "MS": "EMS",
+    "E": "EMS",
+    "C": "P2",
+    "P3": "P2",
+    "D": "P3",
+    "P4": "P3",
+    "Z2": "P4",
+    "Z3": "P4",
+}
+
+ASTEC_KEYDICTIONARY = {
+    "cell_lineage": [
+        "lineage_tree",
+        "lin_tree",
+        "Lineage tree",
+        "cell_lineage",
+    ],
+    "cell_h_min": ["cell_h_min", "h_mins_information"],
+    "cell_volume": [
+        "cell_volume",
+        "volumes_information",
+        "volumes information",
+        "vol",
+    ],
+    "cell_surface": ["cell_surface", "cell surface"],
+    "cell_compactness": [
+        "cell_compactness",
+        "Cell Compactness",
+        "compacity",
+        "cell_sphericity",
+    ],
+    "cell_sigma": ["cell_sigma", "sigmas_information", "sigmas"],
+    "cell_labels_in_time": [
+        "cell_labels_in_time",
+        "Cells labels in time",
+        "time_labels",
+    ],
+    "cell_barycenter": [
+        "cell_barycenter",
+        "Barycenters",
+        "barycenters",
+    ],
+    "cell_fate": ["cell_fate", "Fate"],
+    "cell_fate_2": ["cell_fate_2", "Fate2"],
+    "cell_fate_3": ["cell_fate_3", "Fate3"],
+    "cell_fate_4": ["cell_fate_4", "Fate4"],
+    "all_cells": [
+        "all_cells",
+        "All Cells",
+        "All_Cells",
+        "all cells",
+        "tot_cells",
+    ],
+    "cell_principal_values": [
+        "cell_principal_values",
+        "Principal values",
+    ],
+    "cell_name": ["cell_name", "Names", "names", "cell_names"],
+    "cell_contact_surface": [
+        "cell_contact_surface",
+        "cell_cell_contact_information",
+    ],
+    "cell_history": [
+        "cell_history",
+        "Cells history",
+        "cell_life",
+        "life",
+    ],
+    "cell_principal_vectors": [
+        "cell_principal_vectors",
+        "Principal vectors",
+    ],
+    "cell_naming_score": ["cell_naming_score", "Scores", "scores"],
+    "problematic_cells": ["problematic_cells"],
+    "unknown_key": ["unknown_key"],
+}
+
+
+def read_from_csv(
+    file_path: str,
+    z_mult: float,
+    link: int = 1,
+    delim: str = ",",
+    name: None | str = None,
+) -> lineageTree:
+    """Read a lineage tree from a csv file with the following format:
+    id, time, z, y, x, id, pred_id, lin_id
+
+    Parameters
+    ----------
+        file_path : str
+            path to the csv file
+        z_mult : float
+            aspect ratio
+        link : int
+            1 if the csv file is ordered by id, 2 if ordered by pred_id
+        delim : str, default=","
+            delimiter used in the csv file
+        name : None or str, optional
+           The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+           will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+        lineageTree
+            lineage tree
+    """
+    with open(file_path) as f:
+        lines = f.readlines()
+        f.close()
+    successor = {}
+    pos = {}
+    time = {}
+    lines_to_int = []
+    corres = {}
+    for line in lines:
+        lines_to_int += [[eval(v.strip()) for v in line.split(delim)]]
+    lines_to_int = np.array(lines_to_int)
+    if link == 2:
+        lines_to_int = lines_to_int[np.argsort(lines_to_int[:, 0])]
+    else:
+        lines_to_int = lines_to_int[np.argsort(lines_to_int[:, 1])]
+    for unique_id, line in enumerate(lines_to_int):
+        if link == 1:
+            id_, t, z, y, x, pred, lin_id = line
+        elif link == 2:
+            t, z, y, x, id_, pred, lin_id = line
         else:
-            lines_to_int = lines_to_int[np.argsort(lines_to_int[:, 1])]
-        for line in lines_to_int:
-            if link == 1:
-                id_, t, z, y, x, pred, lin_id = line
-            elif link == 2:
-                t, z, y, x, id_, pred, lin_id = line
+            id_, t, z, y, x, *_ = line
+            pred = None
+        t = int(t)
+        positions = np.array([x, y, z])
+        C = unique_id
+        corres[id_] = C
+        positions[-1] = positions[-1] * z_mult
+        if pred in corres:
+            M = corres[pred]
+            successor.setdefault(M, []).append(C)
+        pos[C] = positions
+        time[C] = t
+    if not name:
+        tmp_name = Path(file_path).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    return lineageTree(successor=successor, time=time, pos=pos, name=name)
+
+
+def _read_from_ASTEC_xml(file_path: str):
+    def _set_dictionary_value(root):
+        if len(root) == 0:
+            if root.text is None:
+                return None
             else:
-                id_, t, z, y, x, dz, dy, dx = line
-                pred = None
-                lin_id = None
-            t = int(t)
-            pos = np.array([x, y, z])
-            C = unique_id
-            corres[id_] = C
-            pos[-1] = pos[-1] * z_mult
-            if pred in corres:
-                M = corres[pred]
-                self.predecessor[C] = [M]
-                self.successor.setdefault(M, []).append(C)
-                self.edges.add((M, C))
-                self.time_edges.setdefault(t, set()).add((M, C))
-                self.lin.setdefault(lin_id, []).append(C)
-                self.C_lin[C] = lin_id
-            self.pos[C] = pos
-            self.nodes.add(C)
-            self.time_nodes.setdefault(t, set()).add(C)
-            self.time[C] = t
-            if not link:
-                self.displacement[C] = np.array([dx, dy, dz * z_mult])
-            unique_id += 1
-        self.max_id = unique_id - 1
-        self.t_b = min(self.time_nodes)
-        self.t_e = max(self.time_nodes)
-
-    def read_from_ASTEC(self, file_path: str, eigen: bool = False):
-        """
-        Read an `xml` or `pkl` file produced by the ASTEC algorithm.
-
-        Args:
-            file_path (str): path to an output generated by ASTEC
-            eigen (bool): whether or not to read the eigen values, default False
-        """
-        self._astec_keydictionary = {
-            "cell_lineage": [
-                "lineage_tree",
-                "lin_tree",
-                "Lineage tree",
-                "cell_lineage",
-            ],
-            "cell_h_min": ["cell_h_min", "h_mins_information"],
-            "cell_volume": [
-                "cell_volume",
-                "volumes_information",
-                "volumes information",
-                "vol",
-            ],
-            "cell_surface": ["cell_surface", "cell surface"],
-            "cell_compactness": [
-                "cell_compactness",
-                "Cell Compactness",
-                "compacity",
-                "cell_sphericity",
-            ],
-            "cell_sigma": ["cell_sigma", "sigmas_information", "sigmas"],
-            "cell_labels_in_time": [
-                "cell_labels_in_time",
-                "Cells labels in time",
-                "time_labels",
-            ],
-            "cell_barycenter": [
-                "cell_barycenter",
-                "Barycenters",
-                "barycenters",
-            ],
-            "cell_fate": ["cell_fate", "Fate"],
-            "cell_fate_2": ["cell_fate_2", "Fate2"],
-            "cell_fate_3": ["cell_fate_3", "Fate3"],
-            "cell_fate_4": ["cell_fate_4", "Fate4"],
-            "all_cells": [
-                "all_cells",
-                "All Cells",
-                "All_Cells",
-                "all cells",
-                "tot_cells",
-            ],
-            "cell_principal_values": [
-                "cell_principal_values",
-                "Principal values",
-            ],
-            "cell_name": ["cell_name", "Names", "names", "cell_names"],
-            "cell_contact_surface": [
-                "cell_contact_surface",
-                "cell_cell_contact_information",
-            ],
-            "cell_history": [
-                "cell_history",
-                "Cells history",
-                "cell_life",
-                "life",
-            ],
-            "cell_principal_vectors": [
-                "cell_principal_vectors",
-                "Principal vectors",
-            ],
-            "cell_naming_score": ["cell_naming_score", "Scores", "scores"],
-            "problematic_cells": ["problematic_cells"],
-            "unknown_key": ["unknown_key"],
-        }
-
-        if os.path.splitext(file_path)[-1] == ".xml":
-            tmp_data = self._read_from_ASTEC_xml(file_path)
+                return eval(root.text)
         else:
-            tmp_data = self._read_from_ASTEC_pkl(file_path, eigen)
+            dictionary = {}
+            for child in root:
+                key = child.tag
+                if child.tag == "cell":
+                    key = int(child.attrib["cell-id"])
+                dictionary[key] = _set_dictionary_value(child)
+        return dictionary
 
-        # make sure these are all named liked they are in tmp_data (or change dictionary above)
-        self.name = {}
+    tree = ET.parse(file_path)
+    root = tree.getroot()
+    dictionary = {}
+
+    for k in ASTEC_KEYDICTIONARY:
+        if root.tag == k:
+            dictionary[str(root.tag)] = _set_dictionary_value(root)
+            break
+    else:
+        for child in root:
+            value = _set_dictionary_value(child)
+            if value is not None:
+                dictionary[str(child.tag)] = value
+    return dictionary
+
+
+def _read_from_ASTEC_pkl(file_path: str, eigen: bool = False):
+    with open(file_path, "rb") as f:
+        tmp_data = pkl.load(f, encoding="latin1")
+        f.close()
+    new_ref = {}
+    for k, v in ASTEC_KEYDICTIONARY.items():
+        for key in v:
+            new_ref[key] = k
+    new_dict = {}
+
+    for k, v in tmp_data.items():
+        if k in new_ref:
+            new_dict[new_ref[k]] = v
+        else:
+            new_dict[k] = v
+    return new_dict
+
+
+def read_from_ASTEC(
+    file_path: str, eigen: bool = False, name: None | str = None
+) -> lineageTree:
+    """
+    Read an `xml` or `pkl` file produced by the ASTEC algorithm.
+
+    Parameters
+    ----------
+    file_path : str
+        path to an output generated by ASTEC
+    eigen : bool, default=False
+        whether or not to read the eigen values, default False
+    name : None or str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+
+    if os.path.splitext(file_path)[-1] == ".xml":
+        tmp_data = _read_from_ASTEC_xml(file_path)
+    else:
+        tmp_data = _read_from_ASTEC_pkl(file_path, eigen)
+
+    # make sure these are all named liked they are in tmp_data (or change dictionary above)
+    properties = {}
+    if "cell_volume" in tmp_data:
+        properties["volume"] = {}
+    if "cell_fate" in tmp_data:
+        properties["fate"] = {}
+    if "cell_barycenter" in tmp_data:
+        pos = {}
+    if "cell_name" in tmp_data:
+        properties["label"] = {}
+    lT2pkl = {}
+    pkl2lT = {}
+    image_label = {}
+
+    lt = tmp_data["cell_lineage"]
+
+    if "cell_contact_surface" in tmp_data:
+        properties["contact"] = {}
+        do_surf = True
+        surfaces = tmp_data["cell_contact_surface"]
+    else:
+        do_surf = False
+
+    inv = {vi: [c] for c, v in lt.items() for vi in v}
+    nodes = set(lt).union(inv)
+
+    unique_id = 0
+    time = {}
+
+    for unique_id, n in enumerate(nodes):
+        t = n // 10**4
+        image_label[unique_id] = n % 10**4
+        lT2pkl[unique_id] = n
+        pkl2lT[n] = unique_id
+        time[unique_id] = t
         if "cell_volume" in tmp_data:
-            self.volume = {}
+            properties["volume"][unique_id] = tmp_data["cell_volume"].get(
+                n, 0.0
+            )
         if "cell_fate" in tmp_data:
-            self.fates = {}
+            properties["fate"][unique_id] = tmp_data["cell_fate"].get(n, "")
         if "cell_barycenter" in tmp_data:
-            self.pos = {}
-        self.lT2pkl = {}
-        self.pkl2lT = {}
-        self.contact = {}
-        self.prob_cells = set()
-        self.image_label = {}
-
-        lt = tmp_data["cell_lineage"]
-
-        if "cell_contact_surface" in tmp_data:
-            do_surf = True
-            surfaces = tmp_data["cell_contact_surface"]
-        else:
-            do_surf = False
-
-        inv = {vi: [c] for c, v in lt.items() for vi in v}
-        nodes = set(lt).union(inv)
-
-        unique_id = 0
-
-        for n in nodes:
-            t = n // 10**4
-            self.image_label[unique_id] = n % 10**4
-            self.lT2pkl[unique_id] = n
-            self.pkl2lT[n] = unique_id
-            self.time_nodes.setdefault(t, set()).add(unique_id)
-            self.nodes.add(unique_id)
-            self.time[unique_id] = t
-            if "cell_volume" in tmp_data:
-                self.volume[unique_id] = tmp_data["cell_volume"].get(n, 0.0)
-            if "cell_fate" in tmp_data:
-                self.fates[unique_id] = tmp_data["cell_fate"].get(n, "")
-            if "cell_barycenter" in tmp_data:
-                self.pos[unique_id] = tmp_data["cell_barycenter"].get(
-                    n, np.zeros(3)
-                )
-
-            unique_id += 1
-        if do_surf:
-            for c in nodes:
-                if c in surfaces and c in self.pkl2lT:
-                    self.contact[self.pkl2lT[c]] = {
-                        self.pkl2lT.get(n, -1): s
-                        for n, s in surfaces[c].items()
-                        if n % 10**4 == 1 or n in self.pkl2lT
-                    }
-
-        for n, new_id in self.pkl2lT.items():
-            if n in inv:
-                self.predecessor[new_id] = [self.pkl2lT[ni] for ni in inv[n]]
-            if n in lt:
-                self.successor[new_id] = [
-                    self.pkl2lT[ni] for ni in lt[n] if ni in self.pkl2lT
-                ]
-
-                for ni in self.successor[new_id]:
-                    self.time_edges.setdefault(t - 1, set()).add((new_id, ni))
-
-        self.t_b = min(self.time_nodes)
-        self.t_e = max(self.time_nodes)
-        self.max_id = unique_id
-
-        # do this in the end of the process, skip lineage tree and whatever is stored already
-        discard = {
-            "cell_volume",
-            "cell_fate",
-            "cell_barycenter",
-            "cell_contact_surface",
-            "cell_lineage",
-            "all_cells",
-            "cell_history",
-            "problematic_cells",
-            "cell_labels_in_time",
-        }
-        self.specific_properties = []
-        for prop_name, prop_values in tmp_data.items():
-            if not (prop_name in discard or hasattr(self, prop_name)):
-                if isinstance(prop_values, dict):
-                    dictionary = {
-                        self.pkl2lT.get(k, -1): v
-                        for k, v in prop_values.items()
+            pos[unique_id] = tmp_data["cell_barycenter"].get(n, np.zeros(3))
+        if "cell_name" in tmp_data:
+            properties["label"][unique_id] = tmp_data["cell_name"].get(n, "")
+
+    if do_surf:
+        for c in nodes:
+            if c in surfaces and c in pkl2lT:
+                properties["contact"][pkl2lT[c]] = {
+                    pkl2lT.get(n, -1): s
+                    for n, s in surfaces[c].items()
+                    if n % 10**4 == 1 or n in pkl2lT
+                }
+
+    successor = {}
+    for n, new_id in pkl2lT.items():
+        if n in lt:
+            successor[new_id] = [pkl2lT[ni] for ni in lt[n] if ni in pkl2lT]
+
+    # do this in the end of the process, skip lineage tree and whatever is stored already
+    discard = {
+        "cell_volume",  # already stored
+        "cell_fate",  # already stored
+        "cell_barycenter",  # already stored
+        "cell_contact_surface",  # already stored
+        "cell_lineage",  # already stored
+        "cell_name",  # already stored
+        "all_cells",  # not a property
+        "cell_history",  # redundant
+        "problematic_cells",  # not useful here
+        "cell_labels_in_time",  # redundant
+    }
+    for prop_name, prop_values in tmp_data.items():
+        if prop_name not in discard and isinstance(prop_values, dict):
+            dictionary = {pkl2lT.get(k, -1): v for k, v in prop_values.items()}
+            # is it a regular dictionary or a dictionary with dictionaries inside?
+            for key, value in dictionary.items():
+                if isinstance(value, dict):
+                    # rename all ids from old to new
+                    dictionary[key] = {
+                        pkl2lT.get(k, -1): v for k, v in value.items()
                     }
-                    # is it a regular dictionary or a dictionary with dictionaries inside?
-                    for key, value in dictionary.items():
-                        if isinstance(value, dict):
-                            # rename all ids from old to new
-                            dictionary[key] = {
-                                self.pkl2lT.get(k, -1): v
-                                for k, v in value.items()
-                            }
-                    self.__dict__[prop_name] = dictionary
-                    self.specific_properties.append(prop_name)
-                # is any of this necessary? Or does it mean it anyways does not contain
-                # information about the id and a simple else: is enough?
-                elif (
-                    isinstance(prop_values, (list, set, np.ndarray))
-                    and prop_name not in []
-                ):
-                    self.__dict__[prop_name] = prop_values
-                    self.specific_properties.append(prop_name)
-
-            # what else could it be?
-
-        # add a list of all available properties
-
-    def _read_from_ASTEC_xml(self, file_path: str):
-        def _set_dictionary_value(root):
-            if len(root) == 0:
-                if root.text is None:
-                    return None
-                else:
-                    return eval(root.text)
+            properties[prop_name] = dictionary
+    if not name:
+        tmp_name = Path(file_path).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    return lineageTree(
+        successor=successor, time=time, pos=pos, name=name, **properties
+    )
+
+
+def read_from_binary(fname: str, name: None | str = None) -> lineageTree:
+    """
+    Reads a binary lineageTree file name.
+    Format description: see lineageTree.to_binary
+
+    Parameters
+    ----------
+    fname : string
+        path to the binary file
+    name : None or str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+    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 = {}
+    time = {}
+    pos = {}
+    is_root = {}
+    waiting_list = []
+    i = 0
+    done = False
+    t = 0
+    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, strict=True)))
+            pos = dict(
+                list(
+                    zip(
+                        tmp,
+                        np.reshape(pos_sequence, (len_time, 3)),
+                        strict=True,
+                    )
+                )
+            )
+            is_root = dict.fromkeys(tmp, True)
+            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])
+                t = time[prev_mother] + 1
             else:
-                dictionary = {}
-                for child in root:
-                    key = child.tag
-                    if child.tag == "cell":
-                        key = int(child.attrib["cell-id"])
-                    dictionary[key] = _set_dictionary_value(child)
-            return dictionary
-
-        tree = ET.parse(file_path)
-        root = tree.getroot()
-        dictionary = {}
-
-        for k, _v in self._astec_keydictionary.items():
-            if root.tag == k:
-                dictionary[str(root.tag)] = _set_dictionary_value(root)
-                break
-        else:
-            for child in root:
-                value = _set_dictionary_value(child)
-                if value is not None:
-                    dictionary[str(child.tag)] = value
-        return dictionary
-
-    def _read_from_ASTEC_pkl(self, file_path: str, eigen: bool = False):
-        with open(file_path, "rb") as f:
-            tmp_data = pkl.load(f, encoding="latin1")
-            f.close()
-        new_ref = {}
-        for k, v in self._astec_keydictionary.items():
-            for key in v:
-                new_ref[key] = k
-        new_dict = {}
-
-        for k, v in tmp_data.items():
-            if k in new_ref:
-                new_dict[new_ref[k]] = v
+                t = time_sequence.pop(0)
+
+        elif c == -2:
+            successor[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:]
+            time[waiting_list[-1]] = t
+            t += 1
+
+        elif number_sequence[i + 1] >= 0:
+            successor[c] = [number_sequence[i + 1]]
+            pos[c] = pos_sequence[:3]
+            pos_sequence = pos_sequence[3:]
+            time[c] = t
+            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:]
+            time[c] = t
+            t += 1
+            i += 1
+            if waiting_list != []:
+                prev_mother = waiting_list.pop()
+                successor[prev_mother].insert(0, number_sequence[i + 1])
+                t = time[prev_mother] + 1
             else:
-                new_dict[k] = v
-        return new_dict
-
-    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 = []
-        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:
+                if len(time_sequence) > 0:
                     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
+        i += 1
+    if not name:
+        tmp_name = Path(fname).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    return lineageTree(successor=successor, time=time, pos=pos, name=name)
+
+
+def read_from_txt_for_celegans(
+    file: str, name: None | str = None
+) -> lineageTree:
+    """
+    Read a C. elegans lineage tree
+
+    Parameters
+    ----------
+    file : str
+        Path to the file to read
+    name : None or str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+    with open(file) as f:
+        raw = f.readlines()[1:]
+        f.close()
+    _labels = {}
+    time_nodes = {}
+    pos = {}
+    time = {}
+    successor = {}
+
+    for unique_id, line in enumerate(raw):
+        t = int(line.split("\t")[0])
+        _labels[unique_id] = line.split("\t")[1]
+        position = np.array(line.split("\t")[2:5], dtype=float)
+        time_nodes.setdefault(t, set()).add(unique_id)
+        pos[unique_id] = position
+        time[unique_id] = t
+
+    t_b = min(time_nodes)
+
+    for t, cells in time_nodes.items():
+        if t != t_b:
+            prev_cells = time_nodes[t - 1]
+            name_to_id = {_labels[c]: c for c in prev_cells}
+            for c in cells:
+                if _labels[c] in name_to_id:
+                    p = name_to_id[_labels[c]]
+                elif _labels[c][:-1] in name_to_id:
+                    p = name_to_id[_labels[c][:-1]]
+                elif IMPLICIT_L_T.get(_labels[c]) in name_to_id:
+                    p = name_to_id[IMPLICIT_L_T.get(_labels[c])]
                 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)
-        self.t_e = max(time_nodes)
-        self.is_root = is_root
-        self.max_id = max(self.nodes)
-
-    def read_from_txt_for_celegans(self, file: str):
-        """
-        Read a C. elegans lineage tree
-
-        Args:
-            file (str): Path to the file to read
-        """
-        with open(file) as f:
-            raw = f.readlines()[1:]
-            f.close()
-        self.name = {}
-
-        unique_id = 0
-        for line in raw:
-            t = int(line.split("\t")[0])
-            self.name[unique_id] = line.split("\t")[1]
-            position = np.array(line.split("\t")[2:5], dtype=float)
-            self.time_nodes.setdefault(t, set()).add(unique_id)
-            self.nodes.add(unique_id)
-            self.pos[unique_id] = position
-            self.time[unique_id] = t
-            unique_id += 1
-
-        self.t_b = min(self.time_nodes)
-        self.t_e = max(self.time_nodes)
-
-        for t, cells in self.time_nodes.items():
-            if t != self.t_b:
-                prev_cells = self.time_nodes[t - 1]
-                name_to_id = {self.name[c]: c for c in prev_cells}
-                for c in cells:
-                    if self.name[c] in name_to_id:
-                        p = name_to_id[self.name[c]]
-                    elif self.name[c][:-1] in name_to_id:
-                        p = name_to_id[self.name[c][:-1]]
-                    elif self.implicit_l_t.get(self.name[c]) in name_to_id:
-                        p = name_to_id[self.implicit_l_t.get(self.name[c])]
-                    else:
-                        p = None
-                    self.predecessor.setdefault(c, []).append(p)
-                    self.successor.setdefault(p, []).append(c)
-                    self.time_edges.setdefault(t - 1, set()).add((p, c))
-            self.max_id = unique_id
-
-    def read_from_txt_for_celegans_CAO(
-        self,
-        file: str,
-        reorder: bool = False,
-        raw_size: float = None,
-        shape: float = None,
-    ):
-        """
-        Read a C. elegans lineage tree from Cao et al.
-
-        Args:
-            file (str): Path to the file to read
-        """
-
-        def split_line(line):
-            return (
-                line.split()[0],
-                eval(line.split()[1]),
-                eval(line.split()[2]),
-                eval(line.split()[3]),
-                eval(line.split()[4]),
+                    p = None
+                successor.setdefault(p, []).append(c)
+    if not name:
+        tmp_name = Path(file).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    properties = {"_labels": _labels}
+    return lineageTree(
+        successor=successor, time=time, pos=pos, name=name, **properties
+    )
+
+
+def read_from_txt_for_celegans_CAO(
+    file: str,
+    reorder: bool = False,
+    raw_size: np.ndarray | None = None,
+    shape: float | None = None,
+    name: str | None = None,
+) -> lineageTree:
+    """
+    Read a C. elegans lineage tree from Cao et al.
+
+    Parameters
+    ----------
+    file : str
+        Path to the file to read
+    name : None or str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+
+    def split_line(line):
+        return (
+            line.split()[0],
+            eval(line.split()[1]),
+            eval(line.split()[2]),
+            eval(line.split()[3]),
+            eval(line.split()[4]),
+        )
+
+    with open(file) as f:
+        raw = f.readlines()[1:]
+        f.close()
+    label = {}
+    time_nodes = {}
+    pos = {}
+    successor = {}
+    time = {}
+
+    unique_id = 0
+    for unique_id, (label, t, z, x, y) in enumerate(map(split_line, raw)):
+        label[unique_id] = label
+        position = np.array([x, y, z], dtype=np.float)
+        time_nodes.setdefault(t, set()).add(unique_id)
+        if reorder:
+
+            def flip(x):
+                return np.array([x[0], x[1], raw_size[2] - x[2]])
+
+            def adjust(x):
+                return (shape / raw_size * flip(x))[[1, 0, 2]]
+
+            pos[unique_id] = adjust(position)
+        else:
+            pos[unique_id] = position
+        time[unique_id] = t
+
+    t_b = min(time_nodes)
+
+    for t, cells in time_nodes.items():
+        if t != t_b:
+            prev_cells = time_nodes[t - 1]
+            name_to_id = {label[c]: c for c in prev_cells}
+            for c in cells:
+                if label[c] in name_to_id:
+                    p = name_to_id[label[c]]
+                elif label[c][:-1] in name_to_id:
+                    p = name_to_id[label[c][:-1]]
+                elif IMPLICIT_L_T.get(label[c]) in name_to_id:
+                    p = name_to_id[IMPLICIT_L_T.get(label[c])]
+                else:
+                    warn(
+                        f"error, cell {label[c]} has no predecessors",
+                        stacklevel=2,
+                    )
+                    p = None
+                successor.setdefault(p, []).append(c)
+    if not name:
+        tmp_name = Path(file).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    return lineageTree(
+        successor=successor, time=time, pos=pos, label=label, name=name
+    )
+
+
+def read_from_txt_for_celegans_BAO(
+    path: str, name: None | str = None
+) -> lineageTree:
+    """Read a C. elegans Bao file from http://digital-development.org
+
+    Parameters
+    ----------
+    file : str
+        Path to the file to read
+    name : str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+    cell_times = {}
+    properties = {}
+    properties["expression"] = {}
+    properties["_labels"] = {}
+    with open(path) as f:
+        for line in f:
+            if "cell_name" not in line:
+                cell_times[line.split("\t")[0]] = [
+                    eval(val) for val in line.split("\t")[-1].split(",")
+                ]
+    unique_id = 0
+    to_link = {}
+    successor = {}
+    for c, lc in cell_times.items():
+        ids = list(range(unique_id, unique_id + len(lc)))
+        successor.update({ids[i]: [ids[i + 1]] for i in range(len(ids) - 1)})
+        properties["expression"].update(dict(zip(ids, lc, strict=True)))
+        properties["_labels"].update(dict.fromkeys(ids, c))
+        to_link[c] = (unique_id, unique_id + len(lc) - 1)
+        unique_id += len(lc)
+
+    for c_name, c_id in to_link.items():
+        if c_name[:-1] in to_link:
+            successor.setdefault(to_link[c_name[:-1]][1], []).append(c_id[0])
+        elif c_name in IMPLICIT_L_T and IMPLICIT_L_T[c_name] in to_link:
+            successor.setdefault(to_link[IMPLICIT_L_T[c_name]][1], []).append(
+                c_id[0]
             )
-
-        with open(file) as f:
-            raw = f.readlines()[1:]
-            f.close()
-        self.name = {}
-
-        unique_id = 0
-        for name, t, z, x, y in map(split_line, raw):
-            self.name[unique_id] = name
-            position = np.array([x, y, z], dtype=np.float)
-            self.time_nodes.setdefault(t, set()).add(unique_id)
-            self.nodes.add(unique_id)
-            if reorder:
-
-                def flip(x):
-                    return np.array([x[0], x[1], raw_size[2] - x[2]])
-
-                def adjust(x):
-                    return (shape / raw_size * flip(x))[[1, 0, 2]]
-
-                self.pos[unique_id] = adjust(position)
-            else:
-                self.pos[unique_id] = position
-            self.time[unique_id] = t
-            unique_id += 1
-
-        self.t_b = min(self.time_nodes)
-        self.t_e = max(self.time_nodes)
-
-        for t, cells in self.time_nodes.items():
-            if t != self.t_b:
-                prev_cells = self.time_nodes[t - 1]
-                name_to_id = {self.name[c]: c for c in prev_cells}
-                for c in cells:
-                    if self.name[c] in name_to_id:
-                        p = name_to_id[self.name[c]]
-                    elif self.name[c][:-1] in name_to_id:
-                        p = name_to_id[self.name[c][:-1]]
-                    elif self.implicit_l_t.get(self.name[c]) in name_to_id:
-                        p = name_to_id[self.implicit_l_t.get(self.name[c])]
-                    else:
-                        warn(
-                            f"error, cell {self.name[c]} has no predecessors",
-                            stacklevel=2,
-                        )
-                        p = None
-                    self.predecessor.setdefault(c, []).append(p)
-                    self.successor.setdefault(p, []).append(c)
-                    self.time_edges.setdefault(t - 1, set()).add((p, c))
-            self.max_id = unique_id
-
-    def read_tgmm_xml(
-        self, file_format: str, tb: int, te: int, z_mult: float = 1.0
-    ):
-        """Reads a lineage tree from TGMM xml output.
-
-        Args:
-            file_format (str): path to the xmls location.
-                    it should be written as follow:
-                    path/to/xml/standard_name_t{t:06d}.xml where (as an example)
-                    {t:06d} means a series of 6 digits representing the time and
-                    if the time values is smaller that 6 digits, the missing
-                    digits are filed with 0s
-            tb (int): first time point to read
-            te (int): last time point to read
-            z_mult (float): aspect ratio
-        """
-        self.time_nodes = {}
-        self.time_edges = {}
-        unique_id = 0
-        self.nodes = set()
-        self.successor = {}
-        self.predecessor = {}
-        self.pos = {}
-        self.time_id = {}
-        self.time = {}
-        self.mother_not_found = []
-        self.ind_cells = {}
-        self.svIdx = {}
-        self.lin = {}
-        self.C_lin = {}
-        self.coeffs = {}
-        self.intensity = {}
-        self.W = {}
-        for t in range(tb, te + 1):
-            tree = ET.parse(file_format.format(t=t))
-            root = tree.getroot()
-            self.time_nodes[t] = set()
-            self.time_edges[t] = set()
-            for it in root:
+    if not name:
+        tmp_name = Path(path).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    return lineageTree(
+        successor=successor, starting_time=0, name=name, **properties
+    )
+
+
+def read_from_tgmm_xml(
+    file_format: str,
+    tb: int,
+    te: int,
+    z_mult: float = 1.0,
+    name: None | str = None,
+) -> lineageTree:
+    """Reads a lineage tree from TGMM xml output.
+
+    Parameters
+    ----------
+    file_format : str
+        path to the xmls location.
+        it should be written as follow:
+        path/to/xml/standard_name_t{t:06d}.xml where (as an example)
+        {t:06d} means a series of 6 digits representing the time and
+        if the time values is smaller that 6 digits, the missing
+        digits are filed with 0s
+    tb : int
+        first time point to read
+    te : int
+        last time point to read
+    z_mult : float, default=1.0
+        aspect ratio
+    name : str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+    unique_id = 0
+    successor = {}
+    pos = {}
+    time_id = {}
+    time = {}
+    properties = {}
+    properties["svIdx"] = {}
+    properties["lin"] = {}
+    properties["C_lin"] = {}
+    properties["coeffs"] = {}
+    properties["intensity"] = {}
+    W = {}
+    for t in range(tb, te + 1):
+        tree = ET.parse(file_format.format(t=t))
+        root = tree.getroot()
+        for unique_id, it in enumerate(root):
+            if "-1.#IND" not in it.attrib["m"] and "nan" not in it.attrib["m"]:
+                M_id, positions, cell_id, svIdx, lin_id = (
+                    int(it.attrib["parent"]),
+                    [float(v) for v in it.attrib["m"].split(" ") if v != ""],
+                    int(it.attrib["id"]),
+                    [int(v) for v in it.attrib["svIdx"].split(" ") if v != ""],
+                    int(it.attrib["lineage"]),
+                )
                 if (
-                    "-1.#IND" not in it.attrib["m"]
-                    and "nan" not in it.attrib["m"]
+                    "alpha" in it.attrib
+                    and "W" in it.attrib
+                    and "nu" in it.attrib
+                    and "alphaPrior" in it.attrib
                 ):
-                    M_id, pos, cell_id, svIdx, lin_id = (
-                        int(it.attrib["parent"]),
+                    alpha, W, nu, alphaPrior = (
+                        float(it.attrib["alpha"]),
                         [
                             float(v)
-                            for v in it.attrib["m"].split(" ")
+                            for v in it.attrib["W"].split(" ")
                             if v != ""
                         ],
-                        int(it.attrib["id"]),
-                        [
-                            int(v)
-                            for v in it.attrib["svIdx"].split(" ")
-                            if v != ""
-                        ],
-                        int(it.attrib["lineage"]),
+                        float(it.attrib["nu"]),
+                        float(it.attrib["alphaPrior"]),
                     )
-                    try:
-                        alpha, W, nu, alphaPrior = (
-                            float(it.attrib["alpha"]),
-                            [
-                                float(v)
-                                for v in it.attrib["W"].split(" ")
-                                if v != ""
-                            ],
-                            float(it.attrib["nu"]),
-                            float(it.attrib["alphaPrior"]),
-                        )
-                        pos = np.array(pos)
-                        C = unique_id
-                        pos[-1] = pos[-1] * z_mult
-                        if (t - 1, M_id) in self.time_id:
-                            M = self.time_id[(t - 1, M_id)]
-                            self.successor.setdefault(M, []).append(C)
-                            self.predecessor.setdefault(C, []).append(M)
-                            self.time_edges[t].add((M, C))
-                        else:
-                            if M_id != -1:
-                                self.mother_not_found.append(C)
-                        self.pos[C] = pos
-                        self.nodes.add(C)
-                        self.time_nodes[t].add(C)
-                        self.time_id[(t, cell_id)] = C
-                        self.time[C] = t
-                        self.svIdx[C] = svIdx
-                        self.lin.setdefault(lin_id, []).append(C)
-                        self.C_lin[C] = lin_id
-                        self.intensity[C] = max(alpha - alphaPrior, 0)
-                        tmp = list(np.array(W) * nu)
-                        self.W[C] = np.array(W).reshape(3, 3)
-                        self.coeffs[C] = (
-                            tmp[:3] + tmp[4:6] + tmp[8:9] + list(pos)
-                        )
-                        unique_id += 1
-                    except Exception:
-                        pass
-                else:
-                    if t in self.ind_cells:
-                        self.ind_cells[t] += 1
-                    else:
-                        self.ind_cells[t] = 1
-        self.max_id = unique_id - 1
-
-    def read_from_mastodon(self, path: str, name: str):
-        """
-        TODO: write doc
-        """
-        from mastodon_reader import MastodonReader
-
-        mr = MastodonReader(path)
-        spots, links = mr.read_tables()
-
-        self.node_name = {}
-
-        for c in spots.iloc:
-            unique_id = c.name
-            x, y, z = c.x, c.y, c.z
-            t = c.t
-            n = c[name] if name is not None else ""
-            self.time_nodes.setdefault(t, set()).add(unique_id)
-            self.nodes.add(unique_id)
-            self.time[unique_id] = t
-            self.node_name[unique_id] = n
-            self.pos[unique_id] = np.array([x, y, z])
-
-        for e in links.iloc:
-            source = e.source_idx
-            target = e.target_idx
-            self.predecessor.setdefault(target, []).append(source)
-            self.successor.setdefault(source, []).append(target)
-            self.time_edges.setdefault(self.time[source], set()).add(
-                (source, target)
-            )
-        self.t_b = min(self.time_nodes.keys())
-        self.t_e = max(self.time_nodes.keys())
-
-    def read_from_mastodon_csv(self, path: str):
-        """
-        TODO: Write doc
-        """
-        spots = []
-        links = []
-        self.node_name = {}
-
-        with open(path[0], encoding="utf-8", errors="ignore") as file:
-            csvreader = csv.reader(file)
-            for row in csvreader:
-                spots.append(row)
-        spots = spots[3:]
-
-        with open(path[1], encoding="utf-8", errors="ignore") as file:
-            csvreader = csv.reader(file)
-            for row in csvreader:
-                links.append(row)
-        links = links[3:]
-
-        for spot in spots:
-            unique_id = int(spot[1])
-            x, y, z = spot[5:8]
-            t = int(spot[4])
-            self.time_nodes.setdefault(t, set()).add(unique_id)
-            self.nodes.add(unique_id)
-            self.time[unique_id] = t
-            self.node_name[unique_id] = spot[1]
-            self.pos[unique_id] = np.array([x, y, z], dtype=float)
-
-        for link in links:
-            source = int(float(link[4]))
-            target = int(float(link[5]))
-            self.predecessor.setdefault(target, []).append(source)
-            self.successor.setdefault(source, []).append(target)
-            self.time_edges.setdefault(self.time[source], set()).add(
-                (source, target)
+                    positions = np.array(positions)
+                    C = unique_id
+                    positions[-1] = positions[-1] * z_mult
+                    if (t - 1, M_id) in time_id:
+                        M = time_id[(t - 1, M_id)]
+                        successor.setdefault(M, []).append(C)
+                    pos[C] = positions
+                    time_id[(t, cell_id)] = C
+                    time[C] = t
+                    properties["svIdx"][C] = svIdx
+                    properties["lin"].setdefault(lin_id, []).append(C)
+                    properties["C_lin"][C] = lin_id
+                    properties["intensity"][C] = max(alpha - alphaPrior, 0)
+                    tmp = list(np.array(W) * nu)
+                    W[C] = np.array(W).reshape(3, 3)
+                    properties["coeffs"][C] = (
+                        tmp[:3] + tmp[4:6] + tmp[8:9] + list(positions)
+                    )
+    if not name:
+        tmp_name = Path(file_format).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    return lineageTree(
+        successor=successor, time=time, pos=pos, name=name, **properties
+    )
+
+
+def read_from_mastodon(
+    path: str, tag_set: int | None = None, name: None | str = None
+) -> lineageTree:
+    """Read a maston lineage tree.
+
+    Parameters
+    ----------
+    path : str
+        path to the mastodon file
+    tag_set : int, optional
+        The tag set that will be used to label.
+    name : str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+    from mastodon_reader import MastodonReader
+
+    mr = MastodonReader(path)
+    spots, links = mr.read_tables()
+
+    label = {}
+    time = {}
+    pos = {}
+    successor = {}
+
+    for c in spots.iloc:
+        unique_id = c.name
+        x, y, z = c.x, c.y, c.z
+        t = c.t
+        time[unique_id] = t
+        pos[unique_id] = np.array([x, y, z])
+
+    for e in links.iloc:
+        source = e.source_idx
+        target = e.target_idx
+        successor.setdefault(source, []).append(target)
+    if isinstance(tag_set, int):
+        tags = mr.read_tags(spots, links)[tag_set]
+        for tag in tags["tags"]:
+            label[tag["id"]] = tag["label"]
+
+    if not name:
+        tmp_name = Path(path).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+    return lineageTree(
+        successor=successor, time=time, pos=pos, label=label, name=name
+    )
+
+
+def read_from_mastodon_csv(
+    paths: list[str], name: None | str = None
+) -> lineageTree:
+    """Read a lineage tree from a mastodon csv.
+
+    Parameters
+    ----------
+    paths : list[str]
+        list of paths to the csv files
+    name : None or str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+    spots = []
+    links = []
+    label = {}
+    time = {}
+    pos = {}
+    successor = {}
+
+    with open(paths[0], encoding="utf-8", errors="ignore") as file:
+        csvreader = csv.reader(file)
+        for row in csvreader:
+            spots.append(row)
+    spots = spots[3:]
+
+    with open(paths[1], encoding="utf-8", errors="ignore") as file:
+        csvreader = csv.reader(file)
+        for row in csvreader:
+            links.append(row)
+    links = links[3:]
+
+    for spot in spots:
+        unique_id = int(spot[1])
+        x, y, z = spot[5:8]
+        t = int(spot[4])
+        time[unique_id] = t
+        label[unique_id] = spot[1]
+        pos[unique_id] = np.array([x, y, z], dtype=float)
+
+    for link in links:
+        source = int(float(link[4]))
+        target = int(float(link[5]))
+        successor.setdefault(source, []).append(target)
+    if not name:
+        tmp_name = Path(paths[0]).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+
+    return lineageTree(
+        successor=successor, time=time, pos=pos, label=label, name=name
+    )
+
+
+def read_from_mamut_xml(
+    path: str, xml_attributes: list[str] | None = None, name: None | str = None
+) -> lineageTree:
+    """Read a lineage tree from a MaMuT xml.
+
+    Parameters
+    ----------
+    path : str
+        path to the MaMut xml
+    name : None or str, optional
+        The name attribute of the lineageTree file. If given a non-empty string, the value of the attribute
+        will be the name attribute, otherwise the name will be the stem of the file path.
+
+    Returns
+    -------
+    lineageTree
+        lineage tree
+    """
+    tree = ET.parse(path)
+    for elem in tree.getroot():
+        if elem.tag == "Model":
+            Model = elem
+    FeatureDeclarations, AllSpots, AllTracks, FilteredTracks = list(Model)
+    xml_attributes = xml_attributes or []
+
+    properties = {}
+    for attr in xml_attributes:
+        properties[attr] = {}
+    nodes = set()
+    pos = {}
+    time = {}
+    properties["label"] = {}
+
+    for frame in AllSpots:
+        t = int(frame.attrib["frame"])
+        for cell in frame:
+            cell_id, n, x, y, z = (
+                int(cell.attrib["ID"]),
+                cell.attrib["name"],
+                float(cell.attrib["POSITION_X"]),
+                float(cell.attrib["POSITION_Y"]),
+                float(cell.attrib["POSITION_Z"]),
             )
-        self.t_b = min(self.time_nodes.keys())
-        self.t_e = max(self.time_nodes.keys())
-
-    def read_from_mamut_xml(self, path: str):
-        """Read a lineage tree from a MaMuT xml.
-
-        Args:
-            path (str): path to the MaMut xml
-        """
-        tree = ET.parse(path)
-        for elem in tree.getroot():
-            if elem.tag == "Model":
-                Model = elem
-        FeatureDeclarations, AllSpots, AllTracks, FilteredTracks = list(Model)
-
-        for attr in self.xml_attributes:
-            self.__dict__[attr] = {}
-        self.time_nodes = {}
-        self.time_edges = {}
-        self.nodes = set()
-        self.pos = {}
-        self.time = {}
-        self.node_name = {}
-        for frame in AllSpots:
-            t = int(frame.attrib["frame"])
-            self.time_nodes[t] = set()
-            for cell in frame:
-                cell_id, n, x, y, z = (
-                    int(cell.attrib["ID"]),
-                    cell.attrib["name"],
-                    float(cell.attrib["POSITION_X"]),
-                    float(cell.attrib["POSITION_Y"]),
-                    float(cell.attrib["POSITION_Z"]),
-                )
-                self.time_nodes[t].add(cell_id)
-                self.nodes.add(cell_id)
-                self.pos[cell_id] = np.array([x, y, z])
-                self.time[cell_id] = t
-                self.node_name[cell_id] = n
-                if "TISSUE_NAME" in cell.attrib:
-                    if not hasattr(self, "fate"):
-                        self.fate = {}
-                    self.fate[cell_id] = cell.attrib["TISSUE_NAME"]
-                if "TISSUE_TYPE" in cell.attrib:
-                    if not hasattr(self, "fate_nb"):
-                        self.fate_nb = {}
-                    self.fate_nb[cell_id] = eval(cell.attrib["TISSUE_TYPE"])
-                for attr in cell.attrib:
-                    if attr in self.xml_attributes:
-                        self.__dict__[attr][cell_id] = eval(cell.attrib[attr])
-
-        tracks = {}
-        self.successor = {}
-        self.predecessor = {}
-        self.track_name = {}
-        for track in AllTracks:
-            if "TRACK_DURATION" in track.attrib:
-                t_id, _ = (
-                    int(track.attrib["TRACK_ID"]),
-                    float(track.attrib["TRACK_DURATION"]),
-                )
-            else:
-                t_id = int(track.attrib["TRACK_ID"])
-            t_name = track.attrib["name"]
-            tracks[t_id] = []
-            for edge in track:
-                s, t = (
-                    int(edge.attrib["SPOT_SOURCE_ID"]),
-                    int(edge.attrib["SPOT_TARGET_ID"]),
+            nodes.add(cell_id)
+            pos[cell_id] = np.array([x, y, z])
+            time[cell_id] = t
+            properties["label"][cell_id] = n
+            if "TISSUE_NAME" in cell.attrib:
+                if "fate" not in properties:
+                    properties["fate"] = {}
+                properties["fate"][cell_id] = cell.attrib["TISSUE_NAME"]
+            if "TISSUE_TYPE" in cell.attrib:
+                if "fate_nb" not in properties:
+                    properties["fate_nb"] = {}
+                properties["fate_nb"][cell_id] = eval(
+                    cell.attrib["TISSUE_TYPE"]
                 )
-                if s in self.nodes and t in self.nodes:
-                    if self.time[s] > self.time[t]:
-                        s, t = t, s
-                    self.successor.setdefault(s, []).append(t)
-                    self.predecessor.setdefault(t, []).append(s)
-                    self.track_name[s] = t_name
-                    self.track_name[t] = t_name
-                    tracks[t_id].append((s, t))
-        self.t_b = min(self.time_nodes.keys())
-        self.t_e = max(self.time_nodes.keys())
-
-    def read_C_elegans_bao(self, path):
-        cell_times = {}
-        self.expression = {}
-        with open(path) as f:
-            for line in f:
-                if "cell_name" not in line:
-                    cell_times[line.split("\t")[0]] = list(
-                        line.split("\t")[-1].split(",")
-                    )
-        new_dict = {}
-        end_dict = {}
-        self.t_e = 0
-        self.t_b = 0
-        for c, lc in cell_times.items():
-            new_dict[c] = self.add_node(0)
-            tmp = self.add_branch(
-                new_dict[c],
-                length=len(lc) - 1,
-                reverse=True,
-                move_timepoints=True,
+            for attr in cell.attrib:
+                if attr in xml_attributes:
+                    properties[attr][cell_id] = eval(cell.attrib[attr])
+
+    properties["tracks"] = {}
+    successor = {}
+    properties["track_name"] = {}
+    for track in AllTracks:
+        if "TRACK_DURATION" in track.attrib:
+            t_id, _ = (
+                int(track.attrib["TRACK_ID"]),
+                float(track.attrib["TRACK_DURATION"]),
+            )
+        else:
+            t_id = int(track.attrib["TRACK_ID"])
+        t_name = track.attrib["name"]
+        properties["tracks"][t_id] = []
+        for edge in track:
+            s, t = (
+                int(edge.attrib["SPOT_SOURCE_ID"]),
+                int(edge.attrib["SPOT_TARGET_ID"]),
             )
-            for i, node in enumerate(self.get_cycle(tmp)):
-                self.expression[node] = int(lc[i])
-            self._labels[self.get_cycle(tmp)[0]] = c
-            self._labels.pop(tmp)
-            end_dict[c] = self.get_cycle(new_dict[c])[-1]
-        cell_names = list(cell_times.keys())
-        c_to_p = {}
-        while cell_names:
-            cur = cell_names.pop()
-            if cur[:-1] in cell_names:
-                c_to_p[cur] = cur[:-1]
-        c_to_p.update(self.implicit_l_t)
-        for c, p in c_to_p.items():
-            if p in cell_times:
-                cyc = end_dict[p]
-                self.predecessor[new_dict[c]] = [cyc]
-                if cyc not in self.successor:
-                    self.successor[cyc] = []
-                self.successor[cyc].append(new_dict[c])
-        self.time_nodes.clear()
-        for root in self.roots:
-            to_do = [root]
-            while to_do:
-                cur = to_do.pop()
-                self.time_nodes.setdefault(self.time[cur], set()).add(cur)
-                _next = self.successor.get(cur, [])
-                to_do += _next
-                for n in _next:
-                    self.time[n] = self.time[cur] + 1
-        self.t_e = max(self.time.values())
+            if s in nodes and t in nodes:
+                if time[s] > time[t]:
+                    s, t = t, s
+                successor.setdefault(s, []).append(t)
+                properties["track_name"][s] = t_name
+                properties["track_name"][t] = t_name
+                properties["tracks"][t_id].append((s, t))
+    if not name:
+        tmp_name = Path(path).stem
+        if name == "":
+            warn(f"Name set to default {tmp_name}", stacklevel=2)
+        name = tmp_name
+
+    return lineageTree(
+        successor=successor,
+        time=time,
+        pos=pos,
+        name=name,
+        **properties,
+    )