Spaces:
Sleeping
Sleeping
| import os | |
| import unittest | |
| import importlib.util | |
| from pm4py.algo.discovery.log_skeleton import algorithm as lsk_alg | |
| from pm4py.algo.conformance.log_skeleton import algorithm as lsk_conf_alg | |
| from pm4py.objects.process_tree.importer import importer as ptree_importer | |
| from pm4py.objects.process_tree.exporter import exporter as ptree_exporter | |
| from pm4py.algo.discovery.performance_spectrum.variants import log as log_pspectrum, dataframe as df_pspectrum | |
| from pm4py.objects.dfg.importer import importer as dfg_importer | |
| from pm4py.objects.dfg.exporter import exporter as dfg_exporter | |
| from pm4py.algo.discovery.dfg import algorithm as dfg_discovery | |
| from pm4py.statistics.start_activities.log import get as start_activities | |
| from pm4py.statistics.end_activities.log import get as end_activities | |
| from pm4py.objects.log.importer.xes import importer as xes_importer | |
| from pm4py.algo.discovery.inductive import algorithm as inductive_miner | |
| from pm4py.statistics.variants.log import get as variants_get | |
| from pm4py.algo.simulation.playout.petri_net import algorithm | |
| from pm4py.objects.conversion.log import converter | |
| from pm4py.objects.log.util import dataframe_utils | |
| from pm4py.util import constants, pandas_utils | |
| from pm4py.objects.conversion.process_tree import converter as process_tree_converter | |
| class OtherPartsTests(unittest.TestCase): | |
| def test_emd_1(self): | |
| if importlib.util.find_spec("pyemd"): | |
| from pm4py.algo.evaluation.earth_mover_distance import algorithm as earth_mover_distance | |
| M = {("a", "b", "d", "e"): 0.49, ("a", "d", "b", "e"): 0.49, ("a", "c", "d", "e"): 0.01, | |
| ("a", "d", "c", "e"): 0.01} | |
| L1 = {("a", "b", "d", "e"): 0.49, ("a", "d", "b", "e"): 0.49, ("a", "c", "d", "e"): 0.01, | |
| ("a", "d", "c", "e"): 0.01} | |
| earth_mover_distance.apply(M, L1) | |
| def test_emd_2(self): | |
| if importlib.util.find_spec("pyemd"): | |
| from pm4py.algo.evaluation.earth_mover_distance import algorithm as earth_mover_distance | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| lang_log = variants_get.get_language(log) | |
| process_tree = inductive_miner.apply(log) | |
| net1, im1, fm1 = process_tree_converter.apply(process_tree) | |
| lang_model1 = variants_get.get_language( | |
| algorithm.apply(net1, im1, fm1, variant=algorithm.Variants.STOCHASTIC_PLAYOUT, | |
| parameters={algorithm.Variants.STOCHASTIC_PLAYOUT.value.Parameters.LOG: log})) | |
| emd = earth_mover_distance.apply(lang_model1, lang_log) | |
| def test_importing_dfg(self): | |
| dfg, sa, ea = dfg_importer.apply(os.path.join("input_data", "running-example.dfg")) | |
| def test_exporting_dfg(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| dfg = dfg_discovery.apply(log) | |
| dfg_exporter.apply(dfg, os.path.join("test_output_data", "running-example.dfg")) | |
| dfg, sa, ea = dfg_importer.apply(os.path.join("test_output_data", "running-example.dfg")) | |
| os.remove(os.path.join("test_output_data", "running-example.dfg")) | |
| def test_exporting_dfg_with_sa_ea(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| dfg = dfg_discovery.apply(log) | |
| sa = start_activities.get_start_activities(log) | |
| ea = end_activities.get_end_activities(log) | |
| dfg_exporter.apply(dfg, os.path.join("test_output_data", "running-example.dfg"), | |
| parameters={dfg_exporter.Variants.CLASSIC.value.Parameters.START_ACTIVITIES: sa, | |
| dfg_exporter.Variants.CLASSIC.value.Parameters.END_ACTIVITIES: ea}) | |
| dfg, sa, ea = dfg_importer.apply(os.path.join("test_output_data", "running-example.dfg")) | |
| os.remove(os.path.join("test_output_data", "running-example.dfg")) | |
| def test_log_skeleton(self): | |
| log = xes_importer.apply(os.path.join("input_data", "receipt.xes")) | |
| skeleton = lsk_alg.apply(log) | |
| conf_res = lsk_conf_alg.apply(log, skeleton) | |
| def test_performance_spectrum_log(self): | |
| log = xes_importer.apply(os.path.join("input_data", "receipt.xes")) | |
| pspectr = log_pspectrum.apply(log, ["T02 Check confirmation of receipt", "T03 Adjust confirmation of receipt"], | |
| 1000, {}) | |
| def test_performance_spectrum_df(self): | |
| df = pandas_utils.read_csv(os.path.join("input_data", "receipt.csv")) | |
| df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT) | |
| pspectr = df_pspectrum.apply(df, ["T02 Check confirmation of receipt", "T03 Adjust confirmation of receipt"], | |
| 1000, {}) | |
| def test_alignment(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| from pm4py.algo.discovery.alpha import algorithm as alpha_miner | |
| net, im, fm = alpha_miner.apply(log) | |
| from pm4py.algo.conformance.alignments.petri_net import algorithm as alignments | |
| aligned_traces = alignments.apply(log, net, im, fm, variant=alignments.Variants.VERSION_STATE_EQUATION_A_STAR) | |
| aligned_traces = alignments.apply(log, net, im, fm, variant=alignments.Variants.VERSION_DIJKSTRA_NO_HEURISTICS) | |
| def test_import_export_ptml(self): | |
| tree = ptree_importer.apply(os.path.join("input_data", "running-example.ptml")) | |
| ptree_exporter.apply(tree, os.path.join("test_output_data", "running-example2.ptml")) | |
| os.remove(os.path.join("test_output_data", "running-example2.ptml")) | |
| def test_footprints_net(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| from pm4py.algo.discovery.alpha import algorithm as alpha_miner | |
| net, im, fm = alpha_miner.apply(log) | |
| from pm4py.algo.discovery.footprints import algorithm as footprints_discovery | |
| fp_entire_log = footprints_discovery.apply(log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG) | |
| fp_trace_trace = footprints_discovery.apply(log) | |
| fp_net = footprints_discovery.apply(net, im) | |
| from pm4py.algo.conformance.footprints import algorithm as footprints_conformance | |
| conf1 = footprints_conformance.apply(fp_entire_log, fp_net) | |
| conf2 = footprints_conformance.apply(fp_trace_trace, fp_net) | |
| conf3 = footprints_conformance.apply(fp_entire_log, fp_net, | |
| variant=footprints_conformance.Variants.LOG_EXTENSIVE) | |
| conf4 = footprints_conformance.apply(fp_trace_trace, fp_net, | |
| variant=footprints_conformance.Variants.TRACE_EXTENSIVE) | |
| def test_footprints_tree(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| from pm4py.algo.discovery.inductive import algorithm as inductive_miner | |
| tree = inductive_miner.apply(log) | |
| from pm4py.algo.discovery.footprints import algorithm as footprints_discovery | |
| fp_entire_log = footprints_discovery.apply(log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG) | |
| fp_trace_trace = footprints_discovery.apply(log) | |
| fp_tree = footprints_discovery.apply(tree) | |
| from pm4py.algo.conformance.footprints import algorithm as footprints_conformance | |
| conf1 = footprints_conformance.apply(fp_entire_log, fp_tree) | |
| conf2 = footprints_conformance.apply(fp_trace_trace, fp_tree) | |
| conf3 = footprints_conformance.apply(fp_entire_log, fp_tree, | |
| variant=footprints_conformance.Variants.LOG_EXTENSIVE) | |
| conf4 = footprints_conformance.apply(fp_trace_trace, fp_tree, | |
| variant=footprints_conformance.Variants.TRACE_EXTENSIVE) | |
| def test_footprints_tree_df(self): | |
| df = pandas_utils.read_csv(os.path.join("input_data", "running-example.csv")) | |
| df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT) | |
| from pm4py.algo.discovery.inductive import algorithm as inductive_miner | |
| log = converter.apply(df, variant=converter.Variants.TO_EVENT_LOG) | |
| tree = inductive_miner.apply(log) | |
| from pm4py.algo.discovery.footprints import algorithm as footprints_discovery | |
| fp_df = footprints_discovery.apply(df) | |
| fp_tree = footprints_discovery.apply(tree) | |
| from pm4py.algo.conformance.footprints import algorithm as footprints_conformance | |
| conf = footprints_conformance.apply(fp_df, fp_tree) | |
| def test_conversion_pn_to_pt(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| from pm4py.algo.discovery.alpha import algorithm as alpha_miner | |
| net, im, fm = alpha_miner.apply(log) | |
| from pm4py.objects.conversion.wf_net import converter as wf_net_converter | |
| tree = wf_net_converter.apply(net, im, fm, variant=wf_net_converter.Variants.TO_PROCESS_TREE) | |
| def test_playout_tree_basic(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| from pm4py.algo.discovery.inductive import algorithm as inductive_miner | |
| tree = inductive_miner.apply(log) | |
| from pm4py.algo.simulation.playout.process_tree import algorithm as tree_playout | |
| new_log = tree_playout.apply(tree) | |
| def test_playout_tree_extensive(self): | |
| log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) | |
| from pm4py.algo.discovery.inductive import algorithm as inductive_miner | |
| tree = inductive_miner.apply(log) | |
| from pm4py.algo.simulation.playout.process_tree import algorithm as tree_playout | |
| new_log = tree_playout.apply(tree, variant=tree_playout.Variants.EXTENSIVE) | |
| def test_service_time_xes(self): | |
| log = xes_importer.apply(os.path.join("input_data", "interval_event_log.xes")) | |
| from pm4py.statistics.service_time.log import get | |
| soj_time = get.apply(log, parameters={get.Parameters.START_TIMESTAMP_KEY: "start_timestamp"}) | |
| def test_service_time_pandas(self): | |
| dataframe = pandas_utils.read_csv(os.path.join("input_data", "interval_event_log.csv")) | |
| from pm4py.objects.log.util import dataframe_utils | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT) | |
| from pm4py.statistics.service_time.pandas import get | |
| soj_time = get.apply(dataframe, parameters={get.Parameters.START_TIMESTAMP_KEY: "start_timestamp"}) | |
| def test_concurrent_activities_xes(self): | |
| log = xes_importer.apply(os.path.join("input_data", "interval_event_log.xes")) | |
| from pm4py.statistics.concurrent_activities.log import get | |
| conc_act = get.apply(log, parameters={get.Parameters.START_TIMESTAMP_KEY: "start_timestamp"}) | |
| def test_concurrent_activities_pandas(self): | |
| dataframe = pandas_utils.read_csv(os.path.join("input_data", "interval_event_log.csv")) | |
| from pm4py.objects.log.util import dataframe_utils | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT) | |
| from pm4py.statistics.concurrent_activities.pandas import get | |
| conc_act = get.apply(dataframe, parameters={get.Parameters.START_TIMESTAMP_KEY: "start_timestamp"}) | |
| def test_efg_xes(self): | |
| log = xes_importer.apply(os.path.join("input_data", "interval_event_log.xes")) | |
| from pm4py.statistics.eventually_follows.log import get | |
| efg = get.apply(log, parameters={get.Parameters.START_TIMESTAMP_KEY: "start_timestamp"}) | |
| def test_efg_pandas(self): | |
| dataframe = pandas_utils.read_csv(os.path.join("input_data", "interval_event_log.csv")) | |
| from pm4py.objects.log.util import dataframe_utils | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT) | |
| from pm4py.statistics.eventually_follows.pandas import get | |
| efg = get.apply(dataframe, parameters={get.Parameters.START_TIMESTAMP_KEY: "start_timestamp"}) | |
| def test_dfg_playout(self): | |
| import pm4py | |
| from pm4py.algo.simulation.playout.dfg import algorithm as dfg_playout | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) | |
| dfg, sa, ea = pm4py.discover_dfg(log) | |
| dfg_playout.apply(dfg, sa, ea) | |
| def test_dfg_align(self): | |
| import pm4py | |
| from pm4py.algo.filtering.dfg import dfg_filtering | |
| from pm4py.algo.conformance.alignments.dfg import algorithm as dfg_alignment | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) | |
| dfg, sa, ea = pm4py.discover_dfg(log) | |
| act_count = pm4py.get_event_attribute_values(log, "concept:name") | |
| dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_activities_percentage(dfg, sa, ea, act_count, 0.5) | |
| dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_paths_percentage(dfg, sa, ea, act_count, 0.5) | |
| aligned_traces = dfg_alignment.apply(log, dfg, sa, ea) | |
| def test_insert_idx_in_trace(self): | |
| df = pandas_utils.read_csv(os.path.join("input_data", "running-example.csv")) | |
| df = pandas_utils.insert_ev_in_tr_index(df) | |
| def test_automatic_feature_extraction(self): | |
| df = pandas_utils.read_csv(os.path.join("input_data", "receipt.csv")) | |
| fea_df = dataframe_utils.automatic_feature_extraction_df(df) | |
| def test_log_to_trie(self): | |
| import pm4py | |
| from pm4py.algo.transformation.log_to_trie import algorithm as log_to_trie | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) | |
| trie = log_to_trie.apply(log) | |
| def test_minimum_self_distance(self): | |
| import pm4py | |
| from pm4py.algo.discovery.minimum_self_distance import algorithm as minimum_self_distance | |
| log = pm4py.read_xes(os.path.join("input_data", "running-example.xes")) | |
| msd = minimum_self_distance.apply(log) | |
| def test_projection_univariate_log(self): | |
| import pm4py | |
| from pm4py.util.compression import util as compression_util | |
| log = pm4py.read_xes(os.path.join("input_data", "receipt.xes")) | |
| cl = compression_util.project_univariate(log, "concept:name") | |
| # just verify that the set is non-empty | |
| self.assertTrue(compression_util.get_start_activities(cl)) | |
| self.assertTrue(compression_util.get_end_activities(cl)) | |
| self.assertTrue(compression_util.get_alphabet(cl)) | |
| self.assertTrue(compression_util.discover_dfg(cl)) | |
| self.assertTrue(compression_util.get_variants(cl)) | |
| def test_projection_univariate_df(self): | |
| from pm4py.util.compression import util as compression_util | |
| dataframe = pandas_utils.read_csv(os.path.join("input_data", "receipt.csv")) | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["time:timestamp"]) | |
| cl = compression_util.project_univariate(dataframe, "concept:name") | |
| # just verify that the set is non-empty | |
| self.assertTrue(compression_util.get_start_activities(cl)) | |
| self.assertTrue(compression_util.get_end_activities(cl)) | |
| self.assertTrue(compression_util.get_alphabet(cl)) | |
| self.assertTrue(compression_util.discover_dfg(cl)) | |
| self.assertTrue(compression_util.get_variants(cl)) | |
| def test_compression_univariate_log(self): | |
| import pm4py | |
| from pm4py.util.compression import util as compression_util | |
| log = pm4py.read_xes(os.path.join("input_data", "receipt.xes")) | |
| cl, lookup = compression_util.compress_univariate(log, "concept:name") | |
| # just verify that the set is non-empty | |
| self.assertTrue(compression_util.get_start_activities(cl)) | |
| self.assertTrue(compression_util.get_end_activities(cl)) | |
| self.assertTrue(compression_util.get_alphabet(cl)) | |
| self.assertTrue(compression_util.discover_dfg(cl)) | |
| self.assertTrue(compression_util.get_variants(cl)) | |
| def test_compression_univariate_df(self): | |
| from pm4py.util.compression import util as compression_util | |
| dataframe = pandas_utils.read_csv(os.path.join("input_data", "receipt.csv")) | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["time:timestamp"]) | |
| cl, lookup = compression_util.compress_univariate(dataframe, "concept:name") | |
| # just verify that the set is non-empty | |
| self.assertTrue(compression_util.get_start_activities(cl)) | |
| self.assertTrue(compression_util.get_end_activities(cl)) | |
| self.assertTrue(compression_util.get_alphabet(cl)) | |
| self.assertTrue(compression_util.discover_dfg(cl)) | |
| self.assertTrue(compression_util.get_variants(cl)) | |
| def test_compression_multivariate_log(self): | |
| import pm4py | |
| from pm4py.util.compression import util as compression_util | |
| log = pm4py.read_xes(os.path.join("input_data", "receipt.xes")) | |
| cl, lookup = compression_util.compress_multivariate(log, ["concept:name", "org:resource"]) | |
| # just verify that the set is non-empty | |
| self.assertTrue(compression_util.get_start_activities(cl)) | |
| self.assertTrue(compression_util.get_end_activities(cl)) | |
| self.assertTrue(compression_util.get_alphabet(cl)) | |
| self.assertTrue(compression_util.discover_dfg(cl)) | |
| self.assertTrue(compression_util.get_variants(cl)) | |
| def test_compression_multivariate_df(self): | |
| from pm4py.util.compression import util as compression_util | |
| dataframe = pandas_utils.read_csv(os.path.join("input_data", "receipt.csv")) | |
| dataframe = dataframe_utils.convert_timestamp_columns_in_df(dataframe, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["time:timestamp"]) | |
| cl, lookup = compression_util.compress_multivariate(dataframe, ["concept:name", "org:resource"]) | |
| # just verify that the set is non-empty | |
| self.assertTrue(compression_util.get_start_activities(cl)) | |
| self.assertTrue(compression_util.get_end_activities(cl)) | |
| self.assertTrue(compression_util.get_alphabet(cl)) | |
| self.assertTrue(compression_util.discover_dfg(cl)) | |
| self.assertTrue(compression_util.get_variants(cl)) | |
| def test_log_to_target_rem_time(self): | |
| import pm4py | |
| from pm4py.algo.transformation.log_to_target import algorithm as log_to_target | |
| log = pm4py.read_xes("input_data/running-example.xes") | |
| rem_time_target, classes = log_to_target.apply(log, variant=log_to_target.Variants.REMAINING_TIME) | |
| def test_log_to_target_next_time(self): | |
| import pm4py | |
| from pm4py.algo.transformation.log_to_target import algorithm as log_to_target | |
| log = pm4py.read_xes("input_data/running-example.xes") | |
| next_time_target, classes = log_to_target.apply(log, variant=log_to_target.Variants.NEXT_TIME) | |
| def test_log_to_target_next_activity(self): | |
| import pm4py | |
| from pm4py.algo.transformation.log_to_target import algorithm as log_to_target | |
| log = pm4py.read_xes("input_data/running-example.xes") | |
| next_activity_target, next_activities = log_to_target.apply(log, variant=log_to_target.Variants.NEXT_ACTIVITY) | |
| def test_ocel_split_cc_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.split_ocel import algorithm as split_ocel | |
| res = split_ocel.apply(ocel, variant=split_ocel.Variants.CONNECTED_COMPONENTS) | |
| def test_ocel_split_ancestors_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.split_ocel import algorithm as split_ocel | |
| res = split_ocel.apply(ocel, parameters={"object_type": "order"}, variant=split_ocel.Variants.ANCESTORS_DESCENDANTS) | |
| def test_ocel_object_features_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.features.objects import algorithm as ocel_fea | |
| res = ocel_fea.apply(ocel) | |
| def test_ocel_event_features_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.features.events import algorithm as ocel_fea | |
| res = ocel_fea.apply(ocel) | |
| def test_ocel_event_object_features_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.features.events_objects import algorithm as ocel_fea | |
| res = ocel_fea.apply(ocel) | |
| def test_ocel_interaction_graph_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.graphs import object_interaction_graph | |
| object_interaction_graph.apply(ocel) | |
| def test_ocel_descendants_graph_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.graphs import object_descendants_graph | |
| object_descendants_graph.apply(ocel) | |
| def test_ocel_inheritance_graph_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.graphs import object_inheritance_graph | |
| object_inheritance_graph.apply(ocel) | |
| def test_ocel_cobirth_graph_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.graphs import object_cobirth_graph | |
| object_cobirth_graph.apply(ocel) | |
| def test_ocel_codeath_graph_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.graphs import object_codeath_graph | |
| object_codeath_graph.apply(ocel) | |
| def test_ocel_description_non_simpl_interface(self): | |
| import pm4py | |
| ocel = pm4py.read_ocel("input_data/ocel/example_log.jsonocel") | |
| from pm4py.algo.transformation.ocel.description.variants import variant1 | |
| variant1.apply(ocel) | |
| if __name__ == "__main__": | |
| unittest.main() | |