merging branches

Author: Javert899

.gitignore

@@ -53,6 +53,7 @@ htmlcov/
 .cache
 nosetests.xml
 coverage.xml
+coverage.json
 *.cover
 *.py,cover
 .hypothesis/

COVERAGE.md

@@ -32,3 +32,65 @@ python -m coverage erase
 (cd examples && python -m coverage run --append --source=pm4py execute_everything.py --pipeline)
 python -m coverage report
 ```
+
+## List the remaining uncovered functions
+
+coverage.py records execution at the statement/line level. To first see which
+modules still contain missing statements, read the combined `.coverage` data
+produced above with:
+
+```bash
+python -m coverage report --show-missing --skip-covered --sort=cover
+```
+
+This report lists module paths and missing line numbers, not function names.
+With coverage.py 7.15.2, function and method regions are also included in the
+JSON report. The completely uncovered functions can therefore be retrieved
+from the same combined data as follows:
+
+```bash
+python -m coverage json --pretty-print -o coverage.json
+python - <<'PY'
+import json
+
+with open("coverage.json", encoding="utf-8") as report_file:
+    report = json.load(report_file)
+
+uncovered = []
+for filename, file_data in report["files"].items():
+    for function_name, function_data in file_data.get("functions", {}).items():
+        summary = function_data["summary"]
+
+        # The empty name represents statements at module scope, not a function.
+        if (
+            function_name
+            and summary["num_statements"] > 0
+            and summary["covered_lines"] == 0
+        ):
+            uncovered.append(
+                (
+                    filename,
+                    function_data["start_line"],
+                    function_name,
+                    function_data["missing_lines"],
+                )
+            )
+
+for filename, start_line, function_name, missing_lines in sorted(uncovered):
+    lines = ",".join(str(line) for line in missing_lines)
+    print(f"{filename}:{start_line}: {function_name} (missing lines: {lines})")
+PY
+```
+
+The filter above has a deliberately strict meaning of *uncovered*: the region
+has at least one executable statement and none of its statements ran. It
+excludes the empty-name region used for module-level statements and functions
+with no measurable statements (for example, a body excluded by a coverage
+pragma). Class methods are listed with qualified names such as
+`ClassName.method_name`.
+
+To also list partially covered functions, replace
+`summary["covered_lines"] == 0` with `summary["missing_lines"] > 0`. In that
+case, any function with at least one unexecuted statement is included. Both
+commands inspect the final combined `.coverage` file, so they should be run
+after the test run and the appended example run.