runem 0.0.16__tar.gz → 0.0.18__tar.gz

{runem-0.0.16 → runem-0.0.18}/HISTORY.md

@@ -4,6 +4,120 @@ Changelog
 
 (unreleased)
 ------------
+- Merge pull request #9 from lursight/chore/rename_core_functions.
+  [Frank Harrison]
+
+  Chore/rename core functions
+- Chore(core-func-rename): renames functions and fixes imports. [Frank
+  Harrison]
+- Chore(core-func-rename): renames files to better reflect contents.
+  [Frank Harrison]
+- Merge pull request #8 from lursight/chore/more_typing_strictness.
+  [Frank Harrison]
+
+  Chore/more typing strictness
+- Chore(mypy-strict): switches mypy to use strict-mode. [Frank Harrison]
+
+  This should catch more issues down the line
+- Chore(mypy-strict): enable disallow_untyped_calls and annotate it.
+  [Frank Harrison]
+- Chore(mypy-strict): enable disallow_untyped_defs in mypy. [Frank
+  Harrison]
+- Chore(mypy-strict): enables check_untyped_defs in mypy. [Frank
+  Harrison]
+- Chore(mypy-strict): annotates mypy config options. [Frank Harrison]
+- Merge pull request #7 from lursight/chore/project_status. [Frank
+  Harrison]
+
+  chore(project-status): removes the project rename from actions
+- Chore(project-status): removes the project rename from actions. [Frank
+  Harrison]
+- Merge pull request #5 from lursight/feat/job_spinner. [Frank Harrison]
+
+  Feat/job spinner
+- Feat(progress): gets a progress spinner working. [Frank Harrison]
+- Feat(progress): adds way to track running jobs for multip-proc jobs.
+  [Frank Harrison]
+- Merge pull request #3 from
+  lursight/dependabot/github_actions/actions/setup-python-5. [Frank
+  Harrison]
+
+  chore(deps): bump actions/setup-python from 4 to 5
+- Chore(deps): bump actions/setup-python from 4 to 5. [dependabot[bot]]
+
+  Bumps [actions/setup-python](https://github.com/actions/setup-python) from 4 to 5.
+  - [Release notes](https://github.com/actions/setup-python/releases)
+  - [Commits](https://github.com/actions/setup-python/compare/v4...v5)
+
+  ---
+  updated-dependencies:
+  - dependency-name: actions/setup-python
+    dependency-type: direct:production
+    update-type: version-update:semver-major
+  ...
+- Merge pull request #6 from lursight/fix/help_tests. [Frank Harrison]
+
+  Fix/help tests
+- Chore(fix-help-tests): fixing the help-text test in ci/cd. [Frank
+  Harrison]
+- Chore(pytest): stops reporting of coverage on test failures. [Frank
+  Harrison]
+- Chore(pytest): stops failing coverage BEFORE we want to. [Frank
+  Harrison]
+- Chore(type): fixes type errors. [Frank Harrison]
+- Merge pull request #4 from lursight/fix/python3.10_support. [Frank
+  Harrison]
+
+  fix(python3.10): removes another pipe shortcut
+- Fix(python3.10): removes another pipe shortcut. [Frank Harrison]
+- Merge branch 'fix/python3.10_support' [Frank Harrison]
+- Fix(python3.10): removes newer typing syntax. [Frank Harrison]
+- Merge branch 'fix/coverage' [Frank Harrison]
+- Fix(coverage): adds more coverage to parse_config() [Frank Harrison]
+
+  ... specifically the bit that warns if we have to nordered phases
+- Fix(coverage): adds more coverage to
+  _load_python_function_from_module() [Frank Harrison]
+- Fix(coverage): adds more coverage to initialise_options() [Frank
+  Harrison]
+- Fix(coverage): adds more coverage to report.py. [Frank Harrison]
+- Fix(coverage): annotates a file that needs more coverage. [Frank
+  Harrison]
+- Merge branch 'fix/spell_check' [Frank Harrison]
+- Fix(spell-check): fixes the spell-checker by ignoring the history
+  file. [Frank Harrison]
+
+  ... which contains typos in the commit hitsory
+
+
+0.0.17 (2023-12-09)
+-------------------
+- Release: version 0.0.17 🚀 [Frank Harrison]
+- Merge branch 'chore/run_in_check_mode_on_release' [Frank Harrison]
+- Chore(release-checks): makes each command fail on 'make release'
+  [Frank Harrison]
+- Chore(release-checks): run runem in check mode on 'make release'
+  [Frank Harrison]
+- Merge branch 'fix/pyyaml_dep' [Frank Harrison]
+- Fix(deps): adds the py-yaml dep to release requirements. [Frank
+  Harrison]
+- Merge branch 'chore/log_output' [Frank Harrison]
+- Chore(coverage): fixes up coverage, for now. [Frank Harrison]
+- Fixup: logs. [Frank Harrison]
+- Chore(black): formats log.py. [Frank Harrison]
+- Chore(log-format): replaces print() with log. [Frank Harrison]
+
+  ... also adds a prefix to the logging
+- Merge branch 'chore/skip_spell_check_history' [Frank Harrison]
+- Chore(spell-history): add cSpell:disable to HISTORY.md's frontmatter.
+  [Frank Harrison]
+
+  ... because some of the commit messages contain spelling typos
+
+
+0.0.16 (2023-12-05)
+-------------------
+- Release: version 0.0.16 🚀 [Frank Harrison]
 - Merge branch 'chore/get_release_running_tests' [Frank Harrison]
 - Chore(test-on-release): prints existing tags on make release. [Frank
   Harrison]

{runem-0.0.16 → runem-0.0.18}/PKG-INFO

@@ -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/runem/VERSION

@@ -0,0 +1 @@
+0.0.18

runem-0.0.18/runem/cli/initialise_options.py

@@ -0,0 +1,25 @@
+import argparse
+
+from runem.config_metadata import ConfigMetadata
+from runem.types import Options
+
+
+def initialise_options(
+    config_metadata: ConfigMetadata,
+    args: argparse.Namespace,
+) -> Options:
+    """Initialises and returns the set of options to use for this run.
+
+    Returns the options dictionary
+    """
+
+    options: 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:  # 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:
+            options[option_name] = False
+    return options

{runem-0.0.16 → runem-0.0.18}/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-0.0.16 → runem-0.0.18}/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-0.0.16 → runem-0.0.18}/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-0.0.16/runem/job_runner.py → runem-0.0.18/runem/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-0.0.16 → runem-0.0.18}/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-0.0.16/runem/job_function_python.py → runem-0.0.18/runem/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-0.0.18/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-0.0.16 → runem-0.0.18}/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-0.0.16 → runem-0.0.18}/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