Implement ExecutionReports. (#3)

Author: tobiasraabe

.github/workflows/continuous-integration-workflow.yml

@@ -31,11 +31,6 @@ jobs:
         shell: bash -l {0}
         run: conda install -c conda-forge tox-conda coverage
 
-      - name: Validate codecov.yml
-        if: runner.os == 'Linux' && matrix.python-version == '3.8'
-        shell: bash -l {0}
-        run: cat codecov.yml | curl --data-binary @- https://codecov.io/validate
-
       # Unit, integration, and end-to-end tests.
 
       - name: Run unit tests and doctests.
@@ -65,6 +60,11 @@ jobs:
         shell: bash -l {0}
         run: bash <(curl -s https://codecov.io/bash) -F end_to_end -c
 
+      - name: Validate codecov.yml
+        if: runner.os == 'Linux' && matrix.python-version == '3.7'
+        shell: bash -l {0}
+        run: cat codecov.yml | curl --data-binary @- https://codecov.io/validate
+
 
   pre-commit:
 

docs/changes.rst

@@ -10,6 +10,7 @@ all releases are available on `Anaconda.org <https://anaconda.org/pytask/pytask>
 ------------------
 
 - :gh:`2` provided multiple small changes.
+- :gh:`3` implements a class which holds the execution report of one task.
 
 
 0.0.1 - 2020-06-29

src/pytask/config.py

@@ -7,7 +7,7 @@
 from pathlib import Path
 
 import click
-from pytask import hookimpl
+import pytask
 from pytask.shared import to_list
 
 
@@ -19,7 +19,7 @@
 ]
 
 
-@hookimpl
+@pytask.hookimpl
 def pytask_configure(pm, config_from_cli):
     config = {"pm": pm, "terminal_width": _get_terminal_width()}
 
@@ -41,7 +41,7 @@ def pytask_configure(pm, config_from_cli):
     return config
 
 
-@hookimpl
+@pytask.hookimpl
 def pytask_parse_config(config, config_from_cli, config_from_file):
     config["ignore"] = (
         _get_first_not_none_value(

src/pytask/execute.py

@@ -13,15 +13,18 @@
 from pytask.exceptions import NodeNotFoundError
 from pytask.mark import Mark
 from pytask.nodes import FilePathNode
+from pytask.report import ExecutionReport
 from pytask.report import format_execute_footer
 
 
 @hookimpl
 def pytask_execute(session):
     session.hook.pytask_execute_log_start(session=session)
     session.scheduler = session.hook.pytask_execute_create_scheduler(session=session)
-    session.results = session.hook.pytask_execute_build(session=session)
-    session.hook.pytask_execute_log_end(session=session, reports=session.results)
+    session.execution_reports = session.hook.pytask_execute_build(session=session)
+    session.hook.pytask_execute_log_end(
+        session=session, reports=session.execution_reports
+    )
 
 
 @hookimpl
@@ -41,12 +44,12 @@ def pytask_execute_create_scheduler(session):
 
 @hookimpl
 def pytask_execute_build(session):
-    results = []
+    reports = []
     for task in session.scheduler:
-        result = session.hook.pytask_execute_task_protocol(session=session, task=task)
-        results.append(result)
+        report = session.hook.pytask_execute_task_protocol(session=session, task=task)
+        reports.append(report)
 
-    return results
+    return reports
 
 
 @hookimpl
@@ -57,19 +60,13 @@ def pytask_execute_task_protocol(session, task):
         session.hook.pytask_execute_task(session=session, task=task)
         session.hook.pytask_execute_task_teardown(session=session, task=task)
     except Exception:
-        etype, value, tb = sys.exc_info()
-        result = {
-            "task": task,
-            "etype": etype,
-            "value": value,
-            "traceback": tb,
-        }
+        report = ExecutionReport.from_task_and_exception(task, sys.exc_info())
     else:
-        result = {"task": task, "value": None}
-    session.hook.pytask_execute_task_process_result(session=session, result=result)
-    session.hook.pytask_execute_task_log_end(session=session, task=task, result=result)
+        report = ExecutionReport.from_task(task)
+    session.hook.pytask_execute_task_process_report(session=session, report=report)
+    session.hook.pytask_execute_task_log_end(session=session, task=task, report=report)
 
-    return result
+    return report
 
 
 @hookimpl(trylast=True)
@@ -114,13 +111,11 @@ def pytask_execute_task_teardown(session, task):
 
 
 @hookimpl(trylast=True)
-def pytask_execute_task_process_result(session, result):
-    task = result["task"]
-    if result["value"] is None:
-        result["success"] = True
+def pytask_execute_task_process_report(session, report):
+    task = report.task
+    if report.success:
         _update_states_in_database(session.dag, task.name)
     else:
-        result["success"] = False
         for descending_task_name in task_and_descending_tasks(task.name, session.dag):
             descending_task = session.dag.nodes[descending_task_name]["task"]
             descending_task.markers.append(
@@ -135,8 +130,8 @@ def pytask_execute_task_process_result(session, result):
 
 
 @hookimpl(trylast=True)
-def pytask_execute_task_log_end(result):
-    if result["success"]:
+def pytask_execute_task_log_end(report):
+    if report.success:
         click.secho(".", fg="green", nl=False)
     else:
         click.secho("F", fg="red", nl=False)
@@ -149,19 +144,15 @@ def pytask_execute_log_end(session, reports):
     session.execution_end = time.time()
     click.echo("")
 
-    n_successful = sum(result["success"] for result in reports)
+    n_successful = sum(report.success for report in reports)
     n_failed = len(reports) - n_successful
     tm_width = session.config["terminal_width"]
 
     for report in reports:
-        if not report["success"]:
-            click.echo(
-                f"{{:=^{tm_width}}}".format(f" Task {report['task'].name} failed ")
-            )
+        if not report.success:
+            click.echo(f"{{:=^{tm_width}}}".format(f" Task {report.task.name} failed "))
             click.echo("")
-            traceback.print_exception(
-                report["etype"], report["value"], report["traceback"]
-            )
+            traceback.print_exception(*report.exc_info)
             click.echo("")
             click.echo("=" * tm_width)
 

src/pytask/hookspecs.py

@@ -170,12 +170,12 @@ def pytask_execute_task_teardown(session, task):
 
 
 @hookspec(firstresult=True)
-def pytask_execute_task_process_result(session, result):
-    """Process the result of a task."""
+def pytask_execute_task_process_report(session, report):
+    """Process the report of a task."""
 
 
 @hookspec(firstresult=True)
-def pytask_execute_task_log_end(session, task, result):
+def pytask_execute_task_log_end(session, task, report):
     """End logging of task execution."""
 
 

src/pytask/report.py

@@ -6,11 +6,6 @@
 import click
 
 
-@attr.s
-class ResolvingDependenciesReport:
-    exc_info = attr.ib()
-
-
 @attr.s
 class CollectionReportTask:
     path = attr.ib(type=Path)
@@ -51,6 +46,26 @@ def format_title(self):
         return f" Collection of file '{self.path}' failed "
 
 
+@attr.s
+class ResolvingDependenciesReport:
+    exc_info = attr.ib()
+
+
+@attr.s
+class ExecutionReport:
+    task = attr.ib()
+    success = attr.ib(type=bool)
+    exc_info = attr.ib(default=None)
+
+    @classmethod
+    def from_task_and_exception(cls, task, exc_info):
+        return cls(task, False, exc_info)
+
+    @classmethod
+    def from_task(cls, task):
+        return cls(task, True)
+
+
 def format_execute_footer(n_successful, n_failed, duration, terminal_width):
     message = []
     if n_successful:

src/pytask/skipping.py

@@ -25,38 +25,45 @@ def pytask_execute_task_setup(task):
 
 
 @pytask.hookimpl
-def pytask_execute_task_process_result(session, result):
-    if isinstance(result["value"], SkippedUnchanged):
-        result["success"] = True
+def pytask_execute_task_process_report(session, report):
+    if report.exc_info and isinstance(report.exc_info[1], SkippedUnchanged):
+        report.success = True
 
-    elif isinstance(result["value"], Skipped):
-        result["success"] = True
+    elif report.exc_info and isinstance(report.exc_info[1], Skipped):
+        report.success = True
         for descending_task_name in task_and_descending_tasks(
-            result["task"].name, session.dag
+            report.task.name, session.dag
         ):
             descending_task = session.dag.nodes[descending_task_name]["task"]
             descending_task.markers.append(Mark("skip", (), {},))
 
-    elif isinstance(result["value"], SkippedAncestorFailed):
-        result["success"] = False
-        result["traceback"] = None
+    elif report.exc_info and isinstance(report.exc_info[1], SkippedAncestorFailed):
+        report.success = False
+        report.exc_info = _remove_traceback_from_exc_info(report.exc_info)
 
-    if isinstance(result["value"], (Skipped, SkippedUnchanged, SkippedAncestorFailed)):
+    if report.exc_info and isinstance(
+        report.exc_info[1], (Skipped, SkippedUnchanged, SkippedAncestorFailed)
+    ):
         return True
 
 
 @pytask.hookimpl
-def pytask_execute_task_log_end(result):
-    value = result["value"]
-    if result["success"]:
-        if isinstance(value, Skipped):
+def pytask_execute_task_log_end(report):
+    if report.success:
+        if report.exc_info and isinstance(report.exc_info[1], Skipped):
             click.secho("s", fg="yellow", nl=False)
-        elif isinstance(value, SkippedUnchanged):
+        elif report.exc_info and isinstance(report.exc_info[1], SkippedUnchanged):
             click.secho("s", fg="green", nl=False)
     else:
-        if isinstance(value, SkippedAncestorFailed):
+        if report.exc_info and isinstance(report.exc_info[1], SkippedAncestorFailed):
             click.secho("s", fg="red", nl=False)
 
-    if isinstance(value, (Skipped, SkippedUnchanged, SkippedAncestorFailed)):
+    if report.exc_info and isinstance(
+        report.exc_info[1], (Skipped, SkippedUnchanged, SkippedAncestorFailed)
+    ):
         # Return non-None value so that the task is not logged again.
         return True
+
+
+def _remove_traceback_from_exc_info(exc_info):
+    return (*exc_info[:2], None)

tests/test_skipping.py

@@ -1,22 +1,18 @@
 import os
 import textwrap
-from contextlib import contextmanager
+from contextlib import ExitStack as does_not_raise  # noqa: N813
 
 import pytest
 from pytask.main import main
 from pytask.mark import Mark
 from pytask.outcomes import Skipped
 from pytask.outcomes import SkippedAncestorFailed
 from pytask.outcomes import SkippedUnchanged
+from pytask.report import ExecutionReport
 from pytask.skipping import pytask_execute_task_log_end
 from pytask.skipping import pytask_execute_task_setup
 
 
-@contextmanager
-def does_not_raise():
-    yield
-
-
 @pytest.mark.end_to_end
 def test_skip_unchanged(tmp_path):
     source = """
@@ -26,10 +22,10 @@ def task_dummy():
     tmp_path.joinpath("task_dummy.py").write_text(textwrap.dedent(source))
 
     session = main({"paths": tmp_path})
-    assert session.results[0]["success"]
+    assert session.execution_reports[0].success
 
     session = main({"paths": tmp_path})
-    assert isinstance(session.results[0]["value"], SkippedUnchanged)
+    assert isinstance(session.execution_reports[0].exc_info[1], SkippedUnchanged)
 
 
 @pytest.mark.end_to_end
@@ -51,12 +47,12 @@ def task_dummy():
     os.chdir(tmp_path)
     session = main({"paths": tmp_path})
 
-    assert session.results[0]["success"]
+    assert session.execution_reports[0].success
     assert tmp_path.joinpath("out.txt").read_text() == "Original content of in.txt."
 
     session = main({"paths": tmp_path})
 
-    assert isinstance(session.results[0]["value"], SkippedUnchanged)
+    assert isinstance(session.execution_reports[0].exc_info[1], SkippedUnchanged)
     assert tmp_path.joinpath("out.txt").read_text() == "Original content of in.txt."
 
 
@@ -81,10 +77,10 @@ def task_second():
     os.chdir(tmp_path)
     session = main({"paths": tmp_path})
 
-    assert not session.results[0]["success"]
-    assert isinstance(session.results[0]["value"], Exception)
-    assert not session.results[1]["success"]
-    assert isinstance(session.results[1]["value"], SkippedAncestorFailed)
+    assert not session.execution_reports[0].success
+    assert isinstance(session.execution_reports[0].exc_info[1], Exception)
+    assert not session.execution_reports[1].success
+    assert isinstance(session.execution_reports[1].exc_info[1], SkippedAncestorFailed)
 
 
 def test_if_skip_decorator_is_applied(tmp_path):
@@ -108,10 +104,10 @@ def task_second():
     os.chdir(tmp_path)
     session = main({"paths": tmp_path})
 
-    assert session.results[0]["success"]
-    assert isinstance(session.results[0]["value"], Skipped)
-    assert session.results[1]["success"]
-    assert isinstance(session.results[1]["value"], Skipped)
+    assert session.execution_reports[0].success
+    assert isinstance(session.execution_reports[0].exc_info[1], Skipped)
+    assert session.execution_reports[1].success
+    assert isinstance(session.execution_reports[1].exc_info[1], Skipped)
 
 
 @pytest.mark.unit
@@ -148,13 +144,15 @@ class Task:
 )
 def test_pytask_execute_task_log_end(capsys, exception, character):
     if isinstance(exception, (Skipped, SkippedUnchanged)):
-        result = {"success": False, "value": exception()}
+        report = ExecutionReport.from_task_and_exception((), exception())
+        report.success = True
     elif isinstance(exception, SkippedAncestorFailed):
-        result = {"success": True, "value": SkippedAncestorFailed(), "reason": ""}
+        report = ExecutionReport.from_task_and_exception((), SkippedAncestorFailed)
+        report.success = True
     else:
-        result = {"success": True, "value": None}
+        report = ExecutionReport.from_task(())
 
-    out = pytask_execute_task_log_end(result)
+    out = pytask_execute_task_log_end(report)
 
     captured = capsys.readouterr()
     if isinstance(exception, (Skipped, SkippedUnchanged)):