Merge branch 'integration' into 212-process-tree-to-powl-converter-utility

fit-alessandro-berti · fit-alessandro-berti · commit 1f38c8512eb0 · 2024-02-07T07:41:53.000+01:00
diff --git a/pm4py/algo/discovery/powl/inductive/cuts/concurrency.py b/pm4py/algo/discovery/powl/inductive/cuts/concurrency.py
@@ -1,5 +1,5 @@
 from abc import ABC
-from typing import Any, Optional, Dict, Generic
+from typing import Any, Optional, Dict, Generic, Tuple, List
 
 from pm4py.algo.discovery.inductive.cuts.concurrency import ConcurrencyCut, ConcurrencyCutUVCL, T
 from pm4py.algo.discovery.inductive.dtypes.im_ds import IMDataStructureUVCL
@@ -10,7 +10,16 @@ class POWLConcurrencyCut(ConcurrencyCut, ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> StrictPartialOrder:
-        return StrictPartialOrder([])
+        raise Exception("This function should not be called!")
+
+    @classmethod
+    def apply(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[Tuple[StrictPartialOrder, List[T]]]:
+        g = cls.holds(obj, parameters)
+        if g is None:
+            return g
+        else:
+            children = cls.project(obj, g, parameters)
+            return StrictPartialOrder(children), children
 
 
 class POWLConcurrencyCutUVCL(ConcurrencyCutUVCL, POWLConcurrencyCut[IMDataStructureUVCL]):
diff --git a/pm4py/algo/discovery/powl/inductive/cuts/loop.py b/pm4py/algo/discovery/powl/inductive/cuts/loop.py
@@ -1,17 +1,26 @@
 from abc import ABC
-from typing import Optional, Any, Dict, Generic
+from typing import Optional, Any, Dict, Generic, List, Tuple
 
 from pm4py.algo.discovery.inductive.cuts.loop import LoopCut, LoopCutUVCL, T
 from pm4py.algo.discovery.inductive.dtypes.im_ds import IMDataStructureUVCL
-from pm4py.objects.powl.obj import OperatorPOWL
+from pm4py.objects.powl.obj import OperatorPOWL, POWL
 from pm4py.objects.process_tree.obj import Operator
 
 
 class POWLLoopCut(LoopCut, ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> OperatorPOWL:
-        return OperatorPOWL(Operator.LOOP, [])
+        raise Exception("This function should not be called!")
+
+    @classmethod
+    def apply(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[Tuple[POWL, List[T]]]:
+        g = cls.holds(obj, parameters)
+        if g is None:
+            return g
+        else:
+            children = cls.project(obj, g, parameters)
+            return OperatorPOWL(Operator.LOOP, children), children
 
 
 class POWLLoopCutUVCL(LoopCutUVCL, POWLLoopCut[IMDataStructureUVCL]):
diff --git a/pm4py/algo/discovery/powl/inductive/cuts/sequence.py b/pm4py/algo/discovery/powl/inductive/cuts/sequence.py
@@ -12,7 +12,7 @@ class POWLSequenceCut(SequenceCut, ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> Sequence:
-        return Sequence([])
+        raise Exception("This function should not be called!")
 
     @classmethod
     def apply(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[Tuple[Sequence, List[T]]]:
diff --git a/pm4py/algo/discovery/powl/inductive/cuts/xor.py b/pm4py/algo/discovery/powl/inductive/cuts/xor.py
@@ -1,17 +1,26 @@
 from abc import ABC
-from typing import Optional, Any, Dict, Generic
+from typing import Optional, Any, Dict, Generic, Tuple, List
 
 from pm4py.algo.discovery.inductive.cuts.xor import ExclusiveChoiceCut, ExclusiveChoiceCutUVCL, T
 from pm4py.algo.discovery.inductive.dtypes.im_ds import IMDataStructureUVCL
-from pm4py.objects.powl.obj import OperatorPOWL
+from pm4py.objects.powl.obj import OperatorPOWL, POWL
 from pm4py.objects.process_tree.obj import Operator
 
 
 class POWLExclusiveChoiceCut(ExclusiveChoiceCut, ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> OperatorPOWL:
-        return OperatorPOWL(Operator.XOR, [])
+        raise Exception("This function should not be called!")
+
+    @classmethod
+    def apply(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[Tuple[POWL, List[T]]]:
+        g = cls.holds(obj, parameters)
+        if g is None:
+            return g
+        else:
+            children = cls.project(obj, g, parameters)
+            return OperatorPOWL(Operator.XOR, children), children
 
 
 class POWLExclusiveChoiceCutUVCL(ExclusiveChoiceCutUVCL, POWLExclusiveChoiceCut[IMDataStructureUVCL], ABC):
diff --git a/pm4py/algo/discovery/powl/inductive/fall_through/activity_concurrent.py b/pm4py/algo/discovery/powl/inductive/fall_through/activity_concurrent.py
@@ -22,4 +22,5 @@ def apply(cls, obj: IMDataStructureUVCL, pool: Pool = None, manager: Manager = N
         for t in log:
             l_a.update({tuple(filter(lambda e: e == candidate, t)): log[t]})
             l_other.update({tuple(filter(lambda e: e != candidate, t)): log[t]})
-        return StrictPartialOrder([]), [IMDataStructureUVCL(l_a), IMDataStructureUVCL(l_other)]
+        children = [IMDataStructureUVCL(l_a), IMDataStructureUVCL(l_other)]
+        return StrictPartialOrder(children), children
diff --git a/pm4py/algo/discovery/powl/inductive/fall_through/activity_once_per_trace.py b/pm4py/algo/discovery/powl/inductive/fall_through/activity_once_per_trace.py
@@ -1,6 +1,28 @@
+from collections import Counter
+from typing import Optional, Tuple, List, Any, Dict
+
+from pm4py.algo.discovery.inductive.dtypes.im_ds import IMDataStructureUVCL
 from pm4py.algo.discovery.inductive.fall_through.activity_once_per_trace import ActivityOncePerTraceUVCL
 from pm4py.algo.discovery.powl.inductive.fall_through.activity_concurrent import POWLActivityConcurrentUVCL
+from pm4py.objects.powl.obj import StrictPartialOrder
+from pm4py.objects.process_tree.obj import ProcessTree, Operator
 
 
 class POWLActivityOncePerTraceUVCL(ActivityOncePerTraceUVCL, POWLActivityConcurrentUVCL):
-    pass
+    @classmethod
+    def apply(cls, obj: IMDataStructureUVCL,
+              pool=None,
+              manager=None,
+              parameters: Optional[Dict[str, Any]] = None) -> Optional[Tuple[StrictPartialOrder, List[IMDataStructureUVCL]]]:
+
+        candidate = cls._get_candidate(obj, pool, manager, parameters)
+        if candidate is None:
+            return None
+        log = obj.data_structure
+        l_a = Counter()
+        l_other = Counter()
+        for t in log:
+            l_a.update({tuple(filter(lambda e: e == candidate, t)): log[t]})
+            l_other.update({tuple(filter(lambda e: e != candidate, t)): log[t]})
+        children = [IMDataStructureUVCL(l_a), IMDataStructureUVCL(l_other)]
+        return StrictPartialOrder(children), children
diff --git a/pm4py/algo/discovery/powl/inductive/fall_through/empty_traces.py b/pm4py/algo/discovery/powl/inductive/fall_through/empty_traces.py
@@ -18,7 +18,7 @@ def apply(cls, obj: IMDataStructureUVCL, pool: Pool = None, manager: Manager = N
         if cls.holds(obj, parameters):
             data_structure = copy(obj.data_structure)
             del data_structure[()]
-            return OperatorPOWL(Operator.XOR, []), [IMDataStructureUVCL(Counter()),
-                                                        IMDataStructureUVCL(data_structure)]
+            children = [IMDataStructureUVCL(Counter()), IMDataStructureUVCL(data_structure)]
+            return OperatorPOWL(Operator.XOR, children), children
         else:
             return None
diff --git a/pm4py/algo/discovery/powl/inductive/fall_through/flower.py b/pm4py/algo/discovery/powl/inductive/fall_through/flower.py
@@ -21,6 +21,7 @@ def apply(cls, obj: IMDataStructureUVCL, pool: Pool = None, manager: Manager = N
         uvcl_redo = UVCL()
         im_uvcl_do = IMDataStructureUVCL(uvcl_do)
         im_uvcl_redo = IMDataStructureUVCL(uvcl_redo)
-        return OperatorPOWL(Operator.LOOP, []), [im_uvcl_do, im_uvcl_redo]
+        children = [im_uvcl_do, im_uvcl_redo]
+        return OperatorPOWL(Operator.LOOP, children), children
 
 
diff --git a/pm4py/algo/discovery/powl/inductive/fall_through/strict_tau_loop.py b/pm4py/algo/discovery/powl/inductive/fall_through/strict_tau_loop.py
@@ -15,5 +15,6 @@ def apply(cls, obj: IMDataStructureUVCL, pool: Pool = None, manager: Manager = N
         log = obj.data_structure
         proj = cls._get_projected_log(log)
         if sum(proj.values()) > sum(log.values()):
-            return OperatorPOWL(Operator.LOOP, []), [IMDataStructureUVCL(proj), IMDataStructureUVCL(Counter())]
+            children = [IMDataStructureUVCL(proj), IMDataStructureUVCL(Counter())]
+            return OperatorPOWL(Operator.LOOP, children), children
 
diff --git a/pm4py/algo/discovery/powl/inductive/variants/brute_force/bf_partial_order_cut.py b/pm4py/algo/discovery/powl/inductive/variants/brute_force/bf_partial_order_cut.py
@@ -154,7 +154,7 @@ class BruteForcePartialOrderCut(Cut[T], ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> StrictPartialOrder:
-        return StrictPartialOrder([])
+        raise Exception("This function should not be called!")
 
     @classmethod
     def holds(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[BinaryRelation]:
diff --git a/pm4py/algo/discovery/powl/inductive/variants/dynamic_clustering/dynamic_clustering_partial_order_cut.py b/pm4py/algo/discovery/powl/inductive/variants/dynamic_clustering/dynamic_clustering_partial_order_cut.py
@@ -116,7 +116,7 @@ class DynamicClusteringPartialOrderCut(Cut[T], ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> StrictPartialOrder:
-        return StrictPartialOrder([])
+        raise Exception("This function should not be called!")
 
     @classmethod
     def holds(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[BinaryRelation]:
diff --git a/pm4py/algo/discovery/powl/inductive/variants/dynamic_clustering_frequency/dynamic_clustering_frequency_partial_order_cut.py b/pm4py/algo/discovery/powl/inductive/variants/dynamic_clustering_frequency/dynamic_clustering_frequency_partial_order_cut.py
@@ -131,7 +131,7 @@ class DynamicClusteringFrequencyPartialOrderCut(Cut[T], ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> StrictPartialOrder:
-        return StrictPartialOrder([])
+        raise Exception("This function should not be called!")
 
     @classmethod
     def holds(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[BinaryRelation]:
diff --git a/pm4py/algo/discovery/powl/inductive/variants/im_tree.py b/pm4py/algo/discovery/powl/inductive/variants/im_tree.py
@@ -13,7 +13,7 @@
     DEFAULT_FILTERING_TYPE
 from pm4py.algo.discovery.powl.inductive.variants.powl_discovery_varaints import POWLDiscoveryVariant
 
-from pm4py.objects.powl.obj import POWL, StrictPartialOrder, Sequence
+from pm4py.objects.powl.obj import POWL, StrictPartialOrder, Sequence, OperatorPOWL
 
 T = TypeVar('T', bound=IMDataStructureUVCL)
 
@@ -88,5 +88,5 @@ def _recurse(self, powl: POWL, objs: List[T], parameters: Optional[Dict[str, Any
                     powl_new.order.add_edge(children[j], children[i])
             return powl_new
         else:
-            powl.children.extend(children)
-            return powl
+            new_powl = OperatorPOWL(operator=powl.operator, children=children)
+            return new_powl
diff --git a/pm4py/algo/discovery/powl/inductive/variants/maximal/maximal_partial_order_cut.py b/pm4py/algo/discovery/powl/inductive/variants/maximal/maximal_partial_order_cut.py
@@ -126,7 +126,7 @@ class MaximalPartialOrderCut(Cut[T], ABC, Generic[T]):
 
     @classmethod
     def operator(cls, parameters: Optional[Dict[str, Any]] = None) -> StrictPartialOrder:
-        return StrictPartialOrder([])
+        raise Exception("This function should not be called!")
 
     @classmethod
     def holds(cls, obj: T, parameters: Optional[Dict[str, Any]] = None) -> Optional[BinaryRelation]:
diff --git a/pm4py/objects/powl/BinaryRelation.py b/pm4py/objects/powl/BinaryRelation.py
@@ -33,7 +33,7 @@ def add_edge(self, source: T, target: T) -> None:
             i = self._map_node_to_id[source]
             j = self._map_node_to_id[target]
         except Exception:
-            raise Exception("Unable to create edge! Invalid  source or target!")
+            raise Exception("Unable to add edge! Source or target not found!")
         else:
             self._edges[i][j] = True
 
diff --git a/pm4py/objects/powl/obj.py b/pm4py/objects/powl/obj.py
@@ -17,6 +17,61 @@ def simplify_using_frequent_transitions(self) -> "POWL":
     def simplify(self) -> "POWL":
         return self
 
+    def validate_partial_orders(self):
+        if isinstance(self, StrictPartialOrder):
+            if not self.order.is_irreflexive():
+                raise Exception("The irreflexivity of the partial order is violated!")
+            if not self.order.is_transitive():
+                raise Exception("The transitivity of the partial order is violated!")
+        if hasattr(self, 'children'):
+            for child in self.children:
+                child.validate_partial_orders()
+
+    def validate_partial_orders_with_missing_transitive_edges(self):
+        if isinstance(self, StrictPartialOrder):
+            if not self.order.is_irreflexive():
+                raise Exception("The irreflexivity of the partial order is violated!")
+            if not self.order.is_transitive():
+                self.order.add_transitive_edges()
+                if not self.order.is_irreflexive():
+                    raise Exception("The transitive closure of the provided relation violates irreflexivity!")
+        if hasattr(self, 'children'):
+            for child in self.children:
+                child.validate_partial_orders_with_missing_transitive_edges()
+
+    def validate_unique_transitions(self) -> TList[Union["Transition", "SilentTransition"]]:
+        def _find_duplicates(lst):
+            counts = {}
+            duplicates = []
+            for item in lst:
+                if item in counts:
+                    counts[item] += 1
+                    if counts[item] == 2:
+                        duplicates.append(item)
+                else:
+                    counts[item] = 1
+            return duplicates
+
+        def _collect_leaves(node: "POWL"):
+            if isinstance(node, Transition) or isinstance(node, SilentTransition):
+                return [node]
+
+            elif hasattr(node, 'children'):
+                leaves = []
+                for child in node.children:
+                    leaves = leaves + _collect_leaves(child)
+                return leaves
+            else:
+                raise Exception(
+                    "Unknown model type! The following model is not a transition and has no children: " + str(node))
+
+        transitions = _collect_leaves(self)
+        duplicate_transitions = _find_duplicates(transitions)
+        if len(duplicate_transitions) > 0:
+            raise Exception("Each of the following transitions occurs in multiple submodels: "
+                            + str([t.label if t.label else "silent transition" for t in duplicate_transitions]))
+        return transitions
+
     @staticmethod
     def model_description() -> str:
         descr = """A partially ordered workflow language (POWL) is a partially ordered graph representation of a process, extended with control-flow operators for modeling choice and loop structures. There are four types of POWL models:
@@ -228,6 +283,9 @@ def connected(node):
                         res.partial_order.add_edge(node_1, node_2)
         return res
 
+    def add_edge(self, source, target):
+        return self.order.add_edge(source, target)
+
 
 class Sequence(StrictPartialOrder):
 
@@ -240,6 +298,14 @@ def __init__(self, nodes: TList[POWL]) -> None:
 
 class OperatorPOWL(POWL):
     def __init__(self, operator: Operator, children: TList[POWL]) -> None:
+        if operator is Operator.XOR:
+            if len(children) < 2:
+                raise Exception("Cannot create a choice of less than 2 submodels!")
+        elif operator is Operator.LOOP:
+            if len(children) != 2:
+                raise Exception("Only loops of length 2 are supported!")
+        else:
+            raise Exception("Unsupported Operator!")
         super().__init__()
         self.operator = operator
         self.children = children
