LineageTree 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

LineageTree/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 from .lineageTree import lineageTree

LineageTree/lineageTree.py

@@ -17,6 +17,7 @@ import struct
 from scipy.spatial.distance import cdist
 import pickle as pkl
 
+
 class lineageTree(object):
     def get_next_id(self):
         """Computes the next authorized id.
@@ -277,7 +278,11 @@ class lineageTree(object):
         stroke_color=None,
         positions=None,
         node_color_map=None,
+        normalize=True,
     ):
+
+        ##### remove background? default True background value? default 1
+
         """Writes the lineage tree to an SVG file.
         Node and edges coloring and size can be provided.
 
@@ -300,7 +305,7 @@ class lineageTree(object):
             node_color: func | str, a function that maps a node id to a triplet between 0 and 255.
                         The triplet will determine the color of the node. If a string is given instead and it is a property
                         of the tree, the the color will be mapped according to the property
-            node_color_map: str, the name of the colormap to use to color the nodes
+            node_color_map: str | func, the name of the colormap to use to color the nodes, or a colormap function
             stroke_color: func, a function that maps a node id to a triplet between 0 and 255.
                           The triplet will determine the color of the stroke of the inward edge.
             positions: {int: [float, float], ...}, dictionary that maps a node id to a 2D position.
@@ -317,6 +322,7 @@ class lineageTree(object):
 
         if roots is None:
             roots = list(set(self.successor).difference(self.predecessor))
+            roots = [cell for cell in roots if self.image_label[cell] != 1]
 
         if node_size is None:
             node_size = lambda x: vert_space_factor / 2.1
@@ -455,28 +461,54 @@ class lineageTree(object):
                     )
         dwg.save()
 
-    def to_treex(self, sampling=1):
-        """Convert the lineage tree into a treex file."""
+    def to_treex(self, sampling=1, start=0, finish=10000, many=True):
+        """
+        Convert the lineage tree into a treex file.
+
+        start/finish refer to first index in the new array times_to_consider
+
+        """
         from treex.tree import Tree
+        from warnings import warn
 
+        start //= sampling
+        finish //= sampling
+        if finish - start <= 0:
+            warn("Will return None, because start = finish")
+            return None
         id_to_tree = {id: Tree() for id in self.nodes}
-        times_to_consider = [t for t, n in self.time_nodes.items() if 0<len(n)]
-        times_to_consider = times_to_consider[::sampling]
+        times_to_consider = [
+            t for t, n in self.time_nodes.items() if 0 < len(n)
+        ]
+        times_to_consider = times_to_consider[start:finish:sampling]
+        start_time = times_to_consider[0]
         for t in times_to_consider:
             for id_mother in self.time_nodes[t]:
                 ids_daughters = self.successor.get(id_mother, [])
                 new_ids_daughters = ids_daughters.copy()
-                for _ in range(sampling-1):
+                for _ in range(sampling - 1):
                     tmp = []
                     for d in new_ids_daughters:
                         tmp.extend(self.successor.get(d, [d]))
                     new_ids_daughters = tmp
-                for daugther in new_ids_daughters: ## For each daughter in the list of daughters
-                    id_to_tree[id_mother].add_subtree(id_to_tree[daugther]) ## Add the Treex daughter as a subtree of the Treex mother   
-        
-        roots = [id_to_tree[id] for id in set(self.successor).difference(self.predecessor)] 
-
-        return roots
+                for (
+                    daugther
+                ) in (
+                    new_ids_daughters
+                ):  ## For each daughter in the list of daughters
+                    id_to_tree[id_mother].add_subtree(
+                        id_to_tree[daugther]
+                    )  ## Add the Treex daughter as a subtree of the Treex mother
+        roots = [id_to_tree[id] for id in set(self.time_nodes[start_time])]
+        for root, ids in zip(roots, set(self.time_nodes[start_time])):
+            root.add_attribute_to_id("ID", ids)
+        if not many:
+            reroot = Tree()
+            for root in roots:
+                reroot.add_subtree(root)
+            return reroot
+        else:
+            return roots
 
     def to_tlp(
         self,
@@ -568,9 +600,7 @@ class lineageTree(object):
                     ]
                 if spatial:
                     edges_to_use += [
-                        e
-                        for e in s_edges
-                        if t_min < self.time[e[0]] < t_max
+                        e for e in s_edges if t_min < self.time[e[0]] < t_max
                     ]
             else:
                 nodes_to_use = list(self.nodes)
@@ -760,224 +790,142 @@ class lineageTree(object):
             eigen (bool): whether or not to read the eigen values, default False
         """
         self._astec_keydictionary = {
-            "lineage": {
-                "output_key": "cell_lineage",
-                "input_keys": [
-                    "lineage_tree",
-                    "lin_tree",
-                    "Lineage tree",
-                    "cell_lineage",
-                ],
-            },
-            "h_min": {
-                "output_key": "cell_h_min",
-                "input_keys": ["cell_h_min", "h_mins_information"],
-            },
-            "volume": {
-                "output_key": "cell_volume",
-                "input_keys": [
-                    "cell_volume",
-                    "volumes_information",
-                    "volumes information",
-                    "vol",
-                ],
-            },
-            "surface": {
-                "output_key": "cell_surface",
-                "input_keys": ["cell_surface", "cell surface"],
-            },
-            "compactness": {
-                "output_key": "cell_compactness",
-                "input_keys": [
-                    "cell_compactness",
-                    "Cell Compactness",
-                    "compacity",
-                    "cell_sphericity",
-                ],
-            },
-            "sigma": {
-                "output_key": "cell_sigma",
-                "input_keys": ["cell_sigma", "sigmas_information", "sigmas"],
-            },
-            "label_in_time": {
-                "output_key": "cell_labels_in_time",
-                "input_keys": [
-                    "cell_labels_in_time",
-                    "Cells labels in time",
-                    "time_labels",
-                ],
-            },
-            "barycenter": {
-                "output_key": "cell_barycenter",
-                "input_keys": [
-                    "cell_barycenter",
-                    "Barycenters",
-                    "barycenters",
-                ],
-            },
-            "fate": {
-                "output_key": "cell_fate",
-                "input_keys": ["cell_fate", "Fate"],
-            },
-            "fate2": {
-                "output_key": "cell_fate_2",
-                "input_keys": ["cell_fate_2", "Fate2"],
-            },
-            "fate3": {
-                "output_key": "cell_fate_3",
-                "input_keys": ["cell_fate_3", "Fate3"],
-            },
-            "fate4": {
-                "output_key": "cell_fate_4",
-                "input_keys": ["cell_fate_4", "Fate4"],
-            },
-            "all-cells": {
-                "output_key": "all_cells",
-                "input_keys": [
-                    "all_cells",
-                    "All Cells",
-                    "All_Cells",
-                    "all cells",
-                    "tot_cells",
-                ],
-            },
-            "principal-value": {
-                "output_key": "cell_principal_values",
-                "input_keys": ["cell_principal_values", "Principal values"],
-            },
-            "name": {
-                "output_key": "cell_name",
-                "input_keys": ["cell_name", "Names", "names", "cell_names"],
-            },
-            "contact": {
-                "output_key": "cell_contact_surface",
-                "input_keys": [
-                    "cell_contact_surface",
-                    "cell_cell_contact_information",
-                ],
-            },
-            "history": {
-                "output_key": "cell_history",
-                "input_keys": [
-                    "cell_history",
-                    "Cells history",
-                    "cell_life",
-                    "life",
-                ],
-            },
-            "principal-vector": {
-                "output_key": "cell_principal_vectors",
-                "input_keys": ["cell_principal_vectors", "Principal vectors"],
-            },
-            "name-score": {
-                "output_key": "cell_naming_score",
-                "input_keys": ["cell_naming_score", "Scores", "scores"],
-            },
-            "problems": {
-                "output_key": "problematic_cells",
-                "input_keys": ["problematic_cells"],
-            },
-            "unknown": {
-                "output_key": "unknown_key",
-                "input_keys": ["unknown_key"],
-            },
+            "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)
         else:
             tmp_data = self._read_from_ASTEC_pkl(file_path, eigen)
 
+        # make sure these are all named liked they are in tmp_data (or change dictionary above)
         self.name = {}
         self.volume = {}
         self.lT2pkl = {}
         self.pkl2lT = {}
         self.contact = {}
         self.prob_cells = set()
-        if "cell_lineage" in tmp_data:
-            lt = tmp_data["cell_lineage"]
-        elif "lin_tree" in tmp_data:
-            lt = tmp_data["lin_tree"]
-        else:
-            lt = tmp_data["Lineage tree"]
-        if "cell_name" in tmp_data:
-            names = tmp_data["cell_name"]
-        elif "Names" in tmp_data:
-            names = tmp_data["Names"]
-        else:
-            names = {}
-        if "cell_fate" in tmp_data:
-            self.fates = {}
-            fates = tmp_data["cell_fate"]
-            do_fates = True
-        else:
-            do_fates = False
-        if "cell_volume" in tmp_data:
-            do_volumes = True
-            volumes = tmp_data["cell_volume"]
-        elif "volume_information" in tmp_data:
-            do_volumes = True
-            volumes = tmp_data["volume_information"]
-        else:
-            do_volumes = False
+        self.image_label = {}
+
+        lt = tmp_data["cell_lineage"]
+
+        # if "cell_name" in tmp_data:
+        #     names = tmp_data["cell_name"]
+        # else:
+        #     names = {}
+
         if "cell_contact_surface" in tmp_data:
             do_surf = True
             surfaces = tmp_data["cell_contact_surface"]
         else:
             do_surf = False
-        if "problematic_cells" in tmp_data:
-            prob_cells = set(tmp_data["problematic_cells"])
-        else:
-            prob_cells = set()
-        if eigen:
-            self.eigen_vectors = {}
-            self.eigen_values = {}
-            eig_val = tmp_data["cell_principal_values"]
-            eig_vec = tmp_data["cell_principal_vectors"]
+
+        # if "problematic_cells" in tmp_data:
+        #     prob_cells = set(tmp_data["problematic_cells"])
+        # else:
+        #     prob_cells = set()
+        # if eigen:
+        #     self.eigen_vectors = {}
+        #     self.eigen_values = {}
+        #     eig_val = tmp_data["cell_principal_values"]
+        #     eig_vec = tmp_data["cell_principal_vectors"]
 
         inv = {vi: [c] for c, v in lt.items() for vi in v}
         nodes = set(lt).union(inv)
-        if "cell_barycenter" in tmp_data:
-            pos = tmp_data["cell_barycenter"]
-        elif "Barycenters" in tmp_data:
-            pos = tmp_data["Barycenters"]
-        else:
-            pos = dict(
-                list(
-                    zip(
-                        nodes,
-                        [
-                            [0.0, 0.0, 0.0],
-                        ]
-                        * len(nodes),
-                    )
-                )
-            )
+        # if "cell_barycenter" in tmp_data:
+        #     pos = tmp_data["cell_barycenter"]
+        # else:
+        #     pos = dict(list(zip(nodes,[[0.0, 0.0, 0.0]]* len(nodes))))
 
         unique_id = 0
-        id_corres = {}
-        self.image_label = {}
+        # id_corres = {}
+
         for n in nodes:
-            if n in prob_cells:
-                self.prob_cells.add(unique_id)
+            # if n in prob_cells:
+            #     self.prob_cells.add(unique_id)
             # if n in pos and n in names:
             t = n // 10**4
             self.image_label[unique_id] = n % 10**4
             self.lT2pkl[unique_id] = n
             self.pkl2lT[n] = unique_id
-            self.name[unique_id] = names.get(n, "")
-            position = np.array(pos.get(n, [0, 0, 0]), dtype=float)
+            # self.name[unique_id] = names.get(n, "")
+            # position = np.array(pos.get(n, [0, 0, 0]), dtype=float)
             self.time_nodes.setdefault(t, set()).add(unique_id)
             self.nodes.add(unique_id)
-            self.pos[unique_id] = position
+            # self.pos[unique_id] = position
             self.time[unique_id] = t
-            id_corres[n] = unique_id
-            if do_volumes:
-                self.volume[unique_id] = volumes.get(n, 0.0)
-            if eigen:
-                self.eigen_vectors[unique_id] = eig_vec.get(n)
-                self.eigen_values[unique_id] = eig_val.get(n)
-            if do_fates:
-                self.fates[unique_id] = fates.get(n, "")
+            # id_corres[n] = unique_id
+            if "cell_volume" in tmp_data:
+                self.volume[unique_id] = tmp_data["cell_volume"].get(n, 0.0)
+            # if eigen:
+            #     self.eigen_vectors[unique_id] = eig_vec.get(n)
+            #     self.eigen_values[unique_id] = eig_val.get(n)
+            if "cell_fate" in tmp_data:
+                self.fates = {}
+                self.fates[unique_id] = tmp_data["cell_fate"].get(n, "")
 
             unique_id += 1
         # self.contact = {self.pkl2lT[c]: v for c, v in surfaces.iteritems() if c in self.pkl2lT}
@@ -990,13 +938,13 @@ class lineageTree(object):
                         if n % 10**4 == 1 or n in self.pkl2lT
                     }
 
-        for n, new_id in id_corres.items():
+        for n, new_id in self.pkl2lT.items():
             # new_id = id_corres[n]
             if n in inv:
-                self.predecessor[new_id] = [id_corres[ni] for ni in inv[n]]
+                self.predecessor[new_id] = [self.pkl2lT[ni] for ni in inv[n]]
             if n in lt:
                 self.successor[new_id] = [
-                    id_corres[ni] for ni in lt[n] if ni in id_corres
+                    self.pkl2lT[ni] for ni in lt[n] if ni in self.pkl2lT
                 ]
                 self.edges.update(
                     [(new_id, ni) for ni in self.successor[new_id]]
@@ -1009,6 +957,35 @@ class lineageTree(object):
         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
+        for prop_name, prop_values in tmp_data.items():
+            if hasattr(self, prop_name):
+                continue
+            else:
+                if isinstance(prop_values, dict):
+                    dictionary = {
+                        self.pkl2lT[k]: 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] = {
+                                self.pkl2lT[k]: v for k, v in value
+                            }
+                    self.__dict__[prop_name] = dictionary
+                # 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 (
+                    prop_values.isinstance(set)
+                    or prop_values.isinstance(list)
+                    or prop_values.isinstance(np.array)
+                ):
+                    self.__dict__[prop_name] = prop_values
+
+            # what else could it be?
+
+        # add a list of all available properties
+
     def _read_from_ASTEC_xml(self, file_path):
         def _set_dictionary_value(root):
             if len(root) == 0:
@@ -1030,7 +1007,7 @@ class lineageTree(object):
         dictionary = {}
 
         for k, v in self._astec_keydictionary.items():
-            if root.tag == v["output_key"]:
+            if root.tag == k:
                 dictionary[str(root.tag)] = _set_dictionary_value(root)
                 break
         else:
@@ -1041,19 +1018,21 @@ class lineageTree(object):
         return dictionary
 
     def _read_from_ASTEC_pkl(self, file_path, eigen=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["input_keys"]:
-                new_ref[key] = v["output_key"]
+            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_txt_for_celegans(self, file):
@@ -1289,6 +1268,41 @@ class lineageTree(object):
                         self.ind_cells[t] = 1
         self.max_id = unique_id - 1
 
+    def read_from_mastodon(self, path, name):
+        from mastodon_reader import MastodonReader
+
+        mr = MastodonReader(path)
+        spots, links = mr.read_tables()
+        mr.read_tags(spots, links)
+
+        self.node_name = {}
+
+        for c in spots.iloc:
+            unique_id = c.name
+            x, y, z = c.x, c.y, c.z
+            t = c.t
+            if name is not None:
+                n = c[name]
+            else:
+                n = ""
+            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.edges.add((source, 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_mamut_xml(self, path):
         """Read a lineage tree from a MaMuT xml.
 
@@ -1344,9 +1358,12 @@ class lineageTree(object):
         self.predecessor = {}
         self.track_name = {}
         for track in AllTracks:
-            t_id, l = int(track.attrib["TRACK_ID"]), float(
-                track.attrib["TRACK_DURATION"]
-            )
+            if "TRACK_DURATION" in track.attrib:
+                t_id, l = 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:
@@ -1571,15 +1588,15 @@ class lineageTree(object):
         self.max_id = max(self.nodes)
 
     def write(self, fname):
-        if os.path.splitext(fname)[-1] != '.lT':
-            os.path.extsep.join(fname, 'lT')
-        with open(fname, 'bw') as f:
+        if os.path.splitext(fname)[-1] != ".lT":
+            fname = os.path.extsep.join((fname, "lT"))
+        with open(fname, "bw") as f:
             pkl.dump(self, f)
             f.close()
 
     @classmethod
     def load(clf, fname):
-        with open(fname, 'br') as f:
+        with open(fname, "br") as f:
             lT = pkl.load(f)
             f.close()
         return lT
@@ -1895,6 +1912,7 @@ class lineageTree(object):
         raw_size=None,
         reorder=False,
         xml_attributes=[],
+        name=None,
     ):
         """Main library to build tree graph representation of lineage tree data
         It can read TGMM, ASTEC, SVF, MaMuT and TrackMate outputs.
@@ -1933,6 +1951,8 @@ class lineageTree(object):
             self.t_e = te
         elif file_type == "mamut" or file_type == "trackmate":
             self.read_from_mamut_xml(file_format)
+        elif file_type == "mastodon":
+            self.read_from_mastodon(file_format, name)
         elif file_type == "celegans":
             self.read_from_txt_for_celegans(file_format)
         elif file_type == "celegans_cao":
@@ -1943,7 +1963,7 @@ class lineageTree(object):
             self.read_from_ASTEC(file_format, eigen)
         elif file_type == "csv":
             self.read_from_csv(file_format, z_mult, link=1, delim=delim)
-        elif file_format is not None and '.lT' in file_format:
-            self.read(file_format)
+        elif file_format is not None and ".lT" in file_format:
+            self.load(file_format)
         elif file_format is not None:
             self.read_from_binary(file_format)

{LineageTree-1.1.0.dist-info → LineageTree-1.2.0.dist-info}/METADATA

@@ -1,17 +1,33 @@
 Metadata-Version: 2.1
 Name: LineageTree
-Version: 1.1.0
-Summary: Lineage tree structure for TGMM algorithm
-Home-page: https://github.com/leoguignard/TGMMlibraries
-Author: Leo Guignard
-Classifier: Development Status :: 5 - Production/Stable
+Version: 1.2.0
+Summary: Lineage tree structure
+Home-page: https://github.com/leoguignard/LineageTree
+Author: Léo Guignard
+Author-email: leo.guignard@univ-amu.fr
+License: MIT
+Project-URL: Bug Tracker, https://github.com/leoguignard/LineageTree/issues
+Project-URL: Documentation, https://github.com/leoguignard/LineageTree#README.md
+Project-URL: Source Code, https://github.com/leoguignard/LineageTree
+Project-URL: User Support, https://github.com/leoguignard/LineageTree/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: napari
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: scipy (>=1.9)
-Requires-Dist: numpy (>=1.23)
+Requires-Dist: scipy >=1.9
+Requires-Dist: numpy >=1.23
+Requires-Dist: mastodon-reader
 Provides-Extra: svg
 Requires-Dist: svgwrite ; extra == 'svg'
 Requires-Dist: matplotlib ; extra == 'svg'

LineageTree-1.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+LineageTree/__init__.py,sha256=4sOHUhh3fwe6uDsv01ZOFOCxW9AesrrwqwLvcdN9CKY,59
+LineageTree/lineageTree.py,sha256=hWb36Ubtr6bMmIfYK-xSBRiBwI33w9xKDyLRRJzKApw,76208
+LineageTree-1.2.0.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
+LineageTree-1.2.0.dist-info/METADATA,sha256=iik7lxLRiBrtY_zVXxl2IS75OuAHIGjAMuNo4q4FSEA,3273
+LineageTree-1.2.0.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+LineageTree-1.2.0.dist-info/entry_points.txt,sha256=M3R-NzHWL87f2i09pSJu-xjKWuMDA3P3QhTsszFeATk,70
+LineageTree-1.2.0.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
+LineageTree-1.2.0.dist-info/RECORD,,

{LineageTree-1.1.0.dist-info → LineageTree-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: bdist_wheel (0.41.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

LineageTree-1.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[napari.manifest]
+napari-lineageTree = napari_lineagetree:napari.yaml

LineageTree-1.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-LineageTree/__init__.py,sha256=eeNSdcYnjpoKqQb9TICn1RBSPXg0WG5hrb8E0bJH1ow,59
-LineageTree/lineageTree.py,sha256=FxNMFWVEvG-gbazVmHP1COKqHttWHVg0YwivYADRfCM,75126
-LineageTree-1.1.0.dist-info/LICENSE,sha256=IKncNCNpq93Kq7Ywg1V4I9Bu_99VMK-mX1EJyjTKLyc,1068
-LineageTree-1.1.0.dist-info/METADATA,sha256=oINELZEj6i0gCMAlWDA_LToEtsTiaUc_FkbBmE8RZ9Y,2505
-LineageTree-1.1.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-LineageTree-1.1.0.dist-info/top_level.txt,sha256=CCqPCTX76zPTEUagUgTWbLaZun8752n59iOOwfUlvxs,12
-LineageTree-1.1.0.dist-info/RECORD,,