runem 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

runem/command_line.py

@@ -5,6 +5,7 @@ import sys
 import typing
 
 from runem.config_metadata import ConfigMetadata
+from runem.log import log
 from runem.types import JobNames, OptionConfig, Options
 from runem.utils import printable_set
 
@@ -146,7 +147,7 @@ def parse_args(
 
     args = parser.parse_args(argv[1:])
 
-    options: Options = _initialise_options(config_metadata, args)
+    options: Options = initialise_options(config_metadata, args)
 
     if not _validate_filters(config_metadata, args):
         sys.exit(1)
@@ -176,7 +177,7 @@ def _validate_filters(
     for name, name_list in (("--jobs", args.jobs), ("--not-jobs", args.jobs_excluded)):
         for job_name in name_list:
             if job_name not in config_metadata.all_job_names:
-                print(
+                log(
                     (
                         f"ERROR: invalid job-name '{job_name}' for {name}, "
                         f"choose from one of {printable_set(config_metadata.all_job_names)}"
@@ -188,7 +189,7 @@ def _validate_filters(
     for name, tag_list in (("--tags", args.tags), ("--not-tags", args.tags_excluded)):
         for tag in tag_list:
             if tag not in config_metadata.all_job_tags:
-                print(
+                log(
                     (
                         f"ERROR: invalid tag '{tag}' for {name}, "
                         f"choose from one of {printable_set(config_metadata.all_job_tags)}"
@@ -203,7 +204,7 @@ def _validate_filters(
     ):
         for phase in phase_list:
             if phase not in config_metadata.all_job_phases:
-                print(
+                log(
                     (
                         f"ERROR: invalid phase '{phase}' for {name}, "
                         f"choose from one of {printable_set(config_metadata.all_job_phases)}"
@@ -213,7 +214,7 @@ def _validate_filters(
     return True
 
 
-def _initialise_options(
+def initialise_options(
     config_metadata: ConfigMetadata,
     args: argparse.Namespace,
 ) -> Options:
@@ -226,7 +227,7 @@ def _initialise_options(
         option["name"]: option["default"] for option in config_metadata.options_config
     }
     if config_metadata.options_config and args.overrides_on:  # pragma: no branch
-        for option_name in args.overrides_on:
+        for option_name in args.overrides_on:  # pragma: no branch
             options[option_name] = True
     if config_metadata.options_config and args.overrides_off:  # pragma: no branch
         for option_name in args.overrides_off:

runem/config.py

@@ -4,6 +4,7 @@ import typing
 
 import yaml
 
+from runem.log import log
 from runem.types import Config
 
 CFG_FILE_YAML = pathlib.Path(".runem.yml")
@@ -47,7 +48,7 @@ def _find_cfg() -> pathlib.Path:
         return cfg_candidate
 
     # error out and exit as we currently require the cfg file as it lists jobs.
-    print(f"ERROR: Config not found! Looked from {start_dirs}")
+    log(f"ERROR: Config not found! Looked from {start_dirs}")
     sys.exit(1)
 
 

runem/config_parse.py

@@ -4,7 +4,8 @@ import typing
 from collections import defaultdict
 
 from runem.config_metadata import ConfigMetadata
-from runem.job_function_python import get_job_function
+from runem.job_wrapper_python import get_job_wrapper
+from runem.log import log
 from runem.types import (
     Config,
     ConfigNodes,
@@ -73,12 +74,12 @@ def parse_job_config(
     try:
         job_names_used = job["label"] in in_out_job_names
         if job_names_used:
-            print("ERROR: duplicate job label!")
-            print(f"\t'{job['label']}' is used twice or more in {str(cfg_filepath)}")
+            log("ERROR: duplicate job label!")
+            log(f"\t'{job['label']}' is used twice or more in {str(cfg_filepath)}")
             sys.exit(1)
 
         # try and load the function _before_ we schedule it's execution
-        get_job_function(job, cfg_filepath)
+        get_job_wrapper(job, cfg_filepath)
         phase_id: PhaseName = job["when"]["phase"]
         in_out_jobs_by_phase[phase_id].append(job)
 
@@ -138,7 +139,7 @@ def parse_config(config: Config, cfg_filepath: pathlib.Path) -> ConfigMetadata:
         )
 
     if not phase_order:
-        print("WARNING: phase ordering not configured! Runs will be non-deterministic!")
+        log("WARNING: phase ordering not configured! Runs will be non-deterministic!")
         phase_order = tuple(job_phases)
 
     # tags = tags.union(("python", "es", "firebase_funcs"))

runem/{job_runner.py → job_execute.py}

@@ -2,15 +2,17 @@ import inspect
 import os
 import pathlib
 import typing
+import uuid
 from datetime import timedelta
 from timeit import default_timer as timer
 
 from runem.config_metadata import ConfigMetadata
-from runem.job_function_python import get_job_function
+from runem.job_wrapper_python import get_job_wrapper
+from runem.log import log
 from runem.types import FilePathList, FilePathListLookup, JobConfig, JobReturn, JobTags
 
 
-def job_runner_inner(
+def job_execute_inner(
     job_config: JobConfig,
     config_metadata: ConfigMetadata,
     file_lists: FilePathListLookup,
@@ -21,12 +23,12 @@ def job_runner_inner(
     """
     label = job_config["label"]
     if config_metadata.args.verbose:
-        print(f"START: {label}")
+        log(f"START: {label}")
     root_path: pathlib.Path = config_metadata.cfg_filepath.parent
     function: typing.Callable
     job_tags: JobTags = set(job_config["when"]["tags"])
     os.chdir(root_path)
-    function = get_job_function(job_config, config_metadata.cfg_filepath)
+    function = get_job_wrapper(job_config, config_metadata.cfg_filepath)
 
     # get the files for all files found for this job's tags
     file_list: FilePathList = []
@@ -36,7 +38,7 @@ def job_runner_inner(
 
     if not file_list:
         # no files to work on
-        print(f"WARNING: skipping job '{label}', no files for job")
+        log(f"WARNING: skipping job '{label}', no files for job")
         return (f"{label}: no files!", timedelta(0)), None
 
     if (
@@ -52,7 +54,7 @@ def job_runner_inner(
     start = timer()
     func_signature = inspect.signature(function)
     if config_metadata.args.verbose:
-        print(f"job: running {job_config['label']}")
+        log(f"job: running {job_config['label']}")
     reports: JobReturn
     if "args" in func_signature.parameters:
         reports = function(config_metadata.args, config_metadata.options, file_list)
@@ -68,18 +70,23 @@ def job_runner_inner(
     end = timer()
     time_taken: timedelta = timedelta(seconds=end - start)
     if config_metadata.args.verbose:
-        print(f"DONE: {label}: {time_taken}")
+        log(f"DONE: {label}: {time_taken}")
     timing_data = (label, time_taken)
     return (timing_data, reports)
 
 
-def job_runner(
+def job_execute(
     job_config: JobConfig,
+    running_jobs: typing.Dict[str, str],
     config_metadata: ConfigMetadata,
     file_lists: FilePathListLookup,
 ) -> typing.Tuple[typing.Tuple[str, timedelta], JobReturn]:
-    """Thing wrapper around job_runner_inner needed fro mocking in tests.
+    """Thin-wrapper around job_execute_inner needed for mocking in tests.
 
     Needed for faster tests.
     """
-    return job_runner_inner(job_config, config_metadata, file_lists)
+    this_id: str = str(uuid.uuid4())
+    running_jobs[this_id] = job_config["label"]
+    results = job_execute_inner(job_config, config_metadata, file_lists)
+    del running_jobs[this_id]
+    return results

runem/job_filter.py

@@ -2,6 +2,7 @@ import typing
 from collections import defaultdict
 
 from runem.config_metadata import ConfigMetadata
+from runem.log import log
 from runem.types import (
     JobConfig,
     JobNames,
@@ -30,7 +31,7 @@ def _get_jobs_matching(
         matching_tags = job_tags.intersection(tags)
         if not matching_tags:
             if verbose:
-                print(
+                log(
                     (
                         f"not running job '{job['label']}' because it doesn't have "
                         f"any of the following tags: {printable_set(tags)}"
@@ -40,7 +41,7 @@ def _get_jobs_matching(
 
         if job["label"] not in job_names:
             if verbose:
-                print(
+                log(
                     (
                         f"not running job '{job['label']}' because it isn't in the "
                         f"list of job names. See --jobs and --not-jobs"
@@ -51,7 +52,7 @@ def _get_jobs_matching(
         has_tags_to_avoid = job_tags.intersection(tags_to_avoid)
         if has_tags_to_avoid:
             if verbose:
-                print(
+                log(
                     (
                         f"not running job '{job['label']}' because it contains the "
                         f"following tags: {printable_set(has_tags_to_avoid)}"
@@ -73,17 +74,23 @@ def filter_jobs(
     jobs: PhaseGroupedJobs = config_metadata.jobs
     verbose: bool = config_metadata.args.verbose
     if tags_to_run:
-        print(f"filtering for tags {printable_set(tags_to_run)}", end="")
+        log(f"filtering for tags {printable_set(tags_to_run)}", decorate=True, end="")
     if tags_to_avoid:
         if tags_to_run:
-            print(", ", end="")
-        print(f"excluding jobs with tags {printable_set(tags_to_avoid)}", end="")
+            log(", ", decorate=False, end="")
+        else:
+            log(decorate=True, end="")
+        log(
+            f"excluding jobs with tags {printable_set(tags_to_avoid)}",
+            decorate=False,
+            end="",
+        )
     if tags_to_run or tags_to_avoid:
-        print()
+        log(decorate=False)
     filtered_jobs: PhaseGroupedJobs = defaultdict(list)
     for phase in config_metadata.phases:
         if phase not in phases_to_run:
-            print(f"skipping phase '{phase}'")
+            log(f"skipping phase '{phase}'")
             continue
         _get_jobs_matching(
             phase=phase,
@@ -95,10 +102,10 @@ def filter_jobs(
             verbose=verbose,
         )
         if len(filtered_jobs[phase]) == 0:
-            print(f"No jobs for phase '{phase}' tags {printable_set(tags_to_run)}")
+            log(f"No jobs for phase '{phase}' tags {printable_set(tags_to_run)}")
             continue
 
-        print((f"will run {len(filtered_jobs[phase])} jobs for phase '{phase}'"))
-        print(f"\t{[job['label'] for job in filtered_jobs[phase]]}")
+        log((f"will run {len(filtered_jobs[phase])} jobs for phase '{phase}'"))
+        log(f"\t{[job['label'] for job in filtered_jobs[phase]]}")
 
     return filtered_jobs

runem/{job_function_python.py → job_wrapper_python.py}

@@ -20,20 +20,35 @@ def _load_python_function_from_module(
     ).absolute()
 
     # load the function
-    module_spec = module_spec_from_file_location(function_to_load, abs_module_file_path)
-    if not module_spec:
+    try:
+        module_spec = module_spec_from_file_location(
+            function_to_load, abs_module_file_path
+        )
+        if not module_spec:
+            raise FileNotFoundError()
+        if not module_spec.loader:
+            raise FunctionNotFound("unable to load module")
+    except FileNotFoundError as err:
         raise FunctionNotFound(
             (
                 f"unable to load '{function_to_load}' from '{str(module_file_path)} "
                 f"relative to '{str(cfg_filepath)}"
             )
-        )
+        ) from err
 
     module = module_from_spec(module_spec)
-    sys.modules[module_name] = module
-    if not module_spec.loader:
+    if not module:
         raise FunctionNotFound("unable to load module")
-    module_spec.loader.exec_module(module)
+    sys.modules[module_name] = module
+    try:
+        module_spec.loader.exec_module(module)
+    except FileNotFoundError as err:
+        raise FunctionNotFound(
+            (
+                f"unable to load '{function_to_load}' from '{str(module_file_path)} "
+                f"relative to '{str(cfg_filepath)}"
+            )
+        ) from err
     try:
         function: JobFunction = getattr(module, function_to_load)
     except AttributeError as err:
@@ -70,7 +85,7 @@ def _find_job_module(cfg_filepath: pathlib.Path, module_file_path: str) -> pathl
     return module_path.relative_to(cfg_filepath.parent.absolute())
 
 
-def get_job_function(job_config: JobConfig, cfg_filepath: pathlib.Path) -> JobFunction:
+def get_job_wrapper(job_config: JobConfig, cfg_filepath: pathlib.Path) -> JobFunction:
     """Given a job-description dynamically loads the job-function so we can call it.
 
     Side-effects: also re-addressed the job-config.

runem/log.py

@@ -0,0 +1,11 @@
+import typing
+
+
+def log(msg: str = "", decorate: bool = True, end: typing.Optional[str] = None) -> None:
+    """Thin wrapper around 'print', so we can change the output.
+
+    One way we change it is to decorate the output with 'runem'
+    """
+    if decorate:
+        msg = f"runem: {msg}"
+    print(msg, end=end)

runem/report.py

@@ -2,6 +2,7 @@ import typing
 from collections import defaultdict
 from datetime import timedelta
 
+from runem.log import log
 from runem.types import (
     JobReturn,
     JobRunMetadatasByPhase,
@@ -25,12 +26,15 @@ def _plot_times(
     phase_run_oder: OrderedPhases,
     timing_data: JobRunTimesByPhase,
 ) -> timedelta:
-    """Prints a report to terminal on how well we performed."""
+    """Prints a report to terminal on how well we performed.
+
+    Also calculates the wall-clock time-saved for the user.
+    """
     labels: typing.List[str] = []
     times: typing.List[float] = []
     job_time_sum: timedelta = timedelta()  # init to 0
     for phase in phase_run_oder:
-        # print(f"Phase '{phase}' jobs took:")
+        # log(f"Phase '{phase}' jobs took:")
         phase_total_time: float = 0.0
         phase_start_idx = len(labels)
         for label, job_time in timing_data[phase]:
@@ -59,18 +63,37 @@ def _plot_times(
         fig.show()
     else:  # pragma: FIXME: add code coverage
         for label, time in zip(labels, times):
-            print(f"{label}: {time}s")
+            log(f"{label}: {time}s")
 
     time_saved: timedelta = job_time_sum - overall_run_time
     return time_saved
 
 
+def _print_reports_by_phase(
+    phase_run_oder: OrderedPhases, report_data: JobRunReportByPhase
+) -> None:
+    """Logs out the reports by grouped by phase."""
+    for phase in phase_run_oder:
+        report_urls: ReportUrls = report_data[phase]
+        job_report_url_info: ReportUrlInfo
+        for job_report_url_info in report_urls:
+            if not job_report_url_info:
+                continue
+            log(f"report: {str(job_report_url_info[0])}: {str(job_report_url_info[1])}")
+
+
 def report_on_run(
     phase_run_oder: OrderedPhases,
     job_run_metadatas: JobRunMetadatasByPhase,
     overall_runtime: timedelta,
-):
-    print("runem: reports:")
+) -> timedelta:
+    """Generate high-level reports AND prints out any reports returned by jobs.
+
+    IMPORTANT: returns the wall-clock time saved to the user.
+    """
+    log("reports:")
+
+    # First, collate all data, timing and reports
     timing_data: JobRunTimesByPhase = defaultdict(list)
     report_data: JobRunReportByPhase = defaultdict(list)
     phase: PhaseName
@@ -80,19 +103,21 @@ def report_on_run(
         for timing, reports in job_run_metadatas[phase]:
             timing_data[phase].append(timing)
             if reports:
+                # the job returned some report urls, record them against the
+                # job's phase
                 report_data[phase].extend(reports["reportUrls"])
+
+    # Now plot the times on the terminal to give a visual report of the timing.
+    # Also, calculate the time saved by runem, a key selling-point metric
     time_saved: timedelta = _plot_times(
         overall_run_time=overall_runtime,
         phase_run_oder=phase_run_oder,
         timing_data=timing_data,
     )
-    for phase in phase_run_oder:
-        report_urls: ReportUrls = report_data[phase]
-        job_report_url_info: ReportUrlInfo
-        for job_report_url_info in report_urls:
-            if not job_report_url_info:
-                continue
-            print(
-                f"report: {str(job_report_url_info[0])}: {str(job_report_url_info[1])}"
-            )
+
+    # Penultimate-ly print out the available reports grouped by run-phase.
+    _print_reports_by_phase(phase_run_oder, report_data)
+
+    # Return the key metric for runem, the wall-clock time saved to the user
+    # TODO: write this to disk
     return time_saved

runem/run_command.py

@@ -5,6 +5,8 @@ from subprocess import STDOUT as SUBPROCESS_STDOUT
 from subprocess import CompletedProcess
 from subprocess import run as subprocess_run
 
+from runem.log import log
+
 TERMINAL_WIDTH = 86
 
 
@@ -42,10 +44,10 @@ def run_command(  # noqa: C901 # pylint: disable=too-many-branches
     """Runs the given command, returning stdout or throwing on any error."""
     cmd_string: str = " ".join(cmd)
     if verbose:
-        print(f"runem: running: start: {label}: {cmd_string}")
+        log(f"running: start: {label}: {cmd_string}")
         if valid_exit_ids is not None:
             valid_exit_strs = ",".join([str(exit_code) for exit_code in valid_exit_ids])
-            print(f"runem:\tallowed return ids are: {valid_exit_strs}")
+            log(f"\tallowed return ids are: {valid_exit_strs}")
 
     if valid_exit_ids is None:
         valid_exit_ids = (0,)
@@ -60,13 +62,13 @@ def run_command(  # noqa: C901 # pylint: disable=too-many-branches
         run_env_as_string = " ".join(
             [f"{key}='{value}'" for key, value in run_env.items()]
         )
-        print(f"RUN ENV OVERRIDES: {run_env_as_string } {cmd_string}")
+        log(f"RUN ENV OVERRIDES: {run_env_as_string } {cmd_string}")
 
         if env_overrides:
             env_overrides_as_string = " ".join(
                 [f"{key}='{value}'" for key, value in env_overrides.items()]
             )
-            print(f"ENV OVERRIDES: {env_overrides_as_string} {cmd_string}")
+            log(f"ENV OVERRIDES: {env_overrides_as_string} {cmd_string}")
 
     env_overrides_dict = {}
     if env_overrides:
@@ -127,6 +129,6 @@ def run_command(  # noqa: C901 # pylint: disable=too-many-branches
     assert process is not None
     cmd_stdout: str = get_stdout(process, prefix=label)
     if verbose:
-        print(cmd_stdout)
-        print(f"runem: running: done: {label}: {cmd_string}")
+        log(cmd_stdout)
+        log(f"running: done: {label}: {cmd_string}")
     return cmd_stdout

runem/runem.py

@@ -23,19 +23,24 @@ import multiprocessing
 import os
 import pathlib
 import sys
+import time
 import typing
 from collections import defaultdict
 from datetime import timedelta
 from itertools import repeat
+from multiprocessing.managers import DictProxy, ValueProxy
 from timeit import default_timer as timer
 
+from halo import Halo
+
 from runem.command_line import parse_args
 from runem.config import load_config
 from runem.config_metadata import ConfigMetadata
 from runem.config_parse import parse_config
 from runem.files import find_files
+from runem.job_execute import job_execute
 from runem.job_filter import filter_jobs
-from runem.job_runner import job_runner
+from runem.log import log
 from runem.report import report_on_run
 from runem.types import (
     Config,
@@ -69,11 +74,27 @@ def _determine_run_parameters(argv: typing.List[str]) -> ConfigMetadata:
     config_metadata = parse_args(config_metadata, argv)
 
     if config_metadata.args.verbose:
-        print(f"loaded config from {cfg_filepath}")
+        log(f"loaded config from {cfg_filepath}")
 
     return config_metadata
 
 
+def _progress_updater(
+    label: str, running_jobs: typing.Dict[str, str], is_running: ValueProxy
+) -> None:
+    spinner = Halo(text="", spinner="dots")
+    spinner.start()
+
+    while is_running.value:
+        running_job_names: typing.List[str] = [
+            f"'{job}'" for job in sorted(list(running_jobs.values()))
+        ]
+        printable_jobs: str = ", ".join(running_job_names)
+        spinner.text = f"{label}: {printable_jobs}"
+        time.sleep(0.1)
+    spinner.stop()
+
+
 def _process_jobs(
     config_metadata: ConfigMetadata,
     file_lists: FilePathListLookup,
@@ -96,22 +117,38 @@ def _process_jobs(
         else multiprocessing.cpu_count()
     )
     num_concurrent_procs = min(num_concurrent_procs, len(jobs))
-    print(
+    log(
         (
             f"Running '{phase}' with {num_concurrent_procs} workers "
             f"processing {len(jobs)} jobs"
         )
     )
-    with multiprocessing.Pool(processes=num_concurrent_procs) as pool:
-        # use starmap so we can pass down the job-configs and the args and the files
-        in_out_job_run_metadatas[phase] = pool.starmap(
-            job_runner,
-            zip(
-                jobs,
-                repeat(config_metadata),
-                repeat(file_lists),
-            ),
+
+    with multiprocessing.Manager() as manager:
+        running_jobs: DictProxy[typing.Any, typing.Any] = manager.dict()
+        is_running: ValueProxy = manager.Value("b", True)
+
+        terminal_writer_process = multiprocessing.Process(
+            target=_progress_updater, args=(phase, running_jobs, is_running)
         )
+        terminal_writer_process.start()
+
+        try:
+            with multiprocessing.Pool(processes=num_concurrent_procs) as pool:
+                # use starmap so we can pass down the job-configs and the args and the files
+                in_out_job_run_metadatas[phase] = pool.starmap(
+                    job_execute,
+                    zip(
+                        jobs,
+                        repeat(running_jobs),
+                        repeat(config_metadata),
+                        repeat(file_lists),
+                    ),
+                )
+        finally:
+            # Signal the terminal_writer process to exit
+            is_running.value = False
+            terminal_writer_process.join()
 
 
 def _process_jobs_by_phase(
@@ -139,7 +176,7 @@ def _process_jobs_by_phase(
             continue
 
         if config_metadata.args.verbose:
-            print(f"Running Phase {phase}")
+            log(f"Running Phase {phase}")
 
         _process_jobs(
             config_metadata, file_lists, in_out_job_run_metadatas, phase, jobs
@@ -158,11 +195,11 @@ def _main(
 
     file_lists: FilePathListLookup = find_files(config_metadata)
     assert file_lists
-    print(f"found {len(file_lists)} batches, ", end="")
+    log(f"found {len(file_lists)} batches, ", end="")
     for tag in sorted(file_lists.keys()):
         file_list = file_lists[tag]
-        print(f"{len(file_list)} '{tag}' files, ", end="")
-    print()  # new line
+        log(f"{len(file_list)} '{tag}' files, ", decorate=False, end="")
+    log(decorate=False)  # new line
 
     filtered_jobs_by_phase: PhaseGroupedJobs = filter_jobs(
         config_metadata=config_metadata,
@@ -202,7 +239,7 @@ def timed_main(argv: typing.List[str]) -> None:
     end = timer()
     time_taken: timedelta = timedelta(seconds=end - start)
     time_saved = report_on_run(phase_run_oder, job_run_metadatas, time_taken)
-    print(
+    log(
         (
             f"DONE: runem took: {time_taken.total_seconds()}s, "
             f"saving you {time_saved.total_seconds()}s"

runem/types.py

@@ -18,8 +18,9 @@ JobPhases = typing.Set[str]
 JobTags = typing.Set[JobTag]
 PhaseName = str
 OrderedPhases = typing.Tuple[PhaseName, ...]
-ReportUrl = str | pathlib.Path
-ReportUrlInfo = typing.Tuple[str, ReportUrl]
+ReportName = str
+ReportUrl = typing.Union[str, pathlib.Path]
+ReportUrlInfo = typing.Tuple[ReportName, ReportUrl]
 ReportUrls = typing.List[ReportUrlInfo]
 
 

{runem-0.0.16.dist-info → runem-0.0.18.dist-info}/METADATA

@@ -1,11 +1,13 @@
 Metadata-Version: 2.1
 Name: runem
-Version: 0.0.16
+Version: 0.0.18
 Summary: Awesome runem created by lursight
 Home-page: https://github.com/lursight/runem/
 Author: lursight
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: halo
+Requires-Dist: PyYAML
 Provides-Extra: test
 Requires-Dist: black ==23.11.0 ; extra == 'test'
 Requires-Dist: coverage ==7.3.2 ; extra == 'test'
@@ -23,7 +25,6 @@ Requires-Dist: pytest-cov ==4.1.0 ; extra == 'test'
 Requires-Dist: pytest-profiling ==1.7.0 ; extra == 'test'
 Requires-Dist: pytest-xdist ==3.3.1 ; extra == 'test'
 Requires-Dist: pytest ==7.4.3 ; extra == 'test'
-Requires-Dist: PyYAML ==6.0.1 ; extra == 'test'
 Requires-Dist: termplotlib ==0.3.9 ; extra == 'test'
 Requires-Dist: types-PyYAML ==6.0.12.12 ; extra == 'test'
 Requires-Dist: requests-mock ==1.10.0 ; extra == 'test'

runem-0.0.18.dist-info/RECORD

@@ -0,0 +1,25 @@
+runem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+runem/__main__.py,sha256=dsOiVZegpfK9JOs5n7UmbX5iwwbj7iFkEbLoVeEgAn4,136
+runem/base.py,sha256=EZfR7FIlwEdU9Vfe47Wk2DOO8GQqpKxxLNKp6YHueZ4,316
+runem/cli.py,sha256=Hz9j6Iy1SWjW2uZlQZp0eX48NDWD1-QhIqlBzr_qz0s,125
+runem/command_line.py,sha256=lb1tvYOEVYpB_bUTRL8KxjLFuV4vKn8btFKm-28GMu0,9464
+runem/config.py,sha256=h0r2WYUlAgdokUS1VU1sjFHgrN_cEq339ph4Kn1IBBM,1937
+runem/config_metadata.py,sha256=EjCEqx9-2mtMrFf3lJJ8HFhfmScioZKeY_c9Rzajne8,2836
+runem/config_parse.py,sha256=gso5Lziw8yII5jGSx8fR-IAs7nxUzhzitnRAEXsg5f8,5157
+runem/files.py,sha256=vAI17m-Y1tRGot6_vDpTuBTkKm8xdByGoh7HCfNkMFU,1900
+runem/job_execute.py,sha256=x-IGTG5KYnTJtCYm4jP8_WOQ_UM_BAiG5b3UUKp527A,3042
+runem/job_filter.py,sha256=nltSRK1IKp2fuTCHOZFcii0FBL-R3RKvrnyWXTPjoMw,3478
+runem/job_wrapper_python.py,sha256=TG9bzDe1dgTnsrXrCPd6LzN8qbMkH4rEv_vXC_zlJc0,4226
+runem/log.py,sha256=m1lI4V8ygM53pY4Go4eEzvEJY8srVoItxUNhdp_Vrqg,314
+runem/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+runem/report.py,sha256=AyD2yT_8ODo5QRuFkVFIecp6ycT4XElJbleWviZbCfI,4032
+runem/run_command.py,sha256=6QxH8pb4Lug-d0MCP2lBKq2TJlQloxRlq0hYJM6IScc,4528
+runem/runem.py,sha256=Q5ryZtArAGuTlHF07aobJkRIzurKIUsMSUPzEksL6LY,8227
+runem/types.py,sha256=Hw7G7ut7yNaoc3XiDNKeM-cAU-DDu3fDOne13FrutS0,5374
+runem/utils.py,sha256=3N_kel9LsriiMq7kOjT14XhfxUOgz4hdDg97wlLKm3U,221
+runem-0.0.18.dist-info/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
+runem-0.0.18.dist-info/METADATA,sha256=VzkG4gPaopCtwCnEx1XRGLk9iNWpLPjl4x8BY-JvSSA,15909
+runem-0.0.18.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+runem-0.0.18.dist-info/entry_points.txt,sha256=nu0g_vBeuPihYtimbtlNusxWovylMppvJ8UxdJlJfvM,46
+runem-0.0.18.dist-info/top_level.txt,sha256=gK6iqh9OfHDDpErioCC9ul_zx2Q5zWTALtcuGU7Vil4,6
+runem-0.0.18.dist-info/RECORD,,

runem-0.0.16.dist-info/RECORD

@@ -1,24 +0,0 @@
-runem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-runem/__main__.py,sha256=dsOiVZegpfK9JOs5n7UmbX5iwwbj7iFkEbLoVeEgAn4,136
-runem/base.py,sha256=EZfR7FIlwEdU9Vfe47Wk2DOO8GQqpKxxLNKp6YHueZ4,316
-runem/cli.py,sha256=Hz9j6Iy1SWjW2uZlQZp0eX48NDWD1-QhIqlBzr_qz0s,125
-runem/command_line.py,sha256=MD3tAdXO7WNKRabwSJwBks1az2mYyTAxifxX-vGA8yc,9425
-runem/config.py,sha256=jtpMOS-7J0YFkQmXpDy3CPtohEd4HBHGmjPTzkL0Tyw,1913
-runem/config_metadata.py,sha256=EjCEqx9-2mtMrFf3lJJ8HFhfmScioZKeY_c9Rzajne8,2836
-runem/config_parse.py,sha256=eA5oAW8T7-kv6TnNEsnhIvRP0AoPItufwaTTaMr7yZ0,5140
-runem/files.py,sha256=vAI17m-Y1tRGot6_vDpTuBTkKm8xdByGoh7HCfNkMFU,1900
-runem/job_filter.py,sha256=cNlc9UVi6S1O9Ui95GH3n4dFEYRiGJ4KUIt5xPDQWWw,3313
-runem/job_function_python.py,sha256=iNRKQp0Rlkh1VektOxUSa_KqrrY0yB7jDChcRt-s6oQ,3754
-runem/job_runner.py,sha256=cCpZg_1LOMalQoY23_5A7R8vu7aaNjliZL4q8qxdIz0,2834
-runem/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-runem/report.py,sha256=S-KV70gMBUlxjqtzQkCqSIDhsRk6X20i9RKLv6-Y5vk,3104
-runem/run_command.py,sha256=UPwQU7eC5FADcX3aPrNP8kp-g5YONBdwwjsz-NCaMno,4533
-runem/runem.py,sha256=LEccvElpxpuKM6Bl4gvrc1-ZlMkSB8b7K13l5nyzNP4,6941
-runem/types.py,sha256=IxUDGHOQZUc86OPjDHDKwrcBFr78v-MNvTpPwUzWoaI,5337
-runem/utils.py,sha256=3N_kel9LsriiMq7kOjT14XhfxUOgz4hdDg97wlLKm3U,221
-runem-0.0.16.dist-info/LICENSE,sha256=awOCsWJ58m_2kBQwBUGWejVqZm6wuRtCL2hi9rfa0X4,1211
-runem-0.0.16.dist-info/METADATA,sha256=P-__qoOFtuC8JZU7uh3hEBeN_U7kHW7U8hGY9q_5A6U,15915
-runem-0.0.16.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-runem-0.0.16.dist-info/entry_points.txt,sha256=nu0g_vBeuPihYtimbtlNusxWovylMppvJ8UxdJlJfvM,46
-runem-0.0.16.dist-info/top_level.txt,sha256=gK6iqh9OfHDDpErioCC9ul_zx2Q5zWTALtcuGU7Vil4,6
-runem-0.0.16.dist-info/RECORD,,