cellects 0.1.2__py3-none-any.whl

cellects/utils/utilitarian.py

@@ -0,0 +1,490 @@
+#!/usr/bin/env python3
+"""
+Utility module with array operations, path manipulation, and progress tracking.
+
+This module provides performance-optimized utilities for numerical comparisons using Numba,
+path string truncation, dictionary filtering, and iteration progress monitoring. It is designed
+for applications requiring efficient data processing pipelines with both low-level optimization
+and human-readable output formatting.
+
+Classes
+-------
+PercentAndTimeTracker : Track iteration progress with time estimates and percentage completion
+
+Functions
+---------
+greater_along_first_axis : Compare arrays element-wise along first axis (>) using Numba
+less_along_first_axis    : Compare arrays element-wise along first axis (<) using Numba
+translate_dict           : Convert standard dict to typed dict, filtering non-string values
+reduce_path_len          : Truncate long path strings with ellipsis insertion
+find_nearest             : Find array element closest to target value
+
+Notes
+-----
+Numba-optimized functions (greater_along_first_axis and less_along_first_axis) require
+input arrays of identical shape. String manipulation utilities include automatic type conversion.
+The progress tracker records initialization time for potential performance analysis.
+"""
+
+import numpy as np
+from numpy.typing import NDArray
+from typing import Tuple
+from timeit import default_timer
+import time
+from numba.typed import Dict
+from cellects.utils.decorators import njit
+from glob import glob
+vectorized_len = np.vectorize(len)
+
+
+@njit()
+def greater_along_first_axis(array_in_1: NDArray, array_in_2: NDArray) -> NDArray[np.uint8]:
+    """
+    Compare two arrays along the first axis and store the result in a third array.
+
+    This function performs a comparison between two input arrays
+    along their first axis and stores the result in a third array. The comparison is
+    made to determine which elements of each row of the first array are greater than
+    the elements(s) corresponding to that row in the second array.
+
+    Parameters
+    ----------
+    array_in_1 : ndarray
+        First input array.
+    array_in_2 : ndarray
+        Second input array.
+
+    Returns
+    -------
+    out : ndarray of uint8
+        Boolean ndarray with same shape as input arrays,
+        containing the result of element-wise comparison.
+
+    Examples
+    --------
+    >>> array_in_1 = np.array([[2, 4], [5, 8]])
+    >>> array_in_2 = np.array([3, 6])
+    >>> array_out = greater_along_first_axis(array_in_1, array_in_2)
+    >>> print(array_out)
+    [[0 1]
+     [0 1]]
+    """
+    array_out = np.zeros(array_in_1.shape, dtype=np.uint8)
+    for i, value in enumerate(array_in_2):
+        array_out[i, ...] = array_in_1[i, ...] > value
+    return array_out
+
+
+@njit()
+def less_along_first_axis(array_in_1: NDArray, array_in_2: NDArray) -> NDArray[np.uint8]:
+    """
+    Compare two arrays along the first axis and store the result in a third array.
+
+    This function performs a comparison between two input arrays
+    along their first axis and stores the result in a third array. The comparison is
+    made to determine which elements of each row of the first array are lesser than
+    the elements(s) corresponding to that row in the second array.
+
+    Parameters
+    ----------
+    array_in_1 : ndarray
+        The first input array.
+    array_in_2 : ndarray
+        The second input array.
+
+    Returns
+    -------
+    ndarray of uint8
+        A boolean array where each element is `True` if the corresponding
+        element in `array_in_1` is lesser than the corresponding element
+        in `array_in_2`, and `False` otherwise.
+
+    Examples
+    --------
+    >>> array_in_1 = np.array([[2, 4], [5, 8]])
+    >>> array_in_2 = np.array([3, 6])
+    >>> array_out = less_along_first_axis(array_in_1, array_in_2)
+    >>> print(array_out)
+    [[1 0]
+     [1 0]]
+    """
+    array_out = np.zeros(array_in_1.shape, dtype=np.uint8)
+    for i, value in enumerate(array_in_2):
+        array_out[i, ...] = array_in_1[i, ...] < value
+    return array_out
+
+
+def translate_dict(old_dict: dict) -> Dict:
+    """
+    Translate a dictionary to a typed dictionary and filter out non-string values.
+
+    Parameters
+    ----------
+    old_dict : dict
+        The input dictionary that may contain non-string values
+
+    Returns
+    -------
+    numba_dict : Dict
+        A typed dictionary containing only the items from `old_dict` where the value is not a string
+
+    Examples
+    --------
+    >>> result = translate_dict({'a': 1., 'b': 'string', 'c': 2.0})
+    >>> print(result)
+    {a: 1.0, c: 2.0}
+    """
+    numba_dict = Dict()
+    for k, v in old_dict.items():
+        if not isinstance(v, str):
+            numba_dict[k] = v
+    return numba_dict
+
+
+def reduce_path_len(pathway: str, to_start: int, from_end: int) -> str:
+    """
+    Reduce the length of a given pathway string by truncating it from both ends.
+
+    The function is used to shorten the `pathway` string if its length exceeds
+    a calculated maximum size. If it does, the function truncates it from both ends,
+    inserting an ellipsis ("...") in between.
+
+    Parameters
+    ----------
+    pathway : str
+        The pathway string to be reduced. If an integer is provided,
+        it will be converted into a string.
+    to_start : int
+        Number of characters from the start to keep in the pathway string.
+    from_end : int
+        Number of characters from the end to keep in the pathway string.
+
+    Returns
+    -------
+    str
+        The reduced version of the `pathway` string. If truncation is not necessary,
+        returns the original pathway string.
+
+    Examples
+    --------
+    >>> reduce_path_len("example/complicated/path/to/resource", 8, 12)
+    'example/.../to/resource'
+    """
+    if not isinstance(pathway, str):
+        pathway = str(pathway)
+    max_size = to_start + from_end + 3
+    if len(pathway) > max_size:
+        pathway = pathway[:to_start] + "..." + pathway[-from_end:]
+    return pathway
+
+
+def find_nearest(array: NDArray, value):
+    """
+    Find the element in an array that is closest to a given value.
+
+    Parameters
+    ----------
+    array : array_like
+        Input array. Can be any array-like data structure.
+    value : int or float
+        The value to find the closest element to.
+
+    Returns
+    -------
+    :obj:`array` type
+        The element in `array` that is closest to `value`.
+
+    Examples
+    --------
+    >>> find_nearest([1, 2, 3, 4], 2.5)
+    2
+    """
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+class PercentAndTimeTracker:
+    """
+    Initialize a progress bar object to track and display the progress of an iteration.
+
+    Parameters
+    ----------
+    total : int
+        The total number of iterations.
+    compute_with_elements_number : bool, optional
+        If True, create an element vector. Default is False.
+    core_number : int, optional
+        The number of cores to use. Default is 1.
+
+    Attributes
+    ----------
+    starting_time : float
+        The time when the ProgressBar object is initialized.
+    total : int
+        The total number of iterations.
+    current_step : int
+        The current iteration step (initialized to 0).
+    element_vector : numpy.ndarray, optional
+        A vector of zeros with the same length as `total`, created if
+        `compute_with_elements_number` is True.
+    core_number : int
+        The number of cores.
+
+    Examples
+    --------
+    >>> p = PercentAndTimeTracker(10)
+    >>> print(p.total)  # prints: 10
+    >>> p = PercentAndTimeTracker(10, compute_with_elements_number=True)
+    >>> print(p.element_vector)  # prints: [0 0 0 0 0 0 0 0 0 0]
+
+    Notes
+    -----
+    Starting time is recorded for potential performance tracking.
+
+    """
+    def __init__(self, total: int, compute_with_elements_number: bool=False, core_number:int =1):
+        """Initialize an instance of the class.
+
+        This constructor sets up the initial attributes including
+        a starting time, total value, current step, and an optional
+        element vector if ``compute_with_elements_number`` is set to True.
+        The core number can be specified, defaulting to 1.
+
+        Parameters
+        ----------
+        total : int
+            The total number of elements or steps.
+        compute_with_elements_number : bool, optional
+            If True, initialize an element vector of zeros. Defaults to False.
+        core_number : int, optional
+            The number of cores to use. Defaults to 1.
+
+        Attributes
+        ----------
+        starting_time : float
+            The time of instantiation.
+        total : int
+            The total number of elements or steps.
+        current_step : int
+            The current step in the process.
+        element_vector : ndarray of int64, optional
+            A vector initialized with zeros. Exists if ``compute_with_elements_number`` is True.
+        core_number : int
+            The number of cores to use.
+        """
+        self.starting_time = default_timer()
+        self.total = total
+        self.current_step = 0
+        if compute_with_elements_number:
+            self.element_vector = np.zeros(total, dtype=np.int64)
+        self.core_number = core_number
+
+    def get_progress(self, step=None, element_number=None):
+        """
+        Calculate and update the current progress, including elapsed time and estimated remaining time.
+
+        This function updates the internal state of the object to reflect progress
+        based on the current step and element number. It calculates elapsed time,
+        estimates total time, and computes the estimated time of arrival (ETA).
+
+        Parameters
+        ----------
+        step : int or None, optional
+            The current step of the process. If ``None``, the internal counter is incremented.
+        element_number : int or None, optional
+            The current element number. If ``None``, no update is made to the element vector.
+
+        Returns
+        -------
+        tuple
+            A tuple containing:
+            - `int`: The current progress percentage.
+            - `str`: A string with the ETA and remaining time.
+
+        Raises
+        ------
+        ValueError
+            If ``step`` or ``element_number`` are invalid.
+
+        Notes
+        -----
+        The function uses linear regression to estimate future progress values when the current step is sufficiently large.
+
+        Examples
+        --------
+        >>> PercentAndTimeTracker(10, compute_with_elements_number=True).get_progress(9, 5)
+        (0, ', wait to get a more accurate ETA...')
+        """
+        if step is not None:
+            self.current_step = step
+        if element_number is not None:
+            self.element_vector[self.current_step] = element_number
+
+        if self.current_step > 0:
+            elapsed_time = default_timer() - self.starting_time
+            if element_number is None or element_number == 0 or self.current_step < 15:
+                if self.current_step < self.core_number:
+                    current_prop = self.core_number / self.total
+                else:
+                    current_prop = (self.current_step + 1) / self.total
+            else:
+                x_mat = np.array([np.ones(self.current_step - 4), np.arange(5, self.current_step + 1)]).T
+                coefs = np.linalg.lstsq(x_mat, self.element_vector[5:self.current_step + 1], rcond=-1)[0]
+                self.element_vector = coefs[0] + (np.arange(self.total) * coefs[1])
+                self.element_vector[self.element_vector < 0] = 0
+                current_prop = self.element_vector[:self.current_step + 1].sum() / self.element_vector.sum()
+
+            total_time = elapsed_time / current_prop
+            current_prop = int(np.round(current_prop * 100))
+            remaining_time_s = total_time - elapsed_time
+
+            local_time = time.localtime()
+            local_m = int(time.strftime("%M", local_time))
+            local_h = int(time.strftime("%H", local_time))
+            remaining_time_h = remaining_time_s // 3600
+            reste_s = remaining_time_s % 3600
+            reste_m = reste_s // 60
+            # + str(int(np.floor(reste_s % 60))) + "S"
+            hours = int(np.floor(remaining_time_h))
+            minutes = int(np.floor(reste_m))
+
+            if (local_m + minutes) < 60:
+                eta_m = local_m + minutes
+            else:
+                eta_m = (local_m + minutes) % 60
+                local_h += 1
+
+            if (local_h + hours) < 24:
+                output = current_prop, f", ETA {local_h + hours}:{eta_m} ({hours}:{minutes} left)"
+            else:
+                days = (local_h + hours) // 24
+                eta_h = (local_h + hours) % 24
+                eta_d = time.strftime("%m", local_time) + "/" + str(int(time.strftime("%d", local_time)) + days)
+                output = current_prop, f", ETA {eta_d} {eta_h}:{eta_m} ({hours}:{minutes} left)"
+            # return current_prop, str(local_h + hours) + ":" + str(local_m + minutes) + "(" + str()
+        else:
+            output = int(np.round(100 / self.total)), ", wait..."
+        if step is None:
+            self.current_step += 1
+        if element_number is not None:
+            if self.current_step < 50:
+                output = int(0), ", wait to get a more accurate ETA..."
+        return output
+
+
+def insensitive_glob(pattern: str):
+    """
+    Generates a glob pattern that matches both lowercase and uppercase letters.
+
+    Parameters
+    ----------
+    pattern : str
+        The glob pattern to be made case-insensitive.
+
+    Returns
+    -------
+    str
+        A new glob pattern that will match both lowercase and uppercase letters.
+
+    Examples
+    --------
+    >>> insensitive_glob('*.TXT')
+    """
+    def either(c):
+        return '[%s%s]' % (c.lower(), c.upper()) if c.isalpha() else c
+    return glob(''.join(map(either, pattern)))
+
+
+def smallest_memory_array(array_object, array_type='uint') -> NDArray:
+    """
+    Convert input data to the smallest possible NumPy array type that can hold it.
+
+    Parameters
+    ----------
+    array_object : ndarray or list of lists
+        The input data to be converted.
+    array_type : str, optional, default is 'uint'
+        The type of NumPy data type to use ('uint').
+
+    Returns
+    -------
+    ndarray
+        A NumPy array of the smallest data type that can hold all values in `array_object`.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> array = [[1, 2], [3, 4]]
+    >>> smallest_memory_array(array)
+    array([[1, 2],
+           [3, 4]], dtype=np.uint8)
+
+    >>> array = [[1000, 2000], [3000, 4000]]
+    >>> smallest_memory_array(array)
+    array([[1000, 2000],
+           [3000, 4000]], dtype=uint16)
+
+    >>> array = [[2**31, 2**32], [2**33, 2**34]]
+    >>> smallest_memory_array(array)
+    array([[         2147483648,          4294967296],
+           [         8589934592,        17179869184]], dtype=uint64)
+    """
+    if isinstance(array_object, list):
+        array_object = np.array(array_object)
+    if isinstance(array_object, np.ndarray):
+        value_max = array_object.max()
+    else:
+
+        if len(array_object[0]) > 0:
+            value_max = np.max((array_object[0].max(), array_object[1].max()))
+        else:
+            value_max = 0
+
+    if array_type == 'uint':
+        if value_max <= np.iinfo(np.uint8).max:
+            array_object = np.array(array_object, dtype=np.uint8)
+        elif value_max <= np.iinfo(np.uint16).max:
+            array_object = np.array(array_object, dtype=np.uint16)
+        elif value_max <= np.iinfo(np.uint32).max:
+            array_object = np.array(array_object, dtype=np.uint32)
+        else:
+            array_object = np.array(array_object, dtype=np.uint64)
+    return array_object
+
+
+def remove_coordinates(arr1: NDArray, arr2: NDArray) -> NDArray:
+    """
+    Remove coordinates from `arr1` that are present in `arr2`.
+
+    Given two arrays of coordinates, remove rows from the first array
+    that match any row in the second array.
+
+    Parameters
+    ----------
+    arr1 : ndarray of shape (n, 2)
+        Array containing coordinates to filter.
+    arr2 : ndarray of shape (m, 2)
+        Array containing coordinates to match for removal.
+
+    Returns
+    -------
+    ndarray of shape (k, 2)
+        Array with coordinates from `arr1` that are not in `arr2`.
+
+    Examples
+    --------
+    >>> arr1 = np.arange(200).reshape(100, 2)
+    >>> arr2 = np.array([[196, 197], [198, 199]])
+    >>> remove_coordinates(arr1, arr2)
+    array([[0, 0],
+           [3, 4]])
+    """
+    if arr1.shape[1] != 2 or arr2.shape[1] != 2:
+        raise ValueError("Both arrays must have shape (n, 2)")
+    mask = ~np.isin(arr1, arr2).all(axis=1)
+    return arr1[mask]
+
+
+
+

cellects-0.1.2.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.2
+Name: cellects
+Version: 0.1.2
+Summary: Cell Expansion Computer Tracking Software.
+Author: Aurèle Boussard
+Project-URL: Homepage, https://github.com/Aurele-B/Cellects
+Project-URL: Issues, https://github.com/Aurele-B/Cellects/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.odt
+Requires-Dist: coloredlogs
+Requires-Dist: exif
+Requires-Dist: ExifRead
+Requires-Dist: numba
+Requires-Dist: opencv-python
+Requires-Dist: pandas
+Requires-Dist: psutil
+Requires-Dist: PySide6>=6.5
+Requires-Dist: scipy
+Requires-Dist: screeninfo
+Requires-Dist: numpy>=1.26
+Requires-Dist: scikit-image
+Requires-Dist: tqdm
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: natsort
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-env; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: doc
+Requires-Dist: mkdocs; extra == "doc"
+Requires-Dist: mkdocs-material; extra == "doc"
+Requires-Dist: pymdown-extensions; extra == "doc"
+
+Cellects: Cell Expansion Computer Tracking Software
+===================================================
+
+Description
+-----------
+
+Cellects is a tracking software for organisms whose shape and size change over time. 
+Cellects’ main strengths are its broad scope of action, 
+automated computation of a variety of geometrical descriptors, easy installation and user-friendly interface.
+
+
+---
+
+## Quick Start
+
+
+⚠️ **Note:** At this stage, Cellects is available **only from source**.  
+You will need **Miniconda3** and **git** installed on your system.
+
+- Install [Miniconda3](https://docs.conda.io/en/latest/miniconda.html)  
+  (choose the installer for your operating system).  
+- Install [git](https://git-scm.com/downloads)  
+  (also available through package managers like `apt`, `brew`, or `choco`).
+
+Once these prerequisites are installed, you can set up Cellects as follows:
+
+```bash
+# Clone the repository
+git clone https://github.com/Aurele-B/Cellects.git
+cd Cellects
+
+# Create and activate the environment
+conda env create -f conda/env.yml
+conda activate cellects-dev
+
+# Install the package in editable mode
+pip install -e .
+```
+
+Launch the application:
+```bash
+Cellects
+```
+
+---
+
+## Developer Guide
+
+### Run Tests
+Cellects uses `pytest` + `pytest-cov`.  
+Install test dependencies:
+
+```bash
+pip install -e ".[test]"
+```
+
+Run the test suite (with coverage enabled by default via `pyproject.toml`):
+
+```bash
+pytest
+```
+
+You can access the coverage report with `coverage html` and open `htmlcov/index.html` in your browser.
+
+```bash
+open htmlcov/index.html        # macOS
+xdg-open htmlcov/index.html    # Linux
+start htmlcov\index.html       # Windows (PowerShell)
+```
+
+Or explicitly:
+```bash
+pytest --cov=src/cellects --cov-report=term-missing
+```
+
+### Build Documentation
+Install doc dependencies:
+
+```bash
+pip install -e ".[doc]"
+```
+
+Serve the docs locally:
+```bash
+mkdocs serve
+```
+
+Open [http://127.0.0.1:8000](http://127.0.0.1:8000) in your browser.
+
+---
+
+## Resources
+- [User manual](https://github.com/Aurele-B/Cellects/blob/main/_old_doc/UserManual.md)  
+- [Usage example (video)](https://www.youtube.com/watch?v=N-k4p_aSPC0)

cellects-0.1.2.dist-info/RECORD

@@ -0,0 +1,44 @@
+cellects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/__main__.py,sha256=qiUkIOuyq3RuyHmYZM3drRbqe5DWP7IVyOGsEy425Lc,1449
+cellects/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/config/all_vars_dict.py,sha256=jcmYUeTiVtEkvIbZAYIASP5oCNiM909YQhaRHCY9y-U,6103
+cellects/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/core/cellects_paths.py,sha256=vwFEYXVAD16w0euoTuJ8Ca0tUyelsoiDNmWqryU5k-k,880
+cellects/core/cellects_threads.py,sha256=St1bAZTWdsrAYu1DBUyOwWSUJv5sellfaNVF3W14LfQ,88336
+cellects/core/motion_analysis.py,sha256=7_fohdeRBFRbJot3g14E6gh58TP9muE4O5fuePqr84A,141997
+cellects/core/one_image_analysis.py,sha256=hU9pa0coVA5s_CTiKgn4najlb8J3LQgEIocXCMi_4nM,68583
+cellects/core/one_video_per_blob.py,sha256=8YKttLdf0gNO3yASdhvAdo-GEh9btDkXrzku7f-t4h0,35536
+cellects/core/program_organizer.py,sha256=gRA3RLdj5i9wPzbqooHd6NoLkPYon5o57HaA7u1d0zQ,77988
+cellects/core/script_based_run.py,sha256=Y9FuJ2I5I3_T6vwAQ6w22vdGbkxmjLVAdDWPyoziVGU,6565
+cellects/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/gui/advanced_parameters.py,sha256=pE2eGZ6tBuq40DalksDzHGGQSjBJcgVr1C2MOAVyGaM,78343
+cellects/gui/cellects.py,sha256=qgHLvrAVR1YatSsuOBl5u7aXCUqVHEbhse7EFkTINOA,7574
+cellects/gui/custom_widgets.py,sha256=tqOYJqBL_3vcBOYkCuHWVa3MBzcEiQiphEcS0QzLCJA,35563
+cellects/gui/first_window.py,sha256=wYQaA-VQFWp_YDjbCXl0e_PgD59-y8kUXRdD2tDelbQ,24803
+cellects/gui/if_several_folders_window.py,sha256=ixi6X4WDQ5CtunEPVFJWip8Sf5ba1Hk2t801lX5CNVk,12508
+cellects/gui/image_analysis_window.py,sha256=7RX9s-jJkvx6qjnFZE81xKCOnhEeY1LhCIYqVlH5r24,116376
+cellects/gui/required_output.py,sha256=YJBSi_Vp5zet2pZVh71viGrlzE8EeMpX41opt3sD8QM,11992
+cellects/gui/video_analysis_window.py,sha256=xl2qtJqUp47GvPh7f4tQoaiK8nUO9Q2Rk6qGSiFBLp8,38033
+cellects/icons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/icons/cellects_icon.icns,sha256=3GM5rpVKUoy-gAYEee5gGPh9lQx9KZqh9iRqYCT83Aw,393392
+cellects/icons/cellects_icon.ico,sha256=Eqlci8zZ0zdsRh2kSQAu4aHAPbR2NEzSbJPgaRQNenI,208076
+cellects/image_analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/image_analysis/cell_leaving_detection.py,sha256=f0wWTACMQASSdXpDtJGe7STJTj6xs1UO1JJzI2FgDBk,2951
+cellects/image_analysis/cluster_flux_study.py,sha256=lHKo2OFN_FvmyX9kP7ubRadTVVxuXDeuRWQuydvyAGQ,5496
+cellects/image_analysis/image_segmentation.py,sha256=g1UXEfb7UFAv0UzZOxFiMJ0rZb0wrnQ4dC69PSJk_NI,28184
+cellects/image_analysis/morphological_operations.py,sha256=a4_SWxk9lik6RZ-DmPrjnkqaV_LUt3h8ar4IQ_F_GTQ,67908
+cellects/image_analysis/network_functions.py,sha256=ahxbWWcq7AxXxelaoEALGqdTbWmDWumNWoUALF2MxoU,88545
+cellects/image_analysis/one_image_analysis_threads.py,sha256=AjAEbJmtldlf23UxWs5my7xz2NIYy3wm25o13pnnYq8,17253
+cellects/image_analysis/progressively_add_distant_shapes.py,sha256=GuTfU57A6JweJHa9dpv7dTVoLX3n2fY6EL9Ul_ukBqU,25799
+cellects/image_analysis/shape_descriptors.py,sha256=8E36-A6hdgJLnj0jVj9_flFDCe2-DBCgpvjNNycyF2I,36546
+cellects/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cellects/utils/decorators.py,sha256=kjZWSK71l5-LrrH7BZHb0kdFaAikC_qZu14_KjIUCms,361
+cellects/utils/formulas.py,sha256=Blw_dgYXb3sbxadONvHUUPoC6qlEVC1NJPMnEimNIxo,20397
+cellects/utils/load_display_save.py,sha256=a_D9uhXPfne-glgFagc0_C_VqKybR9GY8aebc7uLgyg,38299
+cellects/utils/utilitarian.py,sha256=hdCN6PP0z25N-JCElEcGdTzIjyKVG_TYl3BiFmZ2a2k,17248
+cellects-0.1.2.dist-info/LICENSE.odt,sha256=tvKfCylOEuclQm5zOnNWBx0Fp4n7M5yqSmTr6SAekbY,37132
+cellects-0.1.2.dist-info/METADATA,sha256=gYz_r3dVpqwwYTMKtV_SpMov9bWgFgQy7PyPOZJINlw,3354
+cellects-0.1.2.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+cellects-0.1.2.dist-info/entry_points.txt,sha256=JT6rEvKpUuKyDPvfOYma-IMQNvfnKMstFMAoVJhXIGc,60
+cellects-0.1.2.dist-info/top_level.txt,sha256=8VlvCH4ka3bqugIpQnOVjc3UV9Vavfx5SXNyUV9_lGw,9
+cellects-0.1.2.dist-info/RECORD,,

cellects-0.1.2.dist-info/WHEEL

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

cellects-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+Cellects = cellects.__main__:run_cellects

cellects-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+cellects