Spaces:
Sleeping
Sleeping
| import importlib.util | |
| import os | |
| import unittest | |
| import pm4py | |
| from pm4py.objects.bpmn.obj import BPMN | |
| from pm4py.objects.petri_net.obj import PetriNet | |
| from pm4py.objects.process_tree.obj import ProcessTree | |
| from pm4py.util import constants, pandas_utils | |
| from pm4py.objects.log.util import dataframe_utils | |
| from pm4py.objects.log.importer.xes import importer as xes_importer | |
| class SimplifiedInterfaceTest(unittest.TestCase): | |
| def test_csv(self): | |
| df = pandas_utils.read_csv("input_data/running-example.csv") | |
| df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["time:timestamp"]) | |
| df["case:concept:name"] = df["case:concept:name"].astype("string") | |
| log2 = pm4py.convert_to_event_log(df) | |
| stream1 = pm4py.convert_to_event_stream(log2) | |
| df2 = pm4py.convert_to_dataframe(log2) | |
| pm4py.write_xes(log2, "test_output_data/log.xes") | |
| os.remove("test_output_data/log.xes") | |
| def test_alpha_miner(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_alpha(log) | |
| def test_alpha_miner_plus(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_alpha_plus(log) | |
| def test_inductive_miner(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| def test_inductive_miner_noise(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log, noise_threshold=0.5) | |
| def test_heuristics_miner(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_heuristics(log) | |
| def test_inductive_miner_tree(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| tree = pm4py.discover_process_tree_inductive(log) | |
| tree = pm4py.discover_process_tree_inductive(log, noise_threshold=0.2) | |
| def test_heuristics_miner_heu_net(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| heu_net = pm4py.discover_heuristics_net(log) | |
| def test_dfg(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| dfg, sa, ea = pm4py.discover_directly_follows_graph(log) | |
| def test_read_petri(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| def test_read_tree(self): | |
| tree = pm4py.read_ptml("input_data/running-example.ptml") | |
| def test_read_dfg(self): | |
| dfg, sa, ea = pm4py.read_dfg("input_data/running-example.dfg") | |
| def test_alignments_simpl_interface(self): | |
| for legacy_obj in [True, False]: | |
| for diagn_df in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| aligned_traces = pm4py.conformance_diagnostics_alignments(log, net, im, fm, return_diagnostics_dataframe=diagn_df) | |
| def test_tbr_simpl_interface(self): | |
| for legacy_obj in [True, False]: | |
| for diagn_df in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| replayed_traces = pm4py.conformance_diagnostics_token_based_replay(log, net, im, fm, return_diagnostics_dataframe=diagn_df) | |
| def test_fitness_alignments(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| fitness_ali = pm4py.fitness_alignments(log, net, im, fm) | |
| def test_fitness_tbr(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| fitness_tbr = pm4py.fitness_token_based_replay(log, net, im, fm) | |
| def test_precision_alignments(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| precision_ali = pm4py.precision_alignments(log, net, im, fm) | |
| def test_precision_tbr(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| precision_tbr = pm4py.precision_token_based_replay(log, net, im, fm) | |
| def test_convert_to_tree_from_petri(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| tree = pm4py.convert_to_process_tree(net, im, fm) | |
| self.assertTrue(isinstance(tree, ProcessTree)) | |
| def test_convert_to_tree_from_bpmn(self): | |
| bpmn = pm4py.read_bpmn("input_data/running-example.bpmn") | |
| tree = pm4py.convert_to_process_tree(bpmn) | |
| self.assertTrue(isinstance(tree, ProcessTree)) | |
| def test_convert_to_net_from_tree(self): | |
| tree = pm4py.read_ptml("input_data/running-example.ptml") | |
| net, im, fm = pm4py.convert_to_petri_net(tree) | |
| self.assertTrue(isinstance(net, PetriNet)) | |
| def test_convert_to_net_from_bpmn(self): | |
| bpmn = pm4py.read_bpmn("input_data/running-example.bpmn") | |
| net, im, fm = pm4py.convert_to_petri_net(bpmn) | |
| self.assertTrue(isinstance(net, PetriNet)) | |
| def test_convert_to_net_from_dfg(self): | |
| dfg, sa, ea = pm4py.read_dfg("input_data/running-example.dfg") | |
| net, im, fm = pm4py.convert_to_petri_net(dfg, sa, ea) | |
| self.assertTrue(isinstance(net, PetriNet)) | |
| def test_convert_to_net_from_heu(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| heu_net = pm4py.discover_heuristics_net(log) | |
| net, im, fm = pm4py.convert_to_petri_net(heu_net) | |
| self.assertTrue(isinstance(net, PetriNet)) | |
| def test_convert_to_bpmn_from_tree(self): | |
| tree = pm4py.read_ptml("input_data/running-example.ptml") | |
| bpmn = pm4py.convert_to_bpmn(tree) | |
| self.assertTrue(isinstance(bpmn, BPMN)) | |
| def test_statistics_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.get_start_activities(log) | |
| pm4py.get_end_activities(log) | |
| pm4py.get_event_attributes(log) | |
| pm4py.get_trace_attributes(log) | |
| pm4py.get_event_attribute_values(log, "org:resource") | |
| pm4py.get_variants_as_tuples(log) | |
| def test_statistics_df(self): | |
| df = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| df["CaseID"] = df["CaseID"].astype("string") | |
| pm4py.get_start_activities(df, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.get_end_activities(df, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.get_event_attributes(df) | |
| pm4py.get_event_attribute_values(df, "Resource", case_id_key="CaseID") | |
| pm4py.get_variants_as_tuples(df, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_playout(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| pm4py.play_out(net, im, fm) | |
| def test_generator(self): | |
| pm4py.generate_process_tree() | |
| def test_mark_em_equation(self): | |
| for legacy_obj in [True, False]: | |
| log = xes_importer.apply("input_data/running-example.xes") | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| sync_net, sync_im, sync_fm = pm4py.construct_synchronous_product_net(log[0], net, im, fm) | |
| m_h = pm4py.solve_marking_equation(sync_net, sync_im, sync_fm) | |
| em_h = pm4py.solve_extended_marking_equation(log[0], sync_net, sync_im, sync_fm) | |
| def test_new_statistics_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.get_trace_attribute_values(log, "case:creator") | |
| pm4py.discover_eventually_follows_graph(log) | |
| pm4py.get_case_arrival_average(log) | |
| def test_new_statistics_df(self): | |
| df = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, | |
| timest_columns=["Timestamp"]) | |
| df["CaseID"] = df["CaseID"].astype("string") | |
| pm4py.discover_eventually_follows_graph(df, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.get_case_arrival_average(df, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_serialization_log(self): | |
| if importlib.util.find_spec("pyarrow"): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| ser = pm4py.serialize(log) | |
| log2 = pm4py.deserialize(ser) | |
| def test_serialization_dataframe(self): | |
| if importlib.util.find_spec("pyarrow"): | |
| df = pandas_utils.read_csv("input_data/running-example.csv") | |
| df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["time:timestamp"]) | |
| ser = pm4py.serialize(df) | |
| df2 = pm4py.deserialize(ser) | |
| def test_serialization_petri_net(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| ser = pm4py.serialize(net, im, fm) | |
| net2, im2, fm2 = pm4py.deserialize(ser) | |
| def test_serialization_process_tree(self): | |
| tree = pm4py.read_ptml("input_data/running-example.ptml") | |
| ser = pm4py.serialize(tree) | |
| tree2 = pm4py.deserialize(ser) | |
| def test_serialization_bpmn(self): | |
| bpmn = pm4py.read_bpmn("input_data/running-example.bpmn") | |
| ser = pm4py.serialize(bpmn) | |
| bpmn2 = pm4py.deserialize(ser) | |
| def test_serialization_dfg(self): | |
| dfg, sa, ea = pm4py.read_dfg("input_data/running-example.dfg") | |
| ser = pm4py.serialize(dfg, sa, ea) | |
| dfg2, sa2, ea2 = pm4py.deserialize(ser) | |
| def test_minimum_self_distance(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| msd = pm4py.get_minimum_self_distances(log) | |
| def test_minimum_self_distance_2(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| msd = pm4py.get_minimum_self_distance_witnesses(log) | |
| def test_marking_equation_net(self): | |
| import pm4py | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| pm4py.solve_marking_equation(net, im, fm) | |
| def test_marking_equation_sync_net(self): | |
| import pm4py | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| sync_net, sync_im, sync_fm = pm4py.construct_synchronous_product_net(log[0], net, im, fm) | |
| res = pm4py.solve_marking_equation(sync_net, sync_im, sync_fm) | |
| self.assertIsNotNone(res) | |
| self.assertEqual(res, 11) | |
| def test_ext_marking_equation_sync_net(self): | |
| import pm4py | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| sync_net, sync_im, sync_fm = pm4py.construct_synchronous_product_net(log[0], net, im, fm) | |
| res = pm4py.solve_extended_marking_equation(log[0], sync_net, sync_im, sync_fm) | |
| self.assertIsNotNone(res) | |
| def test_alignments_tree_simpl_interface(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| for diagn_df in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| tree = pm4py.read_ptml(os.path.join("input_data", "running-example.ptml")) | |
| res = pm4py.conformance_diagnostics_alignments(log, tree, return_diagnostics_dataframe=diagn_df) | |
| self.assertIsNotNone(res) | |
| def test_alignments_dfg_simpl_interface(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| for diagn_df in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| dfg, sa, ea = pm4py.read_dfg(os.path.join("input_data", "running-example.dfg")) | |
| res = pm4py.conformance_diagnostics_alignments(log, dfg, sa, ea, return_diagnostics_dataframe=diagn_df) | |
| self.assertIsNotNone(res) | |
| def test_alignments_bpmn_simpl_interface(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| for diagn_df in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| bpmn_graph = pm4py.read_bpmn(os.path.join("input_data", "running-example.bpmn")) | |
| res = pm4py.conformance_diagnostics_alignments(log, bpmn_graph, return_diagnostics_dataframe=diagn_df) | |
| self.assertIsNotNone(res) | |
| def test_discovery_inductive_bpmn(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| bpmn_graph = pm4py.discover_bpmn_inductive(log) | |
| self.assertIsNotNone(bpmn_graph) | |
| def test_generation(self): | |
| import pm4py | |
| tree = pm4py.generate_process_tree() | |
| self.assertIsNotNone(tree) | |
| def test_play_out_tree(self): | |
| import pm4py | |
| tree = pm4py.read_ptml(os.path.join("input_data", "running-example.ptml")) | |
| log = pm4py.play_out(tree) | |
| def test_play_out_net(self): | |
| import pm4py | |
| net, im, fm = pm4py.read_pnml(os.path.join("input_data", "running-example.pnml")) | |
| log = pm4py.play_out(net, im, fm) | |
| def test_msd(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| res1 = pm4py.get_minimum_self_distance_witnesses(log) | |
| res2 = pm4py.get_minimum_self_distances(log) | |
| self.assertIsNotNone(res1) | |
| self.assertIsNotNone(res2) | |
| def test_case_arrival(self): | |
| import pm4py | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"), return_legacy_log_object=legacy_obj) | |
| avg = pm4py.get_case_arrival_average(log) | |
| self.assertIsNotNone(avg) | |
| def test_efg(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_eventually_follows_graph(log) | |
| def test_write_pnml(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| pm4py.write_pnml(net, im, fm, "test_output_data/running-example.pnml") | |
| os.remove("test_output_data/running-example.pnml") | |
| def test_write_ptml(self): | |
| process_tree = pm4py.read_ptml("input_data/running-example.ptml") | |
| pm4py.write_ptml(process_tree, "test_output_data/running-example.ptml") | |
| os.remove("test_output_data/running-example.ptml") | |
| def test_write_dfg(self): | |
| dfg, sa, ea = pm4py.read_dfg("input_data/running-example.dfg") | |
| pm4py.write_dfg(dfg, sa, ea, "test_output_data/running-example.dfg") | |
| os.remove("test_output_data/running-example.dfg") | |
| def test_write_bpmn(self): | |
| bpmn_graph = pm4py.read_bpmn("input_data/running-example.bpmn") | |
| pm4py.write_bpmn(bpmn_graph, "test_output_data/running-example.bpmn") | |
| os.remove("test_output_data/running-example.bpmn") | |
| def test_rebase(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| df = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| dataframe = pm4py.rebase(dataframe, activity_key="Activity", case_id="CaseID", timestamp_key="Timestamp", timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT) | |
| def test_parse_process_tree(self): | |
| tree = pm4py.parse_process_tree("-> ( 'a', X ( 'b', 'c' ), tau )") | |
| def test_parse_log_string(self): | |
| elog = pm4py.parse_event_log_string(["A,B,C", "A,B,D"]) | |
| def test_project_eattr(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| lst = pm4py.project_on_event_attribute(log, "org:resource") | |
| def test_sample_cases_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.sample_cases(log, 2) | |
| def test_sample_cases_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.sample_cases(dataframe, 2, case_id_key="CaseID") | |
| def test_sample_events_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.sample_events(log, 2) | |
| def test_sample_events_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.sample_events(dataframe, 2) | |
| def test_check_soundness(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| self.assertTrue(pm4py.check_soundness(net, im, fm)) | |
| def test_check_wfnet(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| self.assertTrue(pm4py.check_is_workflow_net(net)) | |
| def test_artificial_start_end_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.insert_artificial_start_end(log) | |
| def test_artificial_start_end_dataframe(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.insert_artificial_start_end(dataframe, activity_key="Activity", timestamp_key="Timestamp", case_id_key="CaseID") | |
| def test_hof_filter_log(self): | |
| log = xes_importer.apply("input_data/running-example.xes") | |
| pm4py.filter_log(log, lambda x: len(x) > 5) | |
| def test_hof_filter_trace(self): | |
| log = xes_importer.apply("input_data/running-example.xes") | |
| pm4py.filter_trace(log[0], lambda x: x["concept:name"] == "decide") | |
| def test_hof_sort_log(self): | |
| log = xes_importer.apply("input_data/running-example.xes") | |
| pm4py.sort_log(log, key=lambda x: x.attributes["concept:name"]) | |
| def test_hof_sort_trace(self): | |
| log = xes_importer.apply("input_data/running-example.xes") | |
| pm4py.sort_trace(log[0], key=lambda x: x["concept:name"]) | |
| def test_split_train_test_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.split_train_test(log, train_percentage=0.6) | |
| def test_split_train_test_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.split_train_test(dataframe, train_percentage=0.6, case_id_key="CaseID") | |
| def test_get_prefixes_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.get_prefixes_from_log(log, 3) | |
| def test_get_prefixes_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.get_prefixes_from_log(dataframe, 3, case_id_key="CaseID") | |
| def test_convert_reachab(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| ts = pm4py.convert_to_reachability_graph(net, im, fm) | |
| def test_hw_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_handover_of_work_network(log) | |
| def test_hw_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_handover_of_work_network(dataframe, resource_key="Resource", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_wt_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_working_together_network(log) | |
| def test_wt_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_working_together_network(dataframe, resource_key="Resource", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_act_based_res_sim_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_activity_based_resource_similarity(log) | |
| def test_act_based_res_sim_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_activity_based_resource_similarity(dataframe, activity_key="Activity", resource_key="Resource", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_subcontracting_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_subcontracting_network(log) | |
| def test_subcontracting_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_subcontracting_network(dataframe, resource_key="Resource", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_roles_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_organizational_roles(log) | |
| def test_roles_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_organizational_roles(dataframe, activity_key="Activity", resource_key="Resource", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_network_analysis_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_network_analysis(log, "case:concept:name", "case:concept:name", "org:resource", "org:resource", "concept:name") | |
| def test_network_analysis_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_network_analysis(dataframe, "CaseID", "CaseID", "Resource", "Resource", "Activity", sorting_column="Timestamp", timestamp_column="Timestamp") | |
| def test_discover_batches_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_batches(log) | |
| def test_discover_batches_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_batches(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp", resource_key="Resource") | |
| def test_log_skeleton_log_simplified_interface(self): | |
| for legacy_obj in [True, False]: | |
| for diagn_df in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| model = pm4py.discover_log_skeleton(log) | |
| pm4py.conformance_log_skeleton(log, model, return_diagnostics_dataframe=diagn_df) | |
| def test_log_skeleton_df_simplified_interface(self): | |
| for diagn_df in [True, False]: | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, | |
| timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, | |
| timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| model = pm4py.discover_log_skeleton(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| pm4py.conformance_log_skeleton(dataframe, model, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp", return_diagnostics_dataframe=diagn_df) | |
| def test_temporal_profile_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| model = pm4py.discover_temporal_profile(log) | |
| pm4py.conformance_temporal_profile(log, model) | |
| def test_temporal_profile_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| model = pm4py.discover_temporal_profile(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| pm4py.conformance_temporal_profile(dataframe, model, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_ocel_get_obj_types(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.csv") | |
| pm4py.ocel_get_object_types(ocel) | |
| def test_ocel_get_attr_names(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.csv") | |
| pm4py.ocel_get_attribute_names(ocel) | |
| def test_ocel_flattening(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.csv") | |
| pm4py.ocel_flattening(ocel, "order") | |
| def test_stats_var_tuples_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.get_variants_as_tuples(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_stats_cycle_time_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.get_cycle_time(log) | |
| def test_stats_cycle_time_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.get_cycle_time(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_stats_case_durations_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.get_all_case_durations(log) | |
| def test_stats_case_durations_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.get_all_case_durations(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_stats_case_duration_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.get_case_duration(log, "1") | |
| def test_stats_case_duration_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.get_case_duration(dataframe, "1", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_stats_act_pos_summary_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.get_activity_position_summary(log, "check ticket") | |
| def test_stats_act_pos_summary_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.get_activity_position_summary(dataframe, "check ticket", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_act_done_diff_res_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_activity_done_different_resources(log, "check ticket") | |
| def test_filter_act_done_diff_res_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_activity_done_different_resources(dataframe, "check ticket", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp", resource_key="Resource") | |
| def test_filter_four_eyes_principle_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_four_eyes_principle(log, "register request", "check ticket") | |
| def test_filter_four_eyes_principle_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_four_eyes_principle(dataframe, "register request", "check ticket", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp", resource_key="Resource") | |
| def test_filter_rel_occ_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_log_relative_occurrence_event_attribute(log, 0.8, level="cases") | |
| def test_filter_rel_occ_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_log_relative_occurrence_event_attribute(dataframe, 0.8, attribute_key="Activity", level="cases", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_start_activities_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_start_activities(log, ["register request"]) | |
| def test_filter_start_activities_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_start_activities(dataframe, ["register request"], activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_end_activities_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_end_activities(log, ["pay compensation"]) | |
| def test_filter_end_activities_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_end_activities(dataframe, ["pay compensation"], activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_eve_attr_values_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_event_attribute_values(log, "concept:name", ["register request", "pay compensation", "reject request"]) | |
| def test_filter_eve_attr_values_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_event_attribute_values(dataframe, "Activity", ["register request", "pay compensation", "reject request"], case_id_key="CaseID") | |
| def test_filter_trace_attr_values_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_trace_attribute_values(log, "case:creator", ["Fluxicon"]) | |
| def test_filter_variant_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_variants(log, [('register request', 'examine casually', 'check ticket', 'decide', 'reinitiate request', 'examine thoroughly', 'check ticket', 'decide', 'pay compensation')]) | |
| def test_filter_variant_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_variants(dataframe, [('register request', 'examine casually', 'check ticket', 'decide', 'reinitiate request', 'examine thoroughly', 'check ticket', 'decide', 'pay compensation')], activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_dfg_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_directly_follows_relation(log, [("register request", "check ticket")]) | |
| def test_filter_dfg_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_directly_follows_relation(dataframe, [("register request", "check ticket")], activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_efg_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_eventually_follows_relation(log, [("register request", "check ticket")]) | |
| def test_filter_efg_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_eventually_follows_relation(dataframe, [("register request", "check ticket")], activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_time_range_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_time_range(log, "2009-01-01 01:00:00", "2011-01-01 01:00:00") | |
| def test_filter_time_range_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_time_range(dataframe, "2009-01-01 01:00:00", "2011-01-01 01:00:00", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_between_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_between(log, "check ticket", "decide") | |
| def test_filter_between_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_between(dataframe, "check ticket", "decide", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_case_size_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_case_size(log, 10, 20) | |
| def test_filter_case_size_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_case_size(dataframe, 10, 20, case_id_key="CaseID") | |
| def test_filter_case_performance_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_case_performance(log, 86400, 8640000) | |
| def test_filter_case_performance_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_case_performance(dataframe, 86400, 8640000, case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_activities_rework_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_activities_rework(log, "check ticket") | |
| def test_filter_act_rework_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_activities_rework(dataframe, "check ticket", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_paths_perf_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_paths_performance(log, ("register request", "check ticket"), 86400, 864000) | |
| def test_filter_paths_perf_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_paths_performance(dataframe, ("register request", "check ticket"), 86400, 864000, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_vars_top_k_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_variants_top_k(log, 1) | |
| def test_filter_vars_top_k_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_variants_top_k(dataframe, 1, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_vars_coverage(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_variants_by_coverage_percentage(log, 0.1) | |
| def test_filter_vars_coverage(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_variants_by_coverage_percentage(dataframe, 0.1, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_prefixes_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_prefixes(log, "check ticket") | |
| def test_filter_prefixes_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_prefixes(dataframe, "check ticket", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_filter_suffixes_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.filter_suffixes(log, "check ticket") | |
| def test_filter_suffixes_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.filter_suffixes(dataframe, "check ticket", activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_discover_perf_dfg_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_performance_dfg(log) | |
| def test_discover_perf_dfg_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_performance_dfg(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_discover_footprints_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_footprints(log) | |
| def test_discover_ts_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_transition_system(log) | |
| def test_discover_ts_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_transition_system(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_discover_pref_tree_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.discover_prefix_tree(log) | |
| def test_discover_pref_tree_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_prefix_tree(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| def test_discover_ocpn(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.csv") | |
| pm4py.discover_oc_petri_net(ocel) | |
| def test_conformance_alignments_pn_log_simplified_interface(self): | |
| for legacy_obj in [True, False]: | |
| for diagn_df in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| net, im, fm = pm4py.discover_petri_net_inductive(log) | |
| pm4py.conformance_diagnostics_alignments(log, net, im, fm, return_diagnostics_dataframe=diagn_df) | |
| def test_conformance_alignments_pn_df_simplified_interface(self): | |
| for diagn_df in [True, False]: | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, | |
| timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, | |
| timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| net, im, fm = pm4py.discover_petri_net_inductive(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| pm4py.conformance_diagnostics_alignments(dataframe, net, im, fm, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp", return_diagnostics_dataframe=diagn_df) | |
| def test_conformance_diagnostics_fp_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| tree = pm4py.discover_process_tree_inductive(log) | |
| pm4py.conformance_diagnostics_footprints(log, tree) | |
| def test_fitness_fp_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| tree = pm4py.discover_process_tree_inductive(log) | |
| pm4py.fitness_footprints(log, tree) | |
| def test_precision_fp_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| tree = pm4py.discover_process_tree_inductive(log) | |
| pm4py.precision_footprints(log, tree) | |
| def test_maximal_decomposition(self): | |
| net, im, fm = pm4py.read_pnml("input_data/running-example.pnml") | |
| pm4py.maximal_decomposition(net, im, fm) | |
| def test_fea_ext_log(self): | |
| for legacy_obj in [True, False]: | |
| log = pm4py.read_xes("input_data/running-example.xes", return_legacy_log_object=legacy_obj) | |
| pm4py.extract_features_dataframe(log) | |
| def test_fea_ext_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.extract_features_dataframe(dataframe, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp", resource_key="Resource") | |
| def test_new_alpha_miner_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_petri_net_alpha(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_new_heu_miner_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_petri_net_heuristics(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_new_dfg_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_dfg(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_new_perf_dfg_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| pm4py.discover_performance_dfg(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_new_tbr_df_simpl_interface(self): | |
| for ret_df in [True, False]: | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, | |
| timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, | |
| timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| net, im, fm = pm4py.discover_petri_net_inductive(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.conformance_diagnostics_token_based_replay(dataframe, net, im, fm, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp", return_diagnostics_dataframe=ret_df) | |
| def test_new_tbr_fitness_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| net, im, fm = pm4py.discover_petri_net_inductive(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.fitness_token_based_replay(dataframe, net, im, fm, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_new_tbr_precision_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| net, im, fm = pm4py.discover_petri_net_inductive(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.precision_token_based_replay(dataframe, net, im, fm, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_new_align_df_simpl_interface(self): | |
| for diagn_df in [True, False]: | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, | |
| timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, | |
| timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| net, im, fm = pm4py.discover_petri_net_inductive(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.conformance_diagnostics_alignments(dataframe, net, im, fm, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp", return_diagnostics_dataframe=diagn_df) | |
| def test_new_align_fitness_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| net, im, fm = pm4py.discover_petri_net_inductive(dataframe, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| pm4py.fitness_alignments(dataframe, net, im, fm, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_new_align_precision_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| net, im, fm = pm4py.discover_petri_net_inductive(dataframe, case_id_key="CaseID", activity_key="Activity", | |
| timestamp_key="Timestamp") | |
| pm4py.precision_alignments(dataframe, net, im, fm, case_id_key="CaseID", activity_key="Activity", timestamp_key="Timestamp") | |
| def test_vis_case_duration_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| if importlib.util.find_spec("matplotlib"): | |
| target = os.path.join("test_output_data", "case_duration.svg") | |
| pm4py.save_vis_case_duration_graph(dataframe, target, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| os.remove(target) | |
| def test_vis_ev_distr_graph_df(self): | |
| dataframe = pandas_utils.read_csv("input_data/running-example-transformed.csv") | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["Timestamp"]) | |
| dataframe["CaseID"] = dataframe["CaseID"].astype("string") | |
| target = os.path.join("test_output_data", "ev_distr_graph.svg") | |
| if importlib.util.find_spec("matplotlib"): | |
| pm4py.save_vis_events_distribution_graph(dataframe, target, activity_key="Activity", case_id_key="CaseID", timestamp_key="Timestamp") | |
| os.remove(target) | |
| def test_ocel_object_graph(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| ev_graph = pm4py.discover_objects_graph(ocel, graph_type="object_interaction") | |
| ev_graph = pm4py.discover_objects_graph(ocel, graph_type="object_descendants") | |
| ev_graph = pm4py.discover_objects_graph(ocel, graph_type="object_inheritance") | |
| ev_graph = pm4py.discover_objects_graph(ocel, graph_type="object_cobirth") | |
| ev_graph = pm4py.discover_objects_graph(ocel, graph_type="object_codeath") | |
| def test_ocel_temporal_summary(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| temp_summary = pm4py.ocel_temporal_summary(ocel) | |
| def test_ocel_objects_summary(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| objects_summary = pm4py.ocel_objects_summary(ocel) | |
| def test_ocel_filtering_ev_ids(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| filtered_ocel = pm4py.filter_ocel_events(ocel, ["e1"]) | |
| def test_ocel_filtering_obj_ids(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| filtered_ocel = pm4py.filter_ocel_objects(ocel, ["o1"], level=1) | |
| filtered_ocel = pm4py.filter_ocel_objects(ocel, ["o1"], level=2) | |
| def test_ocel_filtering_obj_types(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| filtered_ocel = pm4py.filter_ocel_object_types(ocel, ["order"]) | |
| def test_ocel_filtering_cc(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| filtered_ocel = pm4py.filter_ocel_cc_object(ocel, "o1") | |
| def test_ocel_drop_duplicates(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| filtered_ocel = pm4py.ocel_drop_duplicates(ocel) | |
| def test_ocel_add_index_based_timedelta(self): | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| filtered_ocel = pm4py.ocel_add_index_based_timedelta(ocel) | |
| def test_ocel2_xml(self): | |
| ocel = pm4py.read_ocel2("input_data/ocel/ocel20_example.xmlocel") | |
| pm4py.write_ocel2(ocel, "test_output_data/ocel20_example.xmlocel") | |
| os.remove("test_output_data/ocel20_example.xmlocel") | |
| def test_ocel2_sqlite(self): | |
| ocel = pm4py.read_ocel2("input_data/ocel/ocel20_example.sqlite") | |
| pm4py.write_ocel2(ocel, "test_output_data/ocel20_example.sqlite") | |
| os.remove("test_output_data/ocel20_example.sqlite") | |
| if __name__ == "__main__": | |
| unittest.main() | |