cellfinder 1.3.3__py3-none-any.whl → 1.4.0a0__py3-none-any.whl

cellfinder/core/tools/IO.py

@@ -0,0 +1,45 @@
+import pooch
+
+
+def fetch_pooch_directory(
+    registry: pooch.Pooch,
+    directory_name: str,
+    processor=None,
+    downloader=None,
+    progressbar=False,
+):
+    """
+    Fetches files from the Pooch registry that belong to a specific directory.
+    Parameters:
+        registry (pooch.Pooch): The Pooch registry object.
+        directory_name (str):
+            The remote relative path of the directory to fetch files from.
+        processor (callable, optional):
+            A function to process the fetched files. Defaults to None.
+        downloader (callable, optional):
+            A function to download the files. Defaults to None.
+        progressbar (bool, optional):
+            Whether to display a progress bar during the fetch.
+            Defaults to False.
+    Returns:
+        str: The local absolute path to the fetched directory.
+    """
+    names = []
+    for name in registry.registry_files:
+        if name.startswith(f"{directory_name}/"):
+            names.append(name)
+
+    if not names:
+        raise FileExistsError(
+            f"Unable to find files in directory {directory_name}"
+        )
+
+    for name in names:
+        registry.fetch(
+            name,
+            processor=processor,
+            downloader=downloader,
+            progressbar=progressbar,
+        )
+
+    return str(registry.abspath / directory_name)

cellfinder/core/tools/threading.py

@@ -0,0 +1,380 @@
+"""
+Provides classes that can run a function in another thread or process and
+allow passing data to and from the threads/processes. It also passes on any
+exceptions that occur in the secondary thread/sub-process in the main thread
+or when it exits.
+
+If using a sub-process and pytorch Tensors are sent from/to the main
+process, pytorch will memory map the tensor so the same data is shared and
+edits in the main process will be visible in the sub-process. However, there
+are limitations (such so not re-sharing a tensor shared with us). See
+https://pytorch.org/docs/stable/multiprocessing.html#sharing-cuda-tensors for
+details.
+
+Typical example::
+
+    from cellfinder.core.tools.threading import ThreadWithException, \\
+        EOFSignal, ProcessWithException
+    import torch
+
+
+    def worker(thread: ThreadWithException, power: float):
+        while True:
+            # if the main thread wants us to exit, it'll wake us up
+            msg = thread.get_msg_from_mainthread()
+            # we were asked to exit
+            if msg == EOFSignal:
+                return
+
+            tensor_id, tensor, add = msg
+            # tensors are memory mapped for subprocess (and obv threads) so we
+            # can do the work inplace and result will be visible in main thread
+            tensor += add
+            tensor.pow_(power)
+
+            # we should not share a tensor shared with us as per pytorch docs,
+            # just send the id back
+            thread.send_msg_to_mainthread(tensor_id)
+
+        # we can also handle errors here, which will be re-raised in the main
+        # process
+            if tensor_id == 7:
+                raise ValueError("I fell asleep")
+
+
+    if __name__ == "__main__":
+        data = torch.rand((5, 10))
+        thread = ThreadWithException(
+            target=worker, args=(2.5,), pass_self=True
+        )
+        # use thread or sub-process
+        # thread = ProcessWithException(
+        #     target=worker, args=(2.5,), pass_self=True
+        # )
+        thread.start()
+
+        try:
+            for i in range(10):
+                thread.send_msg_to_thread((i, data, i / 2))
+                # if the thread raises an exception, get_msg_from_thread will
+                # re-raise it here
+                msg = thread.get_msg_from_thread()
+                if msg == EOFSignal:
+                    # thread exited for whatever reason (not exception)
+                    break
+
+                print(f"Thread processed tensor {i}")
+        finally:
+            # whatever happens, make sure thread is told to finish so it
+            # doesn't get stuck
+            thread.notify_to_end_thread()
+        thread.join()
+
+When run, this prints::
+
+    Thread processed tensor 0
+    Thread processed tensor 1
+    Thread processed tensor 2
+    Thread processed tensor 3
+    Thread processed tensor 4
+    Thread processed tensor 5
+    Thread processed tensor 6
+    Thread processed tensor 7
+    Traceback (most recent call last):
+      File "threading.py", line 139, in user_func_runner
+        self.user_func(self, *self.args)
+      File "play.py", line 24, in worker
+        raise ValueError("I fell asleep")
+    ValueError: I fell asleep
+
+    The above exception was the direct cause of the following exception:
+
+    Traceback (most recent call last):
+      File "play.py", line 38, in <module>
+        msg = thread.get_msg_from_thread()
+      File "threading.py", line 203, in get_msg_from_thread
+        raise ExecutionFailure(
+    ExecutionFailure: Reporting failure from other thread/process
+"""
+
+from queue import Queue
+from threading import Thread
+from typing import Any, Callable, Optional
+
+import torch.multiprocessing as mp
+
+
+class EOFSignal:
+    """
+    This class object (not instance) is returned by the thread/process as an
+    indicator that someone exited or that you should exit.
+    """
+
+    pass
+
+
+class ExecutionFailure(Exception):
+    """
+    Exception class raised in the main thread when the function running in the
+    thread/process raises an exception.
+
+    Get the original exception using the `__cause__` property of this
+    exception.
+    """
+
+    pass
+
+
+class ExceptionWithQueueMixIn:
+    """
+    A mix-in that can be used with a secondary thread or sub-process to
+    facilitate communication with them and the passing back of exceptions and
+    signals such as when the thread/sub-process exits or when the main
+    thread/process want the sub-process/thread to end.
+
+    Communication happens bi-directionally via queues. These queues are not
+    limited in buffer size, so if there's potential for the queue to be backed
+    up because the main thread or sub-thread/process is unable to read and
+    process messages quickly enough, you must implement some kind of
+    back-pressure to prevent the queue from growing unlimitedly in size.
+    E.g. using a limited number of tokens that must be held to send a message
+    to prevent a sender from thrashing the queue. And these tokens can be
+    passed between main thread to sub-thread/process etc on each message and
+    when the message is done processing.
+
+    The main process uses `get_msg_from_thread` to raise exceptions in the
+    main thread that occurred in the sub-thread/process. So that must be
+    called in the main thread if you want to know if the sub-thread/process
+    exited.
+    """
+
+    to_thread_queue: Queue
+    """
+    Internal queue used to send messages to the thread from the main thread.
+    """
+
+    from_thread_queue: Queue
+    """
+    Internal queue used to send messages from the thread to the main thread.
+    """
+
+    args: tuple = ()
+    """
+    The args provided by the caller that will be passed to the function running
+    in the thread/process when it starts.
+    """
+
+    # user_func_runner must end with an eof msg to the main thread. This tracks
+    # whether the main thread saw the eof. If it didn't, we know there are more
+    # msgs in the queue waiting to be read
+    _saw_eof: bool = False
+
+    def __init__(self, target: Callable, pass_self: bool = False):
+        self.user_func = target
+        self.pass_self = pass_self
+
+    def user_func_runner(self) -> None:
+        """
+        The internal function that runs the target function provided by the
+        user.
+        """
+        try:
+            if self.user_func is not None:
+                if self.pass_self:
+                    self.user_func(self, *self.args)
+                else:
+                    self.user_func(*self.args)
+        except BaseException as e:
+            self.from_thread_queue.put(
+                ("exception", e), block=True, timeout=None
+            )
+        finally:
+            self.from_thread_queue.put(("eof", None), block=True, timeout=None)
+
+    def send_msg_to_mainthread(self, value: Any) -> None:
+        """
+        Sends the `value` to the main thread, from the sub-thread/process.
+
+        The value must be pickleable if it's running in a sub-process. The main
+        thread then can read it using `get_msg_from_thread`.
+
+        The queue is not limited in size, so if there's potential for the
+        queue to be backed up because the main thread is unable to read quickly
+        enough, you must implement some kind of back-pressure to prevent
+        the queue from growing unlimitedly in size.
+        """
+        self.from_thread_queue.put(("user", value), block=True, timeout=None)
+
+    def clear_remaining(self) -> None:
+        """
+        Celled in the main-thread as part of cleanup when we expect the
+        secondary thread to have exited (e.g. we sent it a message telling it
+        to).
+
+        It will drop any waiting messages sent by the secondary thread, but
+        more importantly, it will handle exceptions raised in the secondary
+        thread before it exited, that may not have yet been processed in the
+        main thread (e.g. we stopped listening to messages from the secondary
+        thread before we got an eof from it).
+        """
+        while not self._saw_eof:
+            self.get_msg_from_thread()
+
+    def get_msg_from_thread(self, timeout: Optional[float] = None) -> Any:
+        """
+        Gets a message from the sub-thread/process sent to the main thread.
+
+        This blocks forever until the message is sent by the sub-thread/process
+        and received by us. If `timeout` is not None, that's how long we block
+        here, in seconds, before raising an `Empty` Exception if no message was
+        received by then.
+
+        If the return value is the `EOFSignal` object, it means the
+        sub-thread/process has or is about to exit.
+
+        If the sub-thread/process has raised an exception, that exception is
+        caught and re-raised in the main thread when this method is called.
+        The exception raised is an `ExecutionFailure` and its `__cause__`
+        property is the original exception raised in the sub-thread/process.
+
+        A typical pattern is::
+
+            >>> try:
+            ...     msg = thread.get_msg_from_thread()
+            ...     if msg == EOFSignal:
+            ...         # thread exited
+            ...         pass
+            ...     else:
+            ...         # do something with the msg
+            ...         pass
+            ... except ExecutionFailure as e:
+            ...     print(f"got exception {type(e.__cause__)}")
+            ...     print(f"with message {e.__cause__.args[0]}")
+        """
+        msg, value = self.from_thread_queue.get(block=True, timeout=timeout)
+        if msg == "eof":
+            self._saw_eof = True
+            return EOFSignal
+        if msg == "exception":
+            raise ExecutionFailure(
+                "Reporting failure from other thread/process"
+            ) from value
+
+        return value
+
+    def send_msg_to_thread(self, value: Any) -> None:
+        """
+        Sends the `value` to the sub-thread/process, from the main thread.
+
+        The value must be pickleable if it's sent to a sub-process. The thread
+        then can read it using `get_msg_from_mainthread`.
+
+        The queue is not limited in size, so if there's potential for the
+        queue to be backed up because the thread is unable to read quickly
+        enough, you must implement some kind of back-pressure to prevent
+        the queue from growing unlimitedly in size.
+        """
+        self.to_thread_queue.put(("user", value), block=True, timeout=None)
+
+    def notify_to_end_thread(self) -> None:
+        """
+        Sends a message to the sub-process/thread that the main process wants
+        them to end. The sub-process/thread sees it by receiving an `EOFSignal`
+        message from `get_msg_from_mainthread` and it should exit asap.
+        """
+        self.to_thread_queue.put(("eof", None), block=True, timeout=None)
+
+    def get_msg_from_mainthread(self, timeout: Optional[float] = None) -> Any:
+        """
+        Gets a message from the main thread sent to the sub-thread/process.
+
+        This blocks forever until the message is sent by the main thread
+        and received by us. If `timeout` is not None, that's how long we block
+        here, in seconds, before raising an `Empty` Exception if no message was
+        received by then.
+
+        If the return value is the `EOFSignal` object, it means the
+        main thread has sent us an EOF message using `notify_to_end_thread`
+        because it wants us to exit.
+
+        A typical pattern is::
+
+            >>> msg = thread.get_msg_from_mainthread()
+            ... if msg == EOFSignal:
+            ...     # we should exit asap
+            ...     return
+            ... # do something with the msg
+        """
+        msg, value = self.to_thread_queue.get(block=True, timeout=timeout)
+        if msg == "eof":
+            return EOFSignal
+
+        return value
+
+
+class ThreadWithException(ExceptionWithQueueMixIn):
+    """
+    Runs a target function in a secondary thread.
+    """
+
+    thread: Thread = None
+    """The thread running the function."""
+
+    def __init__(self, target, args=(), **kwargs):
+        super().__init__(target=target, **kwargs)
+        self.to_thread_queue = Queue(maxsize=0)
+        self.from_thread_queue = Queue(maxsize=0)
+        self.args = args
+        self.thread = Thread(target=self.user_func_runner)
+
+    def start(self) -> None:
+        """Starts the thread that runs the target function."""
+        self.thread.start()
+
+    def join(self, timeout: Optional[float] = None) -> None:
+        """
+        Waits and blocks until the thread exits. If timeout is given,
+        it's the duration to wait, in seconds, before returning.
+
+        To know if it exited, you need to check `is_alive` of the `thread`.
+        """
+        self.thread.join(timeout=timeout)
+
+
+class ProcessWithException(ExceptionWithQueueMixIn):
+    """
+    Runs a target function in a sub-process.
+
+    Any data sent between the processes must be pickleable.
+
+    We run the function using `torch.multiprocessing`. Any tensors sent between
+    the main process and sub-process is memory mapped so that it doesn't copy
+    the tensor. So any edits in the main process/sub-process is seen in the
+    other as well. See https://pytorch.org/docs/stable/multiprocessing.html
+    for more details on this.
+    """
+
+    process: mp.Process = None
+    """The sub-process running the function."""
+
+    def __init__(self, target, args=(), **kwargs):
+        super().__init__(target=target, **kwargs)
+        ctx = mp.get_context("spawn")
+        self.to_thread_queue = ctx.Queue(maxsize=0)
+        self.from_thread_queue = ctx.Queue(maxsize=0)
+        self.process = ctx.Process(target=self.user_func_runner)
+
+        self.args = args
+
+    def start(self) -> None:
+        """Starts the sub-process that runs the target function."""
+        self.process.start()
+
+    def join(self, timeout: Optional[float] = None) -> None:
+        """
+        Waits and blocks until the process exits. If timeout is given,
+        it's the duration to wait, in seconds, before returning.
+
+        To know if it exited, you need to check `is_alive` of the `process`.
+        """
+        self.process.join(timeout=timeout)

cellfinder/core/tools/tools.py

@@ -1,19 +1,141 @@
+from functools import wraps
 from random import getrandbits, uniform
-from typing import Optional
+from typing import Callable, Optional, Type
 
 import numpy as np
+import torch
 from natsort import natsorted
 
 
-def get_max_possible_value(obj_in: np.ndarray) -> int:
+def inference_wrapper(func):
     """
-    Returns the maximum allowed value for a numpy array of integer data type.
+    Decorator that makes the decorated function/method run with
+    `torch.inference_mode` set to True.
+    """
+
+    @wraps(func)
+    def inner_function(*args, **kwargs):
+        with torch.inference_mode(True):
+            return func(*args, **kwargs)
+
+    return inner_function
+
+
+def get_max_possible_int_value(dtype: Type[np.number]) -> int:
+    """
+    Returns the maximum allowed integer for a numpy array of given type.
+
+    If dtype is of integer type, it's the maximum value. If it's a floating
+    type, it's the maximum integer that can be accurately represented.
+    E.g. for float32, only integers up to 2**24 can be represented (due to
+    the number of bits representing the mantissa (significand).
     """
-    dtype = obj_in.dtype
     if np.issubdtype(dtype, np.integer):
         return np.iinfo(dtype).max
-    else:
-        raise ValueError("obj_in must be a numpy array of integer data type.")
+    if np.issubdtype(dtype, np.floating):
+        mant = np.finfo(dtype).nmant
+        return 2**mant
+    raise ValueError("datatype must be of integer or floating data type")
+
+
+def get_min_possible_int_value(dtype: Type[np.number]) -> int:
+    """
+    Returns the minimum allowed integer for a numpy array of given type.
+
+    If dtype is of integer type, it's the minimum value. If it's a floating
+    type, it's the minimum integer that can be accurately represented.
+    E.g. for float32, only integers up to -2**24 can be represented (due to
+    the number of bits representing the mantissa (significand).
+    """
+    if np.issubdtype(dtype, np.integer):
+        return np.iinfo(dtype).min
+    if np.issubdtype(dtype, np.floating):
+        mant = np.finfo(dtype).nmant
+        # the sign bit is separate so we have the full mantissa for value
+        return -(2**mant)
+    raise ValueError("datatype must be of integer or floating data type")
+
+
+def get_data_converter(
+    src_dtype: Type[np.number], dest_dtype: Type[np.floating]
+) -> Callable[[np.ndarray], np.ndarray]:
+    """
+    Returns a function that can be called to convert one data-type to another,
+    scaling the data down as needed.
+
+    If the maximum value supported by the input data-type is smaller than that
+    supported by destination data-type, the data will be scaled by the ratio
+    of maximum integer representable by the `output / input` data-types.
+    If the max is equal or less, it's simply converted to the target type.
+
+    Parameters
+    ----------
+    src_dtype : np.dtype
+        The data-type of the input data.
+    dest_dtype : np.dtype
+        The data-type of the returned data. Currently, it must be a floating
+        type and `np.float32` or `np.float64`.
+
+    Returns
+    -------
+    callable: function
+        A function that takes a single input data parameter and returns
+        the converted data.
+    """
+    if not np.issubdtype(dest_dtype, np.float32) and not np.issubdtype(
+        dest_dtype, np.float64
+    ):
+        raise ValueError(
+            f"Destination dtype must be a float32 or float64, "
+            f"but it is {dest_dtype}"
+        )
+
+    in_min = get_min_possible_int_value(src_dtype)
+    in_max = get_max_possible_int_value(src_dtype)
+    out_min = get_min_possible_int_value(dest_dtype)
+    out_max = get_max_possible_int_value(dest_dtype)
+    in_abs_max = max(in_max, abs(in_min))
+    out_abs_max = max(out_max, abs(out_min))
+
+    def unchanged(data: np.ndarray) -> np.ndarray:
+        return np.asarray(data)
+
+    def float_to_float_scale_down(data: np.ndarray) -> np.ndarray:
+        return ((np.asarray(data) / in_abs_max) * out_abs_max).astype(
+            dest_dtype
+        )
+
+    def int_to_float_scale_down(data: np.ndarray) -> np.ndarray:
+        # data must fit in float64
+        data = np.asarray(data).astype(np.float64)
+        return ((data / in_abs_max) * out_abs_max).astype(dest_dtype)
+
+    def to_float_unscaled(data: np.ndarray) -> np.ndarray:
+        return np.asarray(data).astype(dest_dtype)
+
+    if src_dtype == dest_dtype:
+        return unchanged
+
+    # out can hold the largest in values - just convert to float
+    if out_min <= in_min < in_max <= out_max:
+        return to_float_unscaled
+
+    # need to scale down before converting to float
+    if np.issubdtype(src_dtype, np.integer):
+        # if going to float32 and it didn't fit input must fit in 64-bit float
+        # so we can temp store it there to scale. If going to float64, same.
+        if in_max > get_max_possible_int_value(
+            np.float64
+        ) or in_min < get_min_possible_int_value(np.float64):
+            raise ValueError(
+                f"The input datatype {src_dtype} cannot fit in a "
+                f"64-bit float"
+            )
+        return int_to_float_scale_down
+
+    # for float input, however big it is, we can always scale it down in the
+    # input data type before changing type
+    return float_to_float_scale_down
 
 
 def union(a, b):

{cellfinder-1.3.3.dist-info → cellfinder-1.4.0a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cellfinder
-Version: 1.3.3
+Version: 1.4.0a0
 Summary: Automated 3D cell detection in large microscopy images
 Author-email: "Adam Tyson, Christian Niedworok, Charly Rousseau" <code@adamltyson.com>
 License: BSD-3-Clause
@@ -33,7 +33,7 @@ Requires-Dist: numpy
 Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
 Requires-Dist: keras==3.5.0
-Requires-Dist: torch>=2.1.0
+Requires-Dist: torch!=2.4,>=2.1.0
 Requires-Dist: tifffile
 Requires-Dist: tqdm
 Provides-Extra: dev
@@ -46,6 +46,7 @@ Requires-Dist: pytest-qt; extra == "dev"
 Requires-Dist: pytest-timeout; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: tox; extra == "dev"
+Requires-Dist: pooch>=1; extra == "dev"
 Provides-Extra: napari
 Requires-Dist: brainglobe-napari-io; extra == "napari"
 Requires-Dist: magicgui; extra == "napari"

{cellfinder-1.3.3.dist-info → cellfinder-1.4.0a0.dist-info}/RECORD

@@ -1,32 +1,33 @@
 cellfinder/__init__.py,sha256=S5oQ3EORuyQTMYC4uUuzGKZ23J3Ya6q-1DOBib1KfiA,1166
 cellfinder/cli_migration_warning.py,sha256=gPtNrtnXvWpl5q0k_EGAQZg0DwcpCmuBTgpg56n5NfA,1578
 cellfinder/core/__init__.py,sha256=pRFuQsl78HEK0S6gvhJw70QLbjjSBzP-GFO0AtVaGtk,62
-cellfinder/core/main.py,sha256=t2mkq6iieEytbPckehBB43juwN5E-vhzstLSs620vdM,3625
+cellfinder/core/main.py,sha256=QiLo8qtK6hRT_cu-xSP9k93EE-dZjmb2xxocsY-hTwU,3836
 cellfinder/core/types.py,sha256=lTqWE4v0SMM0qLAZJdyAzqV1nLgDtobEpglNJcXt160,106
 cellfinder/core/classify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/classify/augment.py,sha256=8dMbM7KhimM6NMgdMC53oHoCfYj1CIB-h3Yk8CZAxPw,6321
-cellfinder/core/classify/classify.py,sha256=uhvBGp3uFRp6uZeUtAIIS4BbIotQzZ_rql2zT_l-9Ok,3523
+cellfinder/core/classify/classify.py,sha256=UN5j4-5RlsKNt9wd1A8udCjW4t-D4MySEyQ9BIkCckI,3529
 cellfinder/core/classify/cube_generator.py,sha256=jC5aogTVy213PHouViSR9CgKkuOks3yk6csQC5kRoOE,17125
 cellfinder/core/classify/resnet.py,sha256=vGa85y_NcQnOXwAt5EtatLx5mrO8IoShCcNKtJ5-EFg,10034
 cellfinder/core/classify/tools.py,sha256=s5PEKAsZVbVuoferZ_nqMUM0f2bV_8WEKsdKe3SXEuE,2560
 cellfinder/core/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/config/cellfinder.conf,sha256=5i8axif7ekMutKDiVnZRs-LiJrgVQljg_beltidqtNk,56
 cellfinder/core/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/detect/detect.py,sha256=iEYaYuYCSR4VJXmlFbEE1ti9Pjpv6m4rSfFILSOYmhE,9592
+cellfinder/core/detect/detect.py,sha256=cd6D3XOzP5HEA_Hb3Ik4AVmNzu0im4sQxV46cCY6izU,8056
 cellfinder/core/detect/filters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/detect/filters/setup_filters.py,sha256=sUyZ2dKbfwhn4YTq3kLVTHkckZZ460AVozLfoz7hJK8,2084
+cellfinder/core/detect/filters/setup_filters.py,sha256=gvWhdGVdGrK_Ab-t0kKPnXaf43qLi78ed_-vNPI0nE4,14554
 cellfinder/core/detect/filters/plane/__init__.py,sha256=lybcPbVDnurEQeq2FiLq0zR8p_ztarQOlajhdh1Q2-4,40
-cellfinder/core/detect/filters/plane/classical_filter.py,sha256=Nton_nrvv6LhNlK10HnS0TIHsjapBiMJPURgzYh2myY,1331
-cellfinder/core/detect/filters/plane/plane_filter.py,sha256=PWcAHDKB3qn3i9aSmQzUTEi3tgmccrf24DipjnYbOg0,2746
-cellfinder/core/detect/filters/plane/tile_walker.py,sha256=lhKrq-MB35bR0_JYgj7WMR4otuaZ6XRDDhJhKyH1yS8,3001
+cellfinder/core/detect/filters/plane/classical_filter.py,sha256=X5k266tbl9EHRVY5dls53B5IZlmP7U0UB9BsZ1ey_pc,13250
+cellfinder/core/detect/filters/plane/plane_filter.py,sha256=6FbAjxgt39_RdGDXC_pQ9ndtZtknuHJeTWtbR8cReEA,6102
+cellfinder/core/detect/filters/plane/tile_walker.py,sha256=IiQibvWKnYlgl9h414fRklV7C2xZ0vXNmJ9t89DhYuI,4863
 cellfinder/core/detect/filters/volume/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellfinder/core/detect/filters/volume/ball_filter.py,sha256=ZEg8FNty-VD5N9j4FLZ18G-BuSvxjHs2-QTblwKcZgw,13894
-cellfinder/core/detect/filters/volume/structure_detection.py,sha256=mTHi0_A9FCK39I6fZm2dfMpDxIkfaidOIf6eCjTw-70,11307
-cellfinder/core/detect/filters/volume/structure_splitting.py,sha256=DnYcCkcdEaubzaWxbM7Ee8icyHq3dN8CcvZj_i0QvGM,7880
-cellfinder/core/detect/filters/volume/volume_filter.py,sha256=BJ8bStlNvMWsGlBekeqXpS8d9YKoLe3ifMfrEPpva2Q,7035
+cellfinder/core/detect/filters/volume/ball_filter.py,sha256=qIDo206f558B46tpxrOGXasP8VE6pZxju-duvhPRuNA,14440
+cellfinder/core/detect/filters/volume/structure_detection.py,sha256=AIHq-5u5VFpKBBLEsE1Py-MlndbL8T0zXu0Bq2CI16Y,12916
+cellfinder/core/detect/filters/volume/structure_splitting.py,sha256=0LGE8cQ6EJIsKqWWmd087Q3At8m-PUDmmPjCZKV1TdY,10138
+cellfinder/core/detect/filters/volume/volume_filter.py,sha256=o9_4IsITedhqkhfwRsIhE53_zLNcFjgQzXbMMddH_q4,20544
 cellfinder/core/download/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/download/cli.py,sha256=X9L9ZIkWqs58hX8G8q_0AKN4gk8BhydGxI9nLpdHQQE,1764
 cellfinder/core/download/download.py,sha256=YQP4NMM9Xt0rECRJEV5z6RCZNi5uCFhohFnDreH0qHA,3277
+cellfinder/core/tools/IO.py,sha256=jK1R_6YahQ_MbPlwg1IM-Fp-din-hLBNq71Jxn3q2WQ,1356
 cellfinder/core/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/tools/array_operations.py,sha256=LDbqWA_N2YtxeKS877QYdJRL2FCMC1R1ExJtdb6-vEA,3371
 cellfinder/core/tools/geometry.py,sha256=xlEQQmVQ9jcXqRzUqU554P8VxkaWkc5J_YhjkkKlI0Q,1124
@@ -34,8 +35,9 @@ cellfinder/core/tools/image_processing.py,sha256=z27bGjf3Iv3G4Nt1OYzpEnIYQNc4nNo
 cellfinder/core/tools/prep.py,sha256=YU4VDyjEsOXn3S3gymEfPUzka-WYiHmR4Q4XdRebhDI,2175
 cellfinder/core/tools/source_files.py,sha256=vvwsIMe1ULKvXg_x22L75iqvCyMjEbUjJsDFQk3GYzY,856
 cellfinder/core/tools/system.py,sha256=WvEzPr7v-ohLDnzf4n13TMcN5OYIAXOEkaSmrHzdnwc,2438
+cellfinder/core/tools/threading.py,sha256=EmDLF22ZvXJnsWg7g6sv4cZgNweC0YrVw2o7QXjrO9s,14094
 cellfinder/core/tools/tiff.py,sha256=NzIz6wq2GzxmcIhawFMwZADe-uQO2rIG46H7xkpGKLs,2899
-cellfinder/core/tools/tools.py,sha256=G8oDGNRuWkzEJDnnC4r3SNGgpVbqbelCZR5ODk9JRzs,4867
+cellfinder/core/tools/tools.py,sha256=opMGC5GBBsId0dmL8V0KQrI4U70w_D_KtGQYpZNeHYQ,9390
 cellfinder/core/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellfinder/core/train/train_yml.py,sha256=9QXv2wk24G8hYskMnBij7OngEELUWySK2fH4NFbYWw4,13260
 cellfinder/napari/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -51,9 +53,9 @@ cellfinder/napari/detect/thread_worker.py,sha256=PWM3OE-FpK-dpdhaE_Gi-2lD3u8sL-S
 cellfinder/napari/train/__init__.py,sha256=xo4CK-DvSecInGEc2ohcTgQYlH3iylFnGvKTCoq2WkI,35
 cellfinder/napari/train/train.py,sha256=zJY7zKcLqDTDtD76thmbwViEU4tTFCmXZze-zHsTpoo,5941
 cellfinder/napari/train/train_containers.py,sha256=1wZ_GPe7B5XsLYs5XIx4m8GMw5KeVhg6SchhPtXu4V8,4386
-cellfinder-1.3.3.dist-info/LICENSE,sha256=Tw8iMytIDXLSmcIUsbQmRWojstl9yOWsPCx6ZT6dZLY,1564
-cellfinder-1.3.3.dist-info/METADATA,sha256=27H5g4lHvr3tyLQNPD7H3OnqUN2Y_LZFNOB15M9gS5s,7074
-cellfinder-1.3.3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-cellfinder-1.3.3.dist-info/entry_points.txt,sha256=cKKjU8GPiN-TRelG2sT2JCKAcB9XDCjP6g9atE9pSoY,247
-cellfinder-1.3.3.dist-info/top_level.txt,sha256=jyTQzX-tDjbsMr6s-E71Oy0IKQzmHTXSk4ZhpG5EDSE,11
-cellfinder-1.3.3.dist-info/RECORD,,
+cellfinder-1.4.0a0.dist-info/LICENSE,sha256=Tw8iMytIDXLSmcIUsbQmRWojstl9yOWsPCx6ZT6dZLY,1564
+cellfinder-1.4.0a0.dist-info/METADATA,sha256=X5NbLqZZpyJC2_JDAEo03MHDAjgzYN7SJsh_x2vkS48,7122
+cellfinder-1.4.0a0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+cellfinder-1.4.0a0.dist-info/entry_points.txt,sha256=cKKjU8GPiN-TRelG2sT2JCKAcB9XDCjP6g9atE9pSoY,247
+cellfinder-1.4.0a0.dist-info/top_level.txt,sha256=jyTQzX-tDjbsMr6s-E71Oy0IKQzmHTXSk4ZhpG5EDSE,11
+cellfinder-1.4.0a0.dist-info/RECORD,,

{cellfinder-1.3.3.dist-info → cellfinder-1.4.0a0.dist-info}/WHEEL

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