ceci 2.0__tar.gz → 2.1__tar.gz

{ceci-2.0 → ceci-2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ceci
-Version: 2.0
+Version: 2.1
 Summary: Lightweight pipeline engine for LSST DESC
 Author: Joe Zuntz
 License: BSD 3-Clause License

{ceci-2.0 → ceci-2.1}/ceci/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.0'
-__version_tuple__ = version_tuple = (2, 0)
+__version__ = version = '2.1'
+__version_tuple__ = version_tuple = (2, 1)

{ceci-2.0 → ceci-2.1}/ceci/minirunner.py

@@ -36,9 +36,10 @@ class TimeOut(RunnerError):
 class FailedJob(RunnerError):
     """Error for when a job has failed."""
 
-    def __init__(self, msg, job_name):
+    def __init__(self, msg, job_name, run_time):
         super().__init__(msg)
         self.job_name = job_name
+        self.run_time = run_time
 
 
 class Node:
@@ -145,6 +146,21 @@ def null_callback(
 ):  # pylint: disable=unused-argument,missing-function-docstring
     pass
 
+def make_run_time_string(seconds):
+    """Convert the time in seconds to a string of the form
+    "X days, Y hours, Z minutes, W seconds"
+    """
+    if seconds < 60:
+        return f"{seconds:.1f} seconds"
+    minutes, seconds = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes:.0f} minutes, {seconds:.1f} seconds"
+    hours, minutes = divmod(minutes, 60)
+    if hours < 24:
+        return f"{hours:.0f} hours, {minutes:.0f} minutes, {seconds:.1f} seconds"
+    days, hours = divmod(hours, 24)
+    return f"{days:.0f} days, {hours:.0f} hours, {minutes:.0f} minutes, {seconds:.1f} seconds"
+
 
 class Runner:
     """The main pipeline runner class.
@@ -245,7 +261,7 @@ class Runner:
 
     def abort(self):
         """End the pipeline and kill all running jobs."""
-        for process, _, _ in self.running:
+        for process, _, _, _ in self.running:
             process.kill()
 
         for node in self.nodes:
@@ -275,7 +291,7 @@ class Runner:
             p = subprocess.Popen(
                 cmd, shell=True, stdout=stdout, stderr=subprocess.STDOUT
             )  # pylint: disable=consider-using-with
-            self.running.append((p, job, alloc))
+            self.running.append((p, job, alloc, default_timer()))
             self.callback(
                 EVENT_LAUNCH,
                 {"job": job, "stdout": stdout_file, "process": p, "nodes": alloc},
@@ -337,12 +353,12 @@ class Runner:
         completed_jobs = []
         continuing_jobs = []
         # loop through all known running ones
-        for process, job, alloc in self.running:
+        for process, job, alloc, start_time in self.running:
             # check status
             status = process.poll()
             # None indicates job is still running
             if status is None:  # pragma: no cover
-                continuing_jobs.append((process, job, alloc))
+                continuing_jobs.append((process, job, alloc, start_time))
             # status !=0 indicates error in job.
             # kill everything
             elif status:
@@ -355,11 +371,13 @@ class Runner:
                     EVENT_FAIL,
                     {"job": job, "status": status, "process": process, "nodes": alloc},
                 )
+                fail_time = make_run_time_string(default_timer() - start_time)
                 self.abort()
-                raise FailedJob(job.cmd, job.name)
+                raise FailedJob(job.cmd, job.name, fail_time)
             # status==0 indicates sucess in job, so free resources
             else:
-                print(f"Job {job.name} has completed successfully!")
+                run_time = make_run_time_string(default_timer() - start_time)
+                print(f"Job {job.name} has completed successfully in {run_time} seconds !")
                 # Call back with info about the successful job and how it ran
                 self.callback(
                     EVENT_COMPLETED,

{ceci-2.0 → ceci-2.1}/ceci/pipeline.py

@@ -6,13 +6,18 @@ import graphlib
 import yaml
 import shutil
 from abc import abstractmethod
-import warnings
+import collections
 
 from .stage import PipelineStage
 from . import minirunner
 from .sites import load, get_default_site
 from .utils import embolden, extra_paths
 
+RESUME_MODE_RESUME = "resume"
+RESUME_MODE_RESTART = "restart"
+RESUME_MODE_REFUSE = "refuse"
+
+
 
 def override_config(config, extra):
     """Override configuration parameters with extra parameters provided on command line
@@ -185,16 +190,7 @@ class StageExecutionConfig:
             self.stage_class = PipelineStage.get_stage(
                 self.class_name, self.module_name
             )
-        # EAC.  Ideally we would just pass the aliases into the c'tor of self.stage_class(),
-        # but that would requiring changing the signature of every sub-class, so we do this
-        # instead.  At some point we might want to migrate to doing it the better way
-        try:
-            self.stage_obj = self.stage_class(args, aliases=self.aliases)
-        except TypeError:
-            self.stage_obj = self.stage_class(args)
-            self.stage_obj._aliases.update(**self.aliases)
-            self.stage_obj._io_checked = False
-            self.stage_obj.check_io()
+        self.stage_obj = self.stage_class(args, aliases=self.aliases)
         return self.stage_obj
 
     def generate_full_command(self, inputs, outputs, config):
@@ -373,11 +369,16 @@ class Pipeline:
         run_config = {
             "output_dir": pipe_config.get("output_dir", "."),
             "log_dir": pipe_config.get("log_dir", "."),
-            "resume": pipe_config.get("resume", False),
+            "resume": pipe_config.get("resume", RESUME_MODE_RESUME),
             "flow_chart": pipe_config.get("flow_chart", ""),
             "registry": pipe_config.get("registry", None),
         }
 
+        if run_config["resume"] is True:
+            run_config["resume"] = RESUME_MODE_RESUME
+        elif run_config["resume"] is False:
+            run_config["resume"] = RESUME_MODE_RESTART
+
         launcher_dict = dict(cwl=CWLPipeline, parsl=ParslPipeline, mini=MiniPipeline)
 
         if pipe_config.get("flow_chart", False):
@@ -674,9 +675,11 @@ class Pipeline:
         `Pipeline.pipeline_files` data member, so that they are available to later stages
         """
         kwcopy = kwargs.copy()
+        aliases = kwcopy.pop("aliases", {})
+        comm = kwcopy.pop("comm", None)
         kwcopy.update(**self.pipeline_files)
-        aliases = kwcopy.pop("aliases", None)
-        stage = stage_class(kwcopy, aliases=aliases)
+
+        stage = stage_class(kwcopy, comm=comm, aliases=aliases)
         return self.add_stage(stage)
 
     def remove_stage(self, name):
@@ -827,7 +830,9 @@ class Pipeline:
             # In interactive use the stage object might already be created
             # otherwise we need to create it
             if sec.stage_obj is not None:
+                orig_stage_config = stages_config_data.get(stage_name, {}).copy()
                 stage = sec.stage_obj
+                stage.config.update(**orig_stage_config)
             else:
                 # Find the inputs for this stage and set up the arguments
                 # to the stage init method
@@ -956,7 +961,24 @@ class Pipeline:
 
     def should_skip_stage(self, stage):
         """Return true if we should skip a stage because it is finished and we are in resume mode"""
-        return stage.should_skip(self.run_config)
+        resume_mode = self.run_config["resume"]
+        if resume_mode is True:
+            resume_mode = "resume"
+        elif resume_mode is False:
+            resume_mode = "restart"
+
+        if resume_mode == "restart":
+            return False
+
+        outputs = stage.find_outputs(self.run_config["output_dir"]).values()
+
+        if resume_mode == "resume":
+            return all(os.path.exists(output) for output in outputs)
+        elif resume_mode == "refuse":
+            if any(os.path.exists(output) for output in outputs):
+                raise RuntimeError(f"Output files already exist for stage {stage} and resume mode is 'refuse'")
+        else:
+            raise ValueError(f"Unknown resume mode: {resume_mode}")
 
     def save(self, pipefile, stagefile=None, reduce_config=False, **kwargs):
         """Save this pipeline state to a yaml file
@@ -1046,6 +1068,10 @@ class Pipeline:
         # Nodes we have already added
         seen = set()
 
+        # Dictionary to track nodes by their inputs and outputs
+        node_groups = {}
+
+
         # Add overall pipeline inputs
         for inp in self.overall_inputs.keys():
             graph.add_node(inp, shape="box", color="gold", style="filled")
@@ -1071,6 +1097,43 @@ class Pipeline:
                     seen.add(out)
                 graph.add_edge(stage.instance_name, out, color="black")
 
+        # We want to group together all the files that all created
+        # by the same stage and also all used by the same stages, to
+        # reduce the number of nodes in the graph and make it more readable.
+        # First we find that grouping.
+        node_groups = collections.defaultdict(list)
+        for node in graph.nodes_iter():
+            # only affect the nodes representing files
+            if node.attr['color'] != "skyblue":
+                continue
+            # Find the stage node that created this file,
+            # and all the stage nodes that make use of it
+            edge_in = graph.in_edges(node)[0]
+            creator = edge_in[0]
+            users = []
+            for edge in graph.out_edges(node):
+                users.append(edge[1])
+            key = (creator, tuple(users))
+            node_groups[key].append(node)
+
+        # Now we remove all the groups of nodes with more than one in
+        # and replace them with a single node
+        for key, nodes in node_groups.items():
+            if len(nodes) > 1:
+                if len(nodes) > 4:
+                    # make a string with two nodes per line
+                    node_names = []
+                    for i in range(0, len(nodes), 2):
+                        node_names.append(",  ".join(nodes[i:i+2]))
+                    new_node = "\n".join(node_names)
+                else:
+                    new_node = "\n".join(nodes)
+                graph.remove_nodes_from(nodes)
+                graph.add_node(new_node, shape="box", color="skyblue", style="filled")
+                graph.add_edge(key[0], new_node, color="black")
+                for user in key[1]:
+                    graph.add_edge(new_node, user, color="black")
+
         # finally, output the stage to file
         if filename.endswith(".dot"):
             graph.write(filename)
@@ -1439,6 +1502,7 @@ class MiniPipeline(Pipeline):
                 f"""
 *************************************************
 Error running pipeline stage {error.job_name}.
+Failed after {error.run_time}.
 
 Standard output and error streams in {log_dir}/{error.job_name}.out
 *************************************************

{ceci-2.0 → ceci-2.1}/ceci/stage.py

@@ -8,11 +8,14 @@ import shutil
 import cProfile
 import pdb
 import datetime
+import warnings
+import socket
 
 from abc import abstractmethod
 from . import errors
 from .monitor import MemoryMonitor
 from .config import StageParameter, StageConfig, cast_to_streamable
+from .utils import activate_tracing
 
 SERIAL = "serial"
 MPI_PARALLEL = "mpi"
@@ -102,6 +105,8 @@ class PipelineStage:
         if comm is not None:
             self.setup_mpi(comm)
 
+        self.check_io()
+
 
     @classmethod
     def make_stage(cls, **kwargs):
@@ -117,13 +122,7 @@ class PipelineStage:
             for output_ in cls.outputs:  # pylint: disable=no-member
                 outtag = output_[0]
                 aliases[outtag] = f"{outtag}_{name}"
-        # EAC.  Ideally we would just pass the aliases into the construction call
-        # but that would requiring changing the signature of every sub-class, so we do this
-        # instead.  At some point we might want to migrate to doing it the better way
-        stage = cls(kwcopy, comm=comm)
-        stage._aliases.update(**aliases)
-        stage._io_checked = False
-        stage.check_io()
+        stage = cls(kwcopy, comm=comm, aliases=aliases)
         return stage
 
     def get_aliases(self):
@@ -149,8 +148,18 @@ class PipelineStage:
 
     @abstractmethod
     def run(self):  # pragma: no cover
-        """Run the stage and return the execution status"""
+        """Run the stage and return the execution status.
+
+        Subclasses must implemented this method.
+        """
         raise NotImplementedError("run")
+    
+    def validate(self):
+        """Check that the inputs actually have the data needed for execution,
+        This is called before the run method. It is an optional stage, meant
+        for checking that the input to the stage is actual in the form and
+        shape needed before an expensive run is executed."""
+        pass 
 
     def load_configs(self, args):
         """
@@ -181,7 +190,6 @@ class PipelineStage:
             error_class = type(error)
             msg = str(error)
             raise error_class(f"Error configuring {self.instance_name}: {msg}")
-        self.check_io(args)
 
     def check_io(self, args=None):
         """
@@ -344,7 +352,8 @@ class PipelineStage:
         path = pathlib.Path(filename).resolve()
 
         # Add a description of the parameters to the end of the docstring
-        if stage_is_complete:
+        # If no config options are specified, omit this.
+        if stage_is_complete and cls.config_options:
             config_text = cls._describe_configuration_text()
             if cls.__doc__ is None:
                 cls.__doc__ = f"Stage {cls.name}\n\nConfiguration Parameters:\n{config_text}"
@@ -607,6 +616,12 @@ I currently know about these stages:
             help="Report memory use. Argument gives interval in seconds between reports",
         )
 
+        parser.add_argument(
+            "--trace",
+            action="store_true",
+            help="Enable sending a signal to the process that prints a trace wherever it is",
+        )
+
         # Error message we will return if --mpi used on a non-supported
         # stage.
         mpi_err = (
@@ -665,6 +680,21 @@ I currently know about these stages:
         if args.memmon:  # pragma: no cover
             monitor = MemoryMonitor.start_in_thread(interval=args.memmon)
 
+        if args.trace:
+            activate_tracing(stage._rank)
+
+        # Now we try to see if the validation step has been changed,
+        # if it has then we will run the validation step, and raise any errors
+        try:
+            stage.validate()
+        except Exception as error:
+            if stage.rank==0:
+                print(f"Looks like there is an validation error in: {cls.name}",
+                        "the input data for this stage did not pass the checks implemented on it.")
+                print(error)
+            raise
+
+
         try:
             stage.run()
         except Exception as error:  # pragma: no cover
@@ -785,13 +815,24 @@ I currently know about these stages:
 
     def is_mpi(self):
         """
-        Returns True if the stage is being run under MPI.
+        Check if the stage is being run under MPI.
+
+        Returns
+        -------
+        bool
+            True if the stage is being run under MPI
         """
         return self._parallel == MPI_PARALLEL
 
     def is_dask(self):
         """
-        Returns True if the stage is being run in parallel with Dask.
+        Check if the stage is being run in parallel with Dask.
+
+        Returns
+        -------
+        bool
+            True if the stage is being run under MPI
+        
         """
         return self._parallel == DASK_PARALLEL
 
@@ -942,6 +983,11 @@ I currently know about these stages:
         Parallel: bool
             Whether to split data by rank or just give all procs all data.
             Default=True
+
+        Returns
+        -------
+        start, end: tuple
+            The start and end of the range of rows to be read by this process    
         """
         n_chunks = n_rows // chunk_rows
         if n_chunks * chunk_rows < n_rows:  # pragma: no cover
@@ -963,6 +1009,17 @@ I currently know about these stages:
         """
         Return the path of an input file with the given tag,
         which can be aliased.
+
+        Parameters
+        ----------
+        tag: str
+            Tag as listed in self.outputs
+
+        Returns
+        -------
+        path: str
+            The path to the output file
+        
         """
         tag = self.get_aliased_tag(tag)
         return self._inputs[tag]
@@ -975,7 +1032,21 @@ I currently know about these stages:
         which can be aliased already.
 
         If final_name is False then use a temporary name - file will
-        be moved to its final name at the end
+        be moved to its final name at the end. The temporary name
+        is prefixed with `inprogress_`.
+
+        Parameters
+        ----------
+        tag: str
+            Tag as listed in self.outputs
+
+        final_name: bool
+            Default=False. Whether to save to the final name.
+
+        Returns
+        -------
+        path: str
+            The path to the output file
         """
 
         tag = self.get_aliased_tag(tag)
@@ -998,6 +1069,21 @@ I currently know about these stages:
         For specialized file types like FITS or HDF5 it will return
         a more specific object - see the types.py file for more info.
 
+        Parameters
+        ----------
+        tag: str
+            Tag as listed in self.inputs
+
+        wrapper: bool
+            Whether to return an underlying file object (False) or a data type instance (True)
+
+        **kwargs: dict
+            Extra arguments to pass to the file class constructor
+
+        Returns
+        -------
+        obj: file or object
+            The opened file or object
         """
         path = self.get_input(tag)
         input_class = self.get_input_type(tag)
@@ -1014,7 +1100,7 @@ I currently know about these stages:
         Find and open an output file with the given tag, in write mode.
 
         If final_name is True then they will be opened using their final
-        target output name.  Otherwise we will prepend "inprogress_" to their
+        target output name.  Otherwise we will prepend `inprogress_` to their
         file name. This means we know that if the final file exists then it
         is completed.
 
@@ -1025,12 +1111,11 @@ I currently know about these stages:
 
         Parameters
         ----------
-
         tag: str
             Tag as listed in self.outputs
 
         wrapper: bool
-            Default=False.  Whether to return a wrapped file
+            Whether to return an underlying file object (False) or a data type instance (True)
 
         final_name: bool
             Default=False. Whether to save to
@@ -1038,6 +1123,10 @@ I currently know about these stages:
         **kwargs:
             Extra args are passed on to the file's class constructor.
 
+        Returns
+        -------
+        obj: file or object
+            The opened file or object
         """
         path = self.get_output(tag, final_name=final_name)
         output_class = self.get_output_type(tag)
@@ -1082,33 +1171,63 @@ I currently know about these stages:
     @classmethod
     def inputs_(cls):
         """
-        Return the dict of inputs
+        Return the dict mapping input tags to file names.
+
+        Returns
+        -------
+        in_dict : dict[str:str]
         """
         return cls.inputs  # pylint: disable=no-member
 
     @classmethod
     def outputs_(cls):
         """
-        Return the dict of inputs
+        Return the dict mapping output tags to file names.
+
+        Returns
+        -------
+        out_dict : dict[str:str]
         """
         return cls.outputs  # pylint: disable=no-member
 
     @classmethod
     def output_tags(cls):
         """
-        Return the list of output tags required by this stage
+        Return the list of output tags required by this stage.
+
+        Returns
+        -------
+        out_tags : list[str]
+            The list of output tags
         """
         return [tag for tag, _ in cls.outputs_()]
 
     @classmethod
     def input_tags(cls):
         """
-        Return the list of input tags required by this stage
+        Return the list of input tags required by this stage.
+
+        Returns
+        -------
+        in_tags : list[str]
+            The list of input tags
         """
         return [tag for tag, _ in cls.inputs_()]
 
     def get_input_type(self, tag):
-        """Return the file type class of an input file with the given tag."""
+        """
+        Return the file type class of an input file with the given tag.
+
+        Parameters
+        ----------
+        tag : str
+            The tag of the input file
+
+        Returns
+        -------
+        ftype : FileType
+            The file type class
+        """
         tag = self.get_aliased_tag(tag)
         for t, dt in self.inputs_():
             t = self.get_aliased_tag(t)
@@ -1117,7 +1236,19 @@ I currently know about these stages:
         raise ValueError(f"Tag {tag} is not a known input")  # pragma: no cover
 
     def get_output_type(self, tag):
-        """Return the file type class of an output file with the given tag."""
+        """
+        Return the file type class of an output file with the given tag.
+
+        Parameters
+        ----------
+        tag : str
+            The tag of the output file
+
+        Returns
+        -------
+        ftype : FileType
+            The file type class
+        """
         tag = self.get_aliased_tag(tag)
         for t, dt in self.outputs_():
             t = self.get_aliased_tag(t)
@@ -1137,8 +1268,12 @@ I currently know about these stages:
     @property
     def config(self):
         """
-        Returns the configuration dictionary for this stage, aggregating command
+        The configuration dictionary for this stage, aggregating command
         line options and optional configuration file.
+
+        Options specified in the subclass variable `config_options` are
+        read from the configuration file, command line, or `make_stage` choices,
+        and stored in this dictionary.
         """
         return self._configs
 
@@ -1256,12 +1391,6 @@ I currently know about these stages:
                 f"{tag:20} : {aliased_tag:20} :{str(ftype):20} : {self._outputs[aliased_tag]}\n"
             )
 
-    def should_skip(self, run_config):
-        """Return true if we should skip a stage b/c it's outputs already exist and we are in resume mode"""
-        outputs = self.find_outputs(run_config["output_dir"]).values()
-        already_run_stage = all(os.path.exists(output) for output in outputs)
-        return already_run_stage and run_config["resume"]
-
     def already_finished(self):
         """Print a warning that a stage is being skipped"""
         print(f"Skipping stage {self.instance_name} because its outputs exist already")
@@ -1273,6 +1402,7 @@ I currently know about these stages:
         Loop through chunks of the input data from a FITS file with the given tag
 
         TODO: add ceci tests of this functions
+
         Parameters
         ----------
         tag: str
@@ -1361,6 +1491,59 @@ I currently know about these stages:
             data = {col: group[col][start:end] for col in cols}
             yield start, end, data
 
+    def combined_iterators(self, rows, *inputs, parallel=True):
+        """
+        Iterate through multiple files at the same time.
+
+        If you have more several HDF files with the some
+        columns of the same length then you can use this method to
+        iterate through them all at once, and combine the data from
+        all of them into a single dictionary.
+
+        Parameters
+        ----------
+        rows: int
+            The number of rows to read in each chunk
+
+        *inputs: list
+            A list of (tag, group, cols) triples for each file to read.
+            In each case tag is the input file name tag, group is the
+            group within the HDF5 file to read, and cols is a list of
+            columns to read from that group.  Specify multiple triplets
+            to read from multiple files
+
+        parallel: bool
+            Whether to split up data among processes (parallel=True) or give
+            all processes all data (parallel=False).  Default = True.
+
+        Returns
+        -------
+        it: iterator
+            Iterator yielding (int, int, dict) tuples of (start, end, data)
+        """
+        if not len(inputs) % 3 == 0:
+            raise ValueError(
+                "Arguments to combined_iterators should be in threes: "
+                "tag, group, value"
+            )
+        n = len(inputs) // 3
+
+        iterators = []
+        for i in range(n):
+            tag = inputs[3 * i]
+            section = inputs[3 * i + 1]
+            cols = inputs[3 * i + 2]
+            iterators.append(
+                self.iterate_hdf(tag, section, cols, rows, parallel=parallel)
+            )
+
+        for it in zip(*iterators):
+            data = {}
+            for (s, e, d) in it:
+                data.update(d)
+            yield s, e, data
+
+
     ################################
     # Pipeline-related methods
     ################################
@@ -1560,3 +1743,52 @@ I currently know about these stages:
         # cwl_tool.metadata = cwlgen.Metadata(**metadata)
 
         return cwl_tool
+
+
+    def time_stamp(self, tag):
+        """
+        Print a time stamp with an optional tag.
+
+        Parameters
+        ----------
+        tag: str
+            Additional info to print in the output line. Default is empty.
+        """
+        t = datetime.datetime.now()
+        print(f"Process {self.rank}: {tag} {t}")
+        sys.stdout.flush()
+
+    def memory_report(self, tag=None):
+        """
+        Print a report about memory currently available
+        on the node the process is running on.
+
+        Parameters
+        ----------
+        tag: str
+            Additional info to print in the output line. Default is empty.
+        """
+        import psutil
+
+        t = datetime.datetime.now()
+
+        # The different types of memory are really fiddly and don't
+        # correspond to how you usually imagine. The simplest thing
+        # to report here is just how much memory is left on the machine.
+        mem = psutil.virtual_memory()
+        avail = mem.available / 1024**3
+        total = mem.total / 1024**3
+
+        if tag is None:
+            tag = ""
+        else:
+            tag = f" {tag}:"
+
+        # This gives you the name of the host.  At NERSC that is the node name
+        host = socket.gethostname()
+
+        # Print messsage
+        print(
+            f"{t}: Process {self.rank}:{tag} Remaining memory on {host} {avail:.1f} GB / {total:.1f} GB"
+        )
+        sys.stdout.flush()

{ceci-2.0 → ceci-2.1}/ceci/update_pipelines_for_ceci_2.py

@@ -77,7 +77,8 @@ def update_pipeline_file_group(pipeline_files):
 def scan_directory_and_update(base_dir):
     groups = collections.defaultdict(list)
     yaml = ruamel.yaml.YAML()
-    for dirpath, subdirs, filenames in os.walk(base_dir):
+    yaml.allow_duplicate_keys = True
+    for dirpath, _, filenames in os.walk(base_dir):
         # just process yaml files
         for filename in filenames:
             if not (filename.endswith(".yaml") or filename.endswith(".yml")):
@@ -85,7 +86,11 @@ def scan_directory_and_update(base_dir):
             filepath = os.path.join(dirpath, filename)
             with open(filepath) as f:
                 yaml_str = f.read()
-            info = yaml.load(yaml_str)
+            try:
+                info = yaml.load(yaml_str)
+            except:
+                print("# Could not read yaml file:", filepath)
+                continue
 
             if is_pipeline_file(info):
                 config = info["config"]

{ceci-2.0 → ceci-2.1}/ceci/utils.py

@@ -3,6 +3,8 @@
 from contextlib import contextmanager
 import sys
 import os
+import signal
+import faulthandler
 
 
 def add_python_path(path, start):
@@ -107,3 +109,9 @@ def embolden(text):
         Emboldened text
     """
     return "\033[1m" + text + "\033[0m"
+
+
+def activate_tracing(rank):
+    pid = os.getpid()
+    print(f"Activating trace mode for process {rank}. Trigger trace using command: kill -s {signal.SIGUSR1} {pid}")
+    faulthandler.register(signal.SIGUSR1)

{ceci-2.0 → ceci-2.1}/ceci.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ceci
-Version: 2.0
+Version: 2.1
 Summary: Lightweight pipeline engine for LSST DESC
 Author: Joe Zuntz
 License: BSD 3-Clause License

{ceci-2.0 → ceci-2.1}/tests/test_interactive.py

@@ -137,4 +137,3 @@ def test_inter_pipe():
 
 if __name__ == "__main__":
     test_config()
-    test_interactive()

{ceci-2.0 → ceci-2.1}/tests/test_pipeline.py

@@ -130,7 +130,7 @@ class FailingStage(PipelineStage):
 
 
 def _return_value_test_(resume):
-    expected_status = 0 if resume else 1
+    expected_status = 0 if ((resume == "resume") or (resume is True)) else 1
     # Mini pipeline should not run
     launcher_config = {"interval": 0.5, "name": "mini"}
     run_config = {
@@ -159,10 +159,28 @@ def _return_value_test_(resume):
 
 def test_resume():
     _return_value_test_(True)
+    _return_value_test_("resume")
 
 
 def test_fail():
     _return_value_test_(False)
+    _return_value_test_("restart")
+
+def test_refuse():
+    launcher_config = {"interval": 0.5, "name": "mini"}
+    run_config = {
+        "log_dir": "./tests/logs",
+        "output_dir": "./tests/inputs",
+        "resume": "refuse",
+    }
+
+    pipeline = MiniPipeline([{"name": "FailingStage"}], launcher_config)
+
+    with pytest.raises(RuntimeError) as excinfo:
+        pipeline.initialize({}, run_config, "tests/config.yml")
+        pipeline.run()
+
+    assert "Output files already exist for stage" in str(excinfo.value)
 
 
 def test_dry_run(mocker):

{ceci-2.0 → ceci-2.1}/tests/test_stage.py

@@ -5,8 +5,12 @@ import numpy as np
 from ceci.errors import *
 import pytest
 import h5py
+import sys
 import os
-
+import tempfile
+import time
+import subprocess
+import signal
 # TODO: test MPI facilities properly with:
 # https://github.com/rmjarvis/TreeCorr/blob/releases/4.1/tests/mock_mpi.py
 
@@ -568,9 +572,79 @@ def test_wrong_mpi_flag():
     with pytest.raises(ValueError):
         assert LimaSerial.parse_command_line(["LimaSerial", "--mpi"]).mpi
 
+@pytest.mark.skipif(os.environ.get("GITHUB_ACTIONS") == "true", reason="Doesn't work on github actions")
+def test_tracing():
+    with open("mike_stage.py", "w") as f:
+        f.write("""
+import ceci
+import time
+class Mike(ceci.PipelineStage):
+    name = "Mike"
+    inputs = []
+    outputs = []
+    config_options = {}
+
+    def run(self):
+        time.sleep(6)
+        print("Mike complete")
 
-# could add more tests here for constructor, but the regression tests here and in TXPipe are
-# pretty thorough.
+if __name__ == "__main__":
+    ceci.PipelineStage.main()
+""")
+    with open("config.yml", "w") as f:
+        f.write("{}")
+
+    cmd = f"{sys.executable} mike_stage.py Mike --config config.yml --trace"
+    p1 = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    time.sleep(1)
+    p1.send_signal(signal.SIGUSR1)
+    try:
+        outs, _ = p1.communicate(timeout=15)
+    except subprocess.TimeoutExpired:
+        p1.kill()
+        outs, _ = p1.communicate()
+        raise ValueError("Timeout expired in Mike test with outs =" + outs.decode())
+    assert 'mike_stage.py", line 15' in outs.decode()
+
+
+def test_combined_iterators():
+    class Oscar(PipelineStage):
+        inputs = [("inp1", HDFFile), ("inp2", HDFFile)]
+        outputs = []
+        config_options = {}
+        def run(self):
+            it = self.combined_iterators(
+                10,
+                "inp1", "group1", ["x"], 
+                "inp2", "group1", ["y", "z"])
+            for (s, e, data) in it:
+                pass
+        
+    oo = Oscar.make_stage(inp1="tests/test.hdf5", inp2="tests/test.hdf5")
+    oo.run()
+
+
+def test_memory_and_time_reports(capsys):
+    class November(PipelineStage):
+        name = f"November"
+        parallel = False
+        inputs = []
+        outputs = []
+        config_options = {}
+
+        def run(self):
+            self.memory_report()
+            self.memory_report("TAGTAG")
+            self.time_stamp("Hello")
+
+    
+    nn = November.make_stage()
+    nn.run()
+    captured = capsys.readouterr()
+    assert "Remaining memory on" in captured.out
+    assert "TAGTAG" in captured.out
+    assert "Process 0: Hello" in captured.out
+    
 
 if __name__ == "__main__":
     test_construct()