feat(pm4py): preparing for 2.2.27

Author: fit-alessandro-berti

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog of pm4py
 
+## pm4py 2.2.27 (2022.08.XX)
+
+### Added
+* 58e266610e82cfcc41868313f7b9ccfd9975d49c
+  * discover_objects_graph utility for OCELs.
+
+### Changed
+* 1cbd37ac4b54a4c0e943b506ed685435f003640b
+  * performance improvement batch detection on Pandas dataframes.
+* 94dd96e0095f7cb1ef8d1eb48bd3da0a3cd85793
+  * minor changes to DFG variants simulation.
+
+### Deprecated
+
+### Fixed
+* 98fd3c740d8b6ae2dfde4d7a018f181030f22175
+  * fixed reflexivity in EventLog eventually_follows filter.
+* 9423897cdf0ea293ff1b032a0d4fa49ba746709c
+  * fixed chunk_regex XES importer.
+
+### Removed
+
+### Other
+
 ## pm4py 2.2.26 (2022.08.05)
 
 ### Added
@@ -8,6 +32,7 @@
 
 ### Changed
 * 5c06d520182317d140bd1b82d9d986c3edc81cf7
+  6a2eb404ba240b2c04eb91e7cf1407f72c5ae3e5
   * minor fixes to DFG simulation
 * fe1aa9c5efa7dc274e728a769625a784d7f87c6f
   * added default option for background color setup

docs/source/conf.py

@@ -26,7 +26,7 @@
 # The short X.Y version
 version = '2.2'
 # The full version, including alpha/beta/rc tags
-release = '2.2.26'
+release = '2.2.27'
 
 # -- General configuration ---------------------------------------------------
 

pm4py/__init__.py

@@ -61,6 +61,6 @@
 from pm4py.write import write_xes, write_petri_net, write_process_tree, write_dfg, write_bpmn, write_pnml, write_ptml, write_ocel
 from pm4py.org import discover_handover_of_work_network, discover_activity_based_resource_similarity, discover_subcontracting_network, discover_working_together_network, discover_organizational_roles, discover_network_analysis
 from pm4py.ml import split_train_test, get_prefixes_from_log
-from pm4py.ocel import ocel_get_object_types, ocel_get_attribute_names, ocel_flattening, ocel_object_type_activities, ocel_objects_ot_count, ocel_temporal_summary, ocel_objects_summary
+from pm4py.ocel import ocel_get_object_types, ocel_get_attribute_names, ocel_flattening, ocel_object_type_activities, ocel_objects_ot_count, ocel_temporal_summary, ocel_objects_summary, discover_objects_graph
 
 time.clock = time.process_time

pm4py/algo/discovery/batches/utils/detection.py

@@ -18,6 +18,8 @@
 from typing import Tuple, List, Any, Set, Optional, Dict, Union
 
 from pm4py.util import exec_utils
+import heapq
+from copy import copy
 
 
 class Parameters(Enum):
@@ -78,18 +80,15 @@ def __merge_near_intervals(intervals: List[Tuple[float, float, Set[Any]]], max_a
                 # decide to merge interval i and i+1
                 new_interval = (min(intervals[i][0], intervals[i + 1][0]), max(intervals[i][1], intervals[i + 1][1]),
                                 intervals[i][2].union(intervals[i + 1][2]))
-                # add the new interval to the list
-                intervals.append(new_interval)
                 # remove the i+1 interval
                 del intervals[i + 1]
                 # remove the i interval
                 del intervals[i]
-                # sort the intervals
-                intervals.sort()
+                # add the new interval to the list
+                heapq.heappush(intervals, new_interval)
                 # set the variable continue_cycle to True
                 continue_cycle = True
-                # interrupt the current iteration on the intervals
-                break
+                i = i - 1
             i = i + 1
     return intervals
 
@@ -152,9 +151,9 @@ def __detect_single(events: List[Tuple[float, float, str]], parameters: Optional
     merge_distance = exec_utils.get_param_value(Parameters.MERGE_DISTANCE, parameters, 15 * 60)
     min_batch_size = exec_utils.get_param_value(Parameters.MIN_BATCH_SIZE, parameters, 2)
 
-    intervals = [(e[0], e[1], {(e[0], e[1], e[2])}) for e in
+    intervals = [(e[0], e[1], {copy(e)}) for e in
                  events]
-    intervals.sort()
+    heapq.heapify(intervals)
     intervals = __merge_overlapping_intervals(intervals)
     intervals = __merge_near_intervals(intervals, merge_distance)
     batches = [x for x in intervals if len(x[2]) >= min_batch_size]

pm4py/algo/discovery/batches/variants/pandas.py

@@ -21,6 +21,7 @@
 
 from pm4py.algo.discovery.batches.utils import detection
 from pm4py.util import exec_utils, constants, xes_constants
+import numpy as np
 
 
 class Parameters(Enum):
@@ -29,6 +30,7 @@ class Parameters(Enum):
     START_TIMESTAMP_KEY = constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY
     TIMESTAMP_KEY = constants.PARAMETER_CONSTANT_TIMESTAMP_KEY
     CASE_ID_KEY = constants.PARAMETER_CONSTANT_CASEID_KEY
+    EVENT_ID_KEY = "event_id_key"
     MERGE_DISTANCE = "merge_distance"
     MIN_BATCH_SIZE = "min_batch_size"
 
@@ -84,22 +86,38 @@ def apply(log: pd.DataFrame, parameters: Optional[Dict[Union[str, Parameters], A
     start_timestamp_key = exec_utils.get_param_value(Parameters.START_TIMESTAMP_KEY, parameters,
                                                      timestamp_key)
     case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, constants.CASE_CONCEPT_NAME)
+    event_id_key = exec_utils.get_param_value(Parameters.EVENT_ID_KEY, parameters, constants.DEFAULT_INDEX_KEY)
 
-    log = log[list({activity_key, resource_key, start_timestamp_key, timestamp_key, case_id_key})]
-    events = log.to_dict('records')
+    attributes_to_consider = {activity_key, resource_key, start_timestamp_key, timestamp_key, case_id_key}
+    log_contains_evidkey = event_id_key in log
+    if log_contains_evidkey:
+        attributes_to_consider.add(event_id_key)
 
-    actres_grouping = {}
-
-    for ev in events:
-        case = ev[case_id_key]
-        activity = ev[activity_key]
-        resource = ev[resource_key]
-        st = ev[start_timestamp_key].timestamp()
-        et = ev[timestamp_key].timestamp()
+    log = log[list(attributes_to_consider)]
+    log[timestamp_key] = log[timestamp_key].values.astype(np.int64) // 10**9
+    if start_timestamp_key != timestamp_key:
+        log[start_timestamp_key] = log[start_timestamp_key].values.astype(np.int64) // 10**9
 
-        if (activity, resource) not in actres_grouping:
-            actres_grouping[(activity, resource)] = []
+    actres_grouping0 = log.groupby([activity_key, resource_key]).agg(list).to_dict()
+    start_timestamps = actres_grouping0[start_timestamp_key]
+    complete_timestamps = actres_grouping0[timestamp_key]
+    cases = actres_grouping0[case_id_key]
+    if log_contains_evidkey:
+        events_ids = actres_grouping0[event_id_key]
 
-        actres_grouping[(activity, resource)].append((st, et, case))
+    actres_grouping = {}
+    for k in start_timestamps:
+        st = start_timestamps[k]
+        et = complete_timestamps[k]
+        c = cases[k]
+        if log_contains_evidkey:
+            eid = events_ids[k]
+        actres_grouping_k = []
+        for i in range(len(st)):
+            if log_contains_evidkey:
+                actres_grouping_k.append((st[i], et[i], c[i], eid[i]))
+            else:
+                actres_grouping_k.append((st[i], et[i], c[i]))
+        actres_grouping[k] = actres_grouping_k
 
     return detection.detect(actres_grouping, parameters=parameters)

pm4py/algo/filtering/log/ltl/ltl_checker.py

@@ -326,7 +326,7 @@ def eventually_follows(log: EventLog, attribute_values: List[str], parameters: O
         for c in itertools.product(*occurrences):
             ok = True
             for i in range(len(c)-1):
-                if c[i] > c[i+1]:
+                if c[i] >= c[i+1]:
                     ok = False
                     break
             if ok:

pm4py/algo/simulation/playout/dfg/variants/classic.py

@@ -206,11 +206,17 @@ def apply(dfg: Dict[Tuple[str, str], int], start_activities: Dict[str, int], end
     overall_probability = 0.0
 
     final_traces = []
+    max_occ = 0
 
     start_time = time.time()
     for tr, p in get_traces(dfg, start_activities, end_activities, parameters=parameters):
-        if (interrupt_simulation_when_dfg_complete and interrupt_break_condition) or not (
-                len(final_traces) < max_no_variants and overall_probability <= min_weighted_probability):
+        if interrupt_simulation_when_dfg_complete and interrupt_break_condition:
+            break
+        if len(final_traces) >= max_no_variants:
+            interrupted = True
+            break
+        if overall_probability > min_weighted_probability:
+            interrupted = True
             break
         current_time = time.time()
         if (current_time - start_time) > max_execution_time:
@@ -236,6 +242,10 @@ def apply(dfg: Dict[Tuple[str, str], int], start_activities: Dict[str, int], end
         diff_original_dfg = set(dfg).difference(simulated_traces_dfg)
         interrupt_break_condition = len(diff_original_sa) == 0 and len(diff_original_ea) == 0 and len(
             diff_original_dfg) == 0
+        var_occ = math.ceil(p * max_no_variants)
+        max_occ = max(max_occ, var_occ)
+        if var_occ < min_variant_occ <= max_occ:
+            break
         final_traces.append((-p, tr))
         if interrupt_simulation_when_dfg_complete and interrupt_break_condition:
             break
@@ -248,12 +258,8 @@ def apply(dfg: Dict[Tuple[str, str], int], start_activities: Dict[str, int], end
     if return_variants:
         # returns the variants instead of the log
         variants = {}
-        max_occ = 0
         for p, tr in final_traces:
             var_occ = math.ceil(-p * max_no_variants)
-            max_occ = max(max_occ, var_occ)
-            if max_occ >= min_variant_occ and var_occ < min_variant_occ:
-                break
             variants[tr] = var_occ
 
         if not (interrupted and return_only_if_complete):

pm4py/meta.py

@@ -15,7 +15,7 @@
     along with PM4Py.  If not, see <https://www.gnu.org/licenses/>.
 '''
 __name__ = 'pm4py'
-VERSION = '2.2.26'
+VERSION = '2.2.27'
 __version__ = VERSION
 __doc__ = 'Process Mining for Python (PM4Py)'
 __author__ = 'Fraunhofer Institute for Applied Technology'

pm4py/objects/log/importer/xes/variants/chunk_regex.py

@@ -93,6 +93,7 @@ def import_log_from_file_object(F, encoding, file_size=sys.maxsize, parameters=N
                 if idx > -1:
                     tag = el[:idx]
                     el = el.split('\"')
+                    el[-1] = el[-1].strip()
                     if tag == "string":
                         curr_els_attrs[-1][el[1]] = el[3]
                         if el[-1] != '/':

pm4py/ocel.py

@@ -15,7 +15,7 @@
     along with PM4Py.  If not, see <https://www.gnu.org/licenses/>.
 '''
 
-from typing import List, Dict, Collection
+from typing import List, Dict, Collection, Set, Tuple
 
 import pandas as pd
 
@@ -180,3 +180,35 @@ def ocel_objects_summary(ocel: OCEL) -> pd.DataFrame:
                     graph[o1].add(o2)
     objects_summary["interacting_objects"] = objects_summary[ocel.object_id_column].map(graph)
     return objects_summary
+
+
+def discover_objects_graph(ocel: OCEL, graph_type: str = "object_interaction") -> Set[Tuple[str, str]]:
+    """
+    Discovers an object graph from the provided object-centric event log
+
+    :param ocel: object-centric event log
+    :param graph_type: type of graph to consider (object_interaction, object_descendants, object_inheritance, object_cobirth, object_codeath)
+    :rtype: ``Dict[str, Any]``
+
+    .. code-block:: python3
+
+        import pm4py
+
+        ocel = pm4py.read_ocel('trial.ocel')
+        obj_graph = pm4py.ocel_discover_objects_graph(ocel, graph_type='object_interaction')
+    """
+    if graph_type == "object_interaction":
+        from pm4py.algo.transformation.ocel.graphs import object_interaction_graph
+        return object_interaction_graph.apply(ocel)
+    elif graph_type == "object_descendants":
+        from pm4py.algo.transformation.ocel.graphs import object_descendants_graph
+        return object_descendants_graph.apply(ocel)
+    elif graph_type == "object_inheritance":
+        from pm4py.algo.transformation.ocel.graphs import object_inheritance_graph
+        return object_inheritance_graph.apply(ocel)
+    elif graph_type == "object_cobirth":
+        from pm4py.algo.transformation.ocel.graphs import object_cobirth_graph
+        return object_cobirth_graph.apply(ocel)
+    elif graph_type == "object_codeath":
+        from pm4py.algo.transformation.ocel.graphs import object_codeath_graph
+        return object_codeath_graph.apply(ocel)