Merge branch 'integration' into hotfixes

Author: fit-alessandro-berti

docs/build.sh

@@ -3,14 +3,17 @@
 import sys
 import traceback
 import importlib.util
+import argparse
 
 
 
 EXECUTE_EXAMPLES = True
+PRINT_FAILURE_TRACES = True
 
 class OutcomeMeasurement:
     SUCCESS = 0
     FAILED = 0
+    FAILURE_TRACES = []
 
 
 def polars_process_cubes():
@@ -954,17 +957,23 @@ def execute_script(f):
         OutcomeMeasurement.SUCCESS += 1
     except ImportError:
         import time
-        traceback.print_exc()
+        trace = traceback.format_exc()
+        print(trace)
         OutcomeMeasurement.FAILED += 1
+        OutcomeMeasurement.FAILURE_TRACES.append(trace)
         time.sleep(3)
     except KeyError:
         import time
-        traceback.print_exc()
+        trace = traceback.format_exc()
+        print(trace)
         OutcomeMeasurement.FAILED += 1
+        OutcomeMeasurement.FAILURE_TRACES.append(trace)
         time.sleep(3)
     except:
-        traceback.print_exc()
+        trace = traceback.format_exc()
+        print(trace)
         OutcomeMeasurement.FAILED += 1
+        OutcomeMeasurement.FAILURE_TRACES.append(trace)
         input("\npress INPUT if you want to continue")
 
 
@@ -1000,9 +1009,23 @@ def print_versions():
     print(pm4py.util.pandas_utils.DATAFRAME)
 
 
+def parse_args():
+    parser = argparse.ArgumentParser(
+        prog='Example Tests',
+        description='Runs example tests')
+
+    # some libraries can not be installed in the pipeline, so some tests are disabled in pipelines
+    parser.add_argument('-p', '--pipeline',
+                        action='store_true')
+
+    args = parser.parse_args()
+    return args.pipeline
+
 def main():
     sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))))
 
+    in_pipeline = parse_args()
+
     import pm4py
     import numpy
     import pandas
@@ -1015,6 +1038,8 @@ def main():
 
     print_versions()
 
+    skipped = 0
+
     if EXECUTE_EXAMPLES:
         if importlib.util.find_spec("polars"):
             execute_script(polars_process_cubes)
@@ -1033,7 +1058,10 @@ def main():
         execute_script(simplified_interface)
         execute_script(bpmn_js_visualization)
         execute_script(read_write_ocel)
-        execute_script(discovery_data_petri_net)
+        if not in_pipeline:
+            execute_script(discovery_data_petri_net)
+        else:
+            skipped += 1
         execute_script(data_petri_nets)
         execute_script(inhibitor_reset_arcs)
         execute_script(logs_petri_visual_comparison)
@@ -1064,10 +1092,16 @@ def main():
         execute_script(ocel20_import_export)
         execute_script(revised_playout)
         execute_script(timestamp_case_grouping_filter)
-        execute_script(trace_clustering)
+        if not in_pipeline:
+            execute_script(trace_clustering)
+        else:
+            skipped += 1
         execute_script(validation_ocel20_relational)
         execute_script(interval_events_overlap)
-        execute_script(kneighb_regression)
+        if not in_pipeline:
+            execute_script(kneighb_regression)
+        else:
+            skipped += 1
         execute_script(log_to_int_tree_open_paths)
         execute_script(concept_drift)
         execute_script(dfg_align_metrics)
@@ -1087,7 +1121,10 @@ def main():
         execute_script(ocel_validation)
         execute_script(process_tree_frequency_annotation)
         execute_script(tree_manual_generation)
-        execute_script(workalendar_example)
+        if not in_pipeline:
+            execute_script(workalendar_example)
+        else:
+            skipped += 1
         execute_script(merging_case_relations)
         execute_script(activity_position)
         execute_script(link_analysis_vbfa)
@@ -1159,17 +1196,24 @@ def main():
 
     print("\n\nExamples executed correctly: %d\tExamples failed: %d\t" % (OutcomeMeasurement.SUCCESS, OutcomeMeasurement.FAILED))
 
+    print(f"Skipped {skipped} examples.")
+
     # Compute the total and pass ratio
     total_runs = OutcomeMeasurement.SUCCESS + OutcomeMeasurement.FAILED
     if total_runs > 0:
         pass_ratio = OutcomeMeasurement.SUCCESS / total_runs
     else:
         pass_ratio = 0.0
 
+    if PRINT_FAILURE_TRACES:
+        for i, trace in enumerate(OutcomeMeasurement.FAILURE_TRACES):
+            print(f"Failure {i}:")
+            print(trace)
+
     print(f"Overall pass ratio: {round(pass_ratio * 100, 2)}%")
 
     # If pass ratio is above 90%, exit code is 0; otherwise 1
-    if pass_ratio > 0.9:
+    if pass_ratio == 1:
         #print("exiting with code 0")
         sys.exit(0)
     else:

examples/execute_everything.py

@@ -57,6 +57,6 @@ def lint_package_with_score(package_path, config_path=None, threshold=8):
 if __name__ == "__main__":
     package_path = "../pm4py"
     config_file = "flake8.ini"
-    quality_threshold = 950
+    quality_threshold = 350
 
     lint_package_with_score(package_path, config_path=config_file, threshold=quality_threshold)

files/flake8_score.py

@@ -3,6 +3,7 @@
 from pm4py.objects.petri_net.utils import petri_utils
 import copy
 import numpy as np
+from collections import deque
 
 # Importing for place invariants related stuff (s-components, uniform and
 # weighted place invariants)
@@ -573,11 +574,12 @@ def step_7(woflan_object, return_asap_when_unsound=False):
             woflan_object.get_net(),
         )
     )
-    if len(check_for_improper_conditions(woflan_object.get_mcg())) == 0:
+    improper = check_for_improper_conditions(woflan_object.get_mcg())
+    if len(improper) == 0:
         woflan_object.diagnostic_messages.append("No improper coditions.")
         if woflan_object.print_diagnostics:
             print("No improper conditions.")
-        if woflan_object.get_left:
+        if woflan_object.get_left():
             return step_8(
                 woflan_object,
                 return_asap_when_unsound=return_asap_when_unsound,
@@ -588,16 +590,9 @@ def step_7(woflan_object, return_asap_when_unsound=False):
                 return_asap_when_unsound=return_asap_when_unsound,
             )
     else:
-        woflan_object.diagnostic_messages.append(
-            "Improper WPD. The following are the improper conditions: {}.".format(
-                check_for_improper_conditions(
-                    woflan_object.get_mcg())))
+        woflan_object.diagnostic_messages.append("Improper WPD. The following are the improper conditions: {}.".format(improper))
         if woflan_object.print_diagnostics:
-            print(
-                "Improper WPD. The following are the improper conditions: {}.".format(
-                    check_for_improper_conditions(woflan_object.get_mcg())
-                )
-            )
+            print("Improper WPD. The following are the improper conditions: {}.".format(improper))
         if return_asap_when_unsound:
             return False
         return step_9(
@@ -606,14 +601,9 @@ def step_7(woflan_object, return_asap_when_unsound=False):
 
 
 def step_8(woflan_object, return_asap_when_unsound=False):
-    if check_for_substates(woflan_object.get_mcg()):
-        return step_10(
-            woflan_object, return_asap_when_unsound=return_asap_when_unsound
-        )
-    else:
-        return step_10(
-            woflan_object, return_asap_when_unsound=return_asap_when_unsound
-        )
+    return step_10(
+        woflan_object, return_asap_when_unsound=return_asap_when_unsound
+    )
 
 
 def step_9(woflan_object, return_asap_when_unsound=False):
@@ -792,39 +782,34 @@ def compute_non_live_sequences(woflan_object):
         if all(np.equal(woflan_object.get_r_g().nodes[node]["marking"], f_m)):
             sucessfull_terminate_state = node
             break
-    # red nodes are those from which the final marking is not reachable
-    red_nodes = []
-    for node in woflan_object.get_r_g().nodes:
-        if not nx_utils.has_path(
-            woflan_object.get_r_g(), node, sucessfull_terminate_state
-        ):
-            red_nodes.append(node)
-    # Compute directed spanning tree
-    spanning_tree = nx_utils.Edmonds(woflan_object.get_r_g()).find_optimum()
-    queue = set()
-    paths = {}
-    # root node
-    queue.add(0)
-    paths[0] = []
-    processed_nodes = set()
+    if sucessfull_terminate_state is None:
+        return []
+    reversed_graph = woflan_object.get_r_g().reverse(copy=False)
+    can_reach_final = nx_utils.descendants(
+        reversed_graph, sucessfull_terminate_state
+    )
+    can_reach_final.add(sucessfull_terminate_state)
+    red_nodes = set(woflan_object.get_r_g().nodes) - can_reach_final
+
+    queue = deque()
+    queue.append((0, []))
+    shortest_path_len = {0: 0}
     red_paths = []
-    while len(queue) > 0:
-        v = queue.pop()
-        for node in spanning_tree.neighbors(v):
-            if node not in paths and node not in processed_nodes:
-                paths[node] = paths[v].copy()
-                # we can use directly 0 here, since we are working on a
-                # spanning tree and there should be no more edges to a node
-                paths[node].append(
-                    woflan_object.get_r_g().get_edge_data(v, node)[0][
-                        "transition"
-                    ]
-                )
-                if node not in red_nodes:
-                    queue.add(node)
-                else:
-                    red_paths.append(paths[node])
-        processed_nodes.add(v)
+    while queue:
+        node, path = queue.popleft()
+        if node in red_nodes:
+            red_paths.append(path)
+            continue
+        for successor in woflan_object.get_r_g().successors(node):
+            edge_data = woflan_object.get_r_g().get_edge_data(node, successor)
+            if not edge_data:
+                continue
+            transition = next(iter(edge_data.values()))["transition"]
+            next_path = path + [transition]
+            if successor in shortest_path_len and len(next_path) >= shortest_path_len[successor]:
+                continue
+            shortest_path_len[successor] = len(next_path)
+            queue.append((successor, next_path))
     return red_paths
 
 
@@ -848,70 +833,53 @@ def check_for_markings_larger_than_final_marking(graph, f_m):
             woflan_object.get_net(), woflan_object.get_initial_marking()
         )
     )
+    tree = woflan_object.get_restricted_coverability_tree()
     f_m = convert_marking(
         woflan_object.get_net(), woflan_object.get_final_marking()
     )
-    infinite_markings = []
-    for node in woflan_object.get_restricted_coverability_tree().nodes:
-        if (
-            np.inf
-            in woflan_object.get_restricted_coverability_tree().nodes[node][
-                "marking"
-            ]
-        ):
-            infinite_markings.append(node)
-    larger_markings = check_for_markings_larger_than_final_marking(
-        woflan_object.get_restricted_coverability_tree(), f_m
+    infinite_markings = {
+        node
+        for node, data in tree.nodes(data=True)
+        if np.inf in data["marking"]
+    }
+    larger_markings = set(
+        check_for_markings_larger_than_final_marking(tree, f_m)
     )
-    green_markings = []
-    for node in woflan_object.get_restricted_coverability_tree().nodes:
-        add_to_green = True
-        for marking in infinite_markings:
-            if nx_utils.has_path(
-                woflan_object.get_restricted_coverability_tree(), node, marking
-            ):
-                add_to_green = False
-        for marking in larger_markings:
-            if nx_utils.has_path(
-                woflan_object.get_restricted_coverability_tree(), node, marking
-            ):
-                add_to_green = False
-        if add_to_green:
-            green_markings.append(node)
-    red_markings = []
-    for node in woflan_object.get_restricted_coverability_tree().nodes:
-        add_to_red = True
-        for node_green in green_markings:
-            if nx_utils.has_path(
-                woflan_object.get_restricted_coverability_tree(),
-                node,
-                node_green,
-            ):
-                add_to_red = False
-                break
-        if add_to_red:
-            red_markings.append(node)
+    bad_nodes = infinite_markings | larger_markings
+
+    postorder_nodes = list(nx_utils.topological_sort(tree))[::-1]
+    subtree_has_bad = {}
+    subtree_has_green = {}
+    green_markings = set()
+
+    for node in postorder_nodes:
+        children = list(tree.successors(node))
+        has_bad = node in bad_nodes or any(subtree_has_bad.get(child, False) for child in children)
+        is_green = not has_bad
+        if is_green:
+            green_markings.add(node)
+        subtree_has_bad[node] = has_bad
+        subtree_has_green[node] = is_green or any(
+            subtree_has_green.get(child, False) for child in children
+        )
+
+    red_markings = {
+        node for node in tree.nodes if not subtree_has_green.get(node, False)
+    }
     # Make the path as short as possible. If we reach a red state, we stop and
     # do not go further in the "red zone".
-    queue = set()
-    queue.add(0)
-    paths = {}
-    paths[0] = []
+    queue = deque()
+    queue.append((0, []))
     paths_to_red = []
-    while len(queue) > 0:
-        v = queue.pop()
-        successors = (
-            woflan_object.get_restricted_coverability_tree().successors(v)
-        )
+    while queue:
+        v, path = queue.popleft()
+        if v in red_markings:
+            paths_to_red.append(path)
+            continue
+        successors = tree.successors(v)
         for suc in successors:
-            paths[suc] = paths[v].copy()
-            paths[suc].append(
-                woflan_object.get_restricted_coverability_tree().get_edge_data(
-                    v, suc
-                )["transition"]
-            )
-            if suc in red_markings:
-                paths_to_red.append(paths[suc])
-            else:
-                queue.add(suc)
+            edge_data = tree.get_edge_data(v, suc)
+            transition = edge_data["transition"] if edge_data else None
+            next_path = path + [transition]
+            queue.append((suc, next_path))
     return paths_to_red