cellprofiler-core-nightly 5.0.0.dev65__py3-none-any.whl

cellprofiler_core/__init__.py

@@ -0,0 +1 @@
+from cellprofiler_core._version import __version__

cellprofiler_core/__main__.py

@@ -0,0 +1,55 @@
+import os
+import pathlib
+
+import click
+
+import cellprofiler_core.commands
+
+CONTEXT_SETTINGS = dict(auto_envvar_prefix="COMPLEX")
+
+
+class Command(click.MultiCommand):
+    def get_command(self, context, name):
+        try:
+            name = f"cellprofiler_core.commands._{name}_command"
+
+            imported_module = __import__(name, None, None, ["command"])
+        except ImportError:
+            return
+
+        return imported_module.command
+
+    def list_commands(self, context):
+        command_names = []
+
+        commands_pathname = cellprofiler_core.commands.__file__
+
+        commands_directory = pathlib.Path(commands_pathname).parent
+
+        for filename in os.listdir(commands_directory):
+            if filename.endswith("_command.py") and filename.startswith("_"):
+                command_name = filename[1:-11]
+
+                command_names += [command_name]
+
+        command_names.sort()
+
+        return command_names
+
+
+class Environment:
+    def __init__(self):
+        pass
+
+
+pass_environment = click.make_pass_decorator(Environment, ensure=True)
+
+
+@click.command(cls=Command, context_settings=CONTEXT_SETTINGS)
+@pass_environment
+def main(context):
+    pass
+
+
+if __name__ == "__main__":
+    main({})

cellprofiler_core/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '5.0.0.dev65'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev65')

cellprofiler_core/analysis/__init__.py

@@ -0,0 +1,32 @@
+"""
+Run pipelines on imagesets to produce measurements.
+"""
+
+import sys
+
+
+use_analysis = True
+
+DEBUG = "DEBUG"
+ANNOUNCE_DONE = "DONE"
+
+
+###############################
+# Request, Replies, Events
+###############################
+
+
+if sys.platform == "darwin":
+    pass
+
+if __name__ == "__main__":
+    # This is an ugly hack, but it's necesary to unify the Request/Reply
+    # classes above, so that regardless of whether this is the current module,
+    # or a separately imported one, they see the same classes.
+    import cellprofiler_core.analysis
+    from ._runner import Runner
+
+    globals().update(cellprofiler_core.analysis.__dict__)
+
+    Runner.start_workers(2)
+    Runner.stop_workers()

cellprofiler_core/analysis/_analysis.py

@@ -0,0 +1,109 @@
+import gc
+import threading
+import uuid
+
+from ._runner import Runner
+from ..measurement import Measurements
+
+
+class Analysis:
+    """An Analysis is the application of a particular pipeline of modules to a
+    set of images to produce measurements.
+
+    Multiprocessing for analyses is handled by multiple layers of threads and
+    processes, to keep the GUI responsive and simplify the code.  Threads and
+    processes are organized as below.  Display/Interaction requests and
+    Exceptions are sent directly to the pipeline listener.
+
+    +------------------------------------------------+
+    |           CellProfiler GUI/WX thread           |
+    |                                                |
+    +- Analysis() methods down,  Events/Requests up -+
+    |                                                |
+    |       AnalysisRunner.interface() thread        |
+    |                                                |
+    +----------------  Queues  ----------------------+
+    |                                                |
+    |  AnalysisRunner.jobserver()/announce() threads |
+    |                                                |
+    +----------------------------------------------- +
+    |              zmqrequest.Boundary()             |
+    +---------------+----------------+---------------+
+    |     Worker    |     Worker     |   Worker      |
+    +---------------+----------------+---------------+
+
+    Workers are managed by class variables in the AnalysisRunner.
+    """
+
+    def __init__(self, pipeline, initial_measurements=None):
+        """create an Analysis applying pipeline to a set of images, writing out
+        to measurements_filename, optionally starting with previous
+        measurements."""
+        self.pipeline = pipeline
+        initial_measurements = Measurements(copy=initial_measurements)
+        self.initial_measurements_buf = initial_measurements.file_contents()
+        initial_measurements.close()
+        self.debug_mode = False
+        self.analysis_in_progress = False
+        self.runner = None
+
+        self.runner_lock = threading.Lock()  # defensive coding purposes
+
+    def start(self, analysis_event_callback, num_workers=None, overwrite=True):
+        """Start the analysis runner
+
+        analysis_event_callback - callback from runner to UI thread for
+                                  event progress and UI handlers
+
+        num_workers - # of worker processes to instantiate, default is # of cores
+
+        overwrite - True (default) to process all image sets, False to only
+                    process incomplete ones (or incomplete groups if grouping)
+        """
+        with self.runner_lock:
+            assert not self.analysis_in_progress
+            self.analysis_in_progress = uuid.uuid1().hex
+
+            self.runner = Runner(
+                self.analysis_in_progress,
+                self.pipeline,
+                self.initial_measurements_buf,
+                analysis_event_callback,
+            )
+            self.runner.start(num_workers=num_workers, overwrite=overwrite)
+            return self.analysis_in_progress
+
+    def pause(self):
+        with self.runner_lock:
+            assert self.analysis_in_progress
+            self.runner.pause()
+
+    def resume(self):
+        with self.runner_lock:
+            assert self.analysis_in_progress
+            self.runner.resume()
+
+    def cancel(self):
+        with self.runner_lock:
+            if not self.analysis_in_progress:
+                return
+            self.analysis_in_progress = False
+            self.runner.cancel()
+            self.runner = None
+            """
+            Explicitly call GC here so that the old runner's threads and 
+            queues get deleted before any new analysis can be started.
+            On rare occasions CP can hang when threads get GC'd during a run
+            """
+            gc.collect()
+
+    def check_running(self):
+        """Verify that an analysis is running, allowing the GUI to recover even
+        if the AnalysisRunner fails in some way.
+
+        Returns True if analysis is still running (threads are still alive).
+        """
+        with self.runner_lock:
+            if self.analysis_in_progress:
+                return self.runner.check()
+            return False