diff --git a/Dockerfile b/Dockerfile index 01694d7e6..56bd7a232 100644 --- a/Dockerfile +++ b/Dockerfile @@ -12,6 +12,7 @@ RUN apt-get -y install g++ libboost-all-dev libncurses5-dev wget RUN apt-get -y install libtool flex bison pkg-config g++ libssl-dev automake RUN apt-get -y install libjemalloc-dev libboost-dev libboost-filesystem-dev libboost-system-dev libboost-regex-dev python3-dev autoconf flex bison cmake RUN apt-get -y install libxml2-dev libxslt-dev libfreetype6-dev libsuitesparse-dev +RUN apt-get -y install libclang-16-dev llvm-16-dev RUN pip install -U wheel six pytest RUN pip install -U meson-python>=0.13.1 Cython>=3.0.6 ninja spin==0.8 build RUN pip install deprecation==2.1.0 graphviz==0.20.3 intervaltree==3.1.0 networkx==3.3 packaging==24.0 python-dateutil==2.9.0.post0 pytz==2024.1 six==1.16.0 sortedcontainers==2.4.0 tzdata==2024.1 @@ -24,6 +25,7 @@ RUN pip install contourpy==1.2.1 fonttools==4.51.0 kiwisolver==1.4.5 matplotlib= #RUN cd / && git clone https://github.com/scipy/scipy.git && cd /scipy && git submodule update --init && pip3 install . #RUN cd / && git clone https://github.com/lxml/lxml.git && cd /lxml && pip3 install . #RUN pip3 install matplotlib +#RUN cd / && git clone https://github.com/duckdb/duckdb.git && cd /duckdb && make && cd /duckdb/tools/pythonpkg && python3 setup.py install COPY . /app RUN cd /app && python setup.py install diff --git a/examples/align_approx_pt.py b/examples/align_approx_pt.py index e6458fca2..a79ff42a1 100644 --- a/examples/align_approx_pt.py +++ b/examples/align_approx_pt.py @@ -1,7 +1,7 @@ import os +import importlib.util from pm4py.algo.discovery.inductive import algorithm as inductive from pm4py.objects.log.importer.xes import importer as xes_importer -from pm4py.visualization.process_tree import visualizer as pt_vis from pm4py.algo.conformance.alignments.process_tree import algorithm as align_approx from pm4py.objects.petri_net.utils.align_utils import pretty_print_alignments from examples import examples_conf @@ -12,8 +12,11 @@ def execute_script(): log = xes_importer.apply(log_path) tree = inductive.apply(log) - gviz = pt_vis.apply(tree, parameters={pt_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - pt_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.process_tree import visualizer as pt_vis + gviz = pt_vis.apply(tree, parameters={pt_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + pt_vis.view(gviz) print("start calculate approximated alignments") approx_alignments = align_approx.apply(log, tree) diff --git a/examples/align_decomposition_ex_paper.py b/examples/align_decomposition_ex_paper.py index 5e01b582f..7410a22ed 100644 --- a/examples/align_decomposition_ex_paper.py +++ b/examples/align_decomposition_ex_paper.py @@ -1,8 +1,8 @@ from pm4py.objects.petri_net.obj import PetriNet, Marking from pm4py.objects.petri_net.utils.petri_utils import add_arc_from_to -from pm4py.visualization.petri_net import visualizer from pm4py.objects.petri_net.utils import decomposition from examples import examples_conf +import importlib.util def execute_script(): @@ -82,13 +82,17 @@ def execute_script(): im[start] = 1 fm = Marking() fm[end] = 1 - gvizs = [] - gvizs.append(visualizer.apply(net, im, final_marking=fm, parameters={"format": examples_conf.TARGET_IMG_FORMAT})) - visualizer.view(gvizs[len(gvizs) - 1]) decomposed_net = decomposition.decompose(net, im, fm) - for snet, sim, sfm in decomposed_net: - gvizs.append(visualizer.apply(snet, sim, final_marking=sfm, parameters={"format": examples_conf.TARGET_IMG_FORMAT})) + gvizs = [] + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer + + gvizs.append(visualizer.apply(net, im, final_marking=fm, parameters={"format": examples_conf.TARGET_IMG_FORMAT})) visualizer.view(gvizs[len(gvizs) - 1]) + for snet, sim, sfm in decomposed_net: + gvizs.append(visualizer.apply(snet, sim, final_marking=sfm, parameters={"format": examples_conf.TARGET_IMG_FORMAT})) + visualizer.view(gvizs[len(gvizs) - 1]) if __name__ == "__main__": diff --git a/examples/bpmn_from_pt_conversion.py b/examples/bpmn_from_pt_conversion.py index 5990c8de0..846917dc8 100644 --- a/examples/bpmn_from_pt_conversion.py +++ b/examples/bpmn_from_pt_conversion.py @@ -6,6 +6,7 @@ from pm4py.objects.log.importer.xes import importer as xes_import from pm4py.objects.bpmn.exporter import exporter as bpmn_exporter from examples import examples_conf +import importlib.util @@ -14,10 +15,11 @@ def execute_script(): log = xes_import.apply(log_path) ptree = inductive_miner.apply(log) bpmn = pt_converter.apply(ptree, variant=pt_converter.Variants.TO_BPMN) - #bpmn = bpmn_layouter.apply(bpmn) - bpmn_exporter.apply(bpmn, "stru.bpmn") - os.remove("stru.bpmn") - pm4py.view_bpmn(bpmn, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + bpmn_exporter.apply(bpmn, "stru.bpmn") + os.remove("stru.bpmn") + pm4py.view_bpmn(bpmn, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/bpmn_js_visualization.py b/examples/bpmn_js_visualization.py index 1b51ccf5d..c73902fb8 100644 --- a/examples/bpmn_js_visualization.py +++ b/examples/bpmn_js_visualization.py @@ -1,4 +1,5 @@ import pm4py +import importlib.util def execute_script(): @@ -6,7 +7,8 @@ def execute_script(): bpmn_model = pm4py.discover_bpmn_inductive(log) - pm4py.view_bpmn(bpmn_model, variant_str="dagrejs") + if importlib.util.find_spec("graphviz"): + pm4py.view_bpmn(bpmn_model, variant_str="dagrejs") if __name__ == "__main__": diff --git a/examples/corr_mining.py b/examples/corr_mining.py index 2830d8f80..ac486edc6 100644 --- a/examples/corr_mining.py +++ b/examples/corr_mining.py @@ -6,8 +6,7 @@ from pm4py.statistics.start_activities.pandas import get as sa_get from pm4py.statistics.end_activities.pandas import get as ea_get from examples import examples_conf - -from pm4py.visualization.dfg import visualizer as dfg_vis +import importlib.util def execute_script(): @@ -25,13 +24,16 @@ def execute_script(): soj_time = soj_time_get.apply(df, parameters=parameters) dfg, performance_dfg = correlation_miner.apply(df, variant=correlation_miner.Variants.CLASSIC, parameters=parameters) - gviz_freq = dfg_vis.apply(dfg, activities_count=act_count, serv_time=soj_time, variant=dfg_vis.Variants.FREQUENCY, - parameters=parameters) - dfg_vis.view(gviz_freq) - gviz_perf = dfg_vis.apply(performance_dfg, activities_count=act_count, serv_time=soj_time, - variant=dfg_vis.Variants.PERFORMANCE, - parameters=parameters) - dfg_vis.view(gviz_perf) + + if importlib.util.find_spec("grapviz"): + from pm4py.visualization.dfg import visualizer as dfg_vis + gviz_freq = dfg_vis.apply(dfg, activities_count=act_count, serv_time=soj_time, variant=dfg_vis.Variants.FREQUENCY, + parameters=parameters) + dfg_vis.view(gviz_freq) + gviz_perf = dfg_vis.apply(performance_dfg, activities_count=act_count, serv_time=soj_time, + variant=dfg_vis.Variants.PERFORMANCE, + parameters=parameters) + dfg_vis.view(gviz_perf) if __name__ == "__main__": diff --git a/examples/cost_based_dfg.py b/examples/cost_based_dfg.py index 6280a5092..103710d85 100644 --- a/examples/cost_based_dfg.py +++ b/examples/cost_based_dfg.py @@ -1,15 +1,18 @@ import pm4py import os from pm4py.algo.discovery.dfg.adapters.pandas import df_statistics -from pm4py.visualization.dfg import visualizer as dfg_visualizer from examples import examples_conf +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "roadtraffic100traces.xes"), return_legacy_log_object=False) cost_based_dfg = df_statistics.get_dfg_graph(log, measure="cost", cost_attribute="amount") - gviz = dfg_visualizer.apply(cost_based_dfg, variant=dfg_visualizer.Variants.COST, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - dfg_visualizer.view(gviz) + + if importlib.util.find_spec("grapviz"): + from pm4py.visualization.dfg import visualizer as dfg_visualizer + gviz = dfg_visualizer.apply(cost_based_dfg, variant=dfg_visualizer.Variants.COST, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + dfg_visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/data_petri_nets.py b/examples/data_petri_nets.py index b8f3387a7..817384916 100644 --- a/examples/data_petri_nets.py +++ b/examples/data_petri_nets.py @@ -6,6 +6,7 @@ from pm4py.objects.petri_net.data_petri_nets.data_marking import DataMarking from pm4py.objects.log.importer.xes import importer as xes_importer from examples import examples_conf +import importlib.util def get_trans_by_name(net, name): @@ -18,7 +19,10 @@ def get_trans_by_name(net, name): def execute_script(): log = xes_importer.apply(os.path.join("..", "tests", "input_data", "roadtraffic100traces.xes")) net, im, fm = pm4py.read_pnml(os.path.join("..", "tests", "input_data", "data_petri_net.pnml"), auto_guess_final_marking=True) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + aligned_traces = alignments.apply(log, net, im, fm, variant=alignments.Variants.VERSION_DIJKSTRA_LESS_MEMORY, parameters={"ret_tuple_as_trans_desc": True}) for index, trace in enumerate(log): aligned_trace = aligned_traces[index] diff --git a/examples/dec_treplay_imdf.py b/examples/dec_treplay_imdf.py index f9f048d83..4fd1a0444 100644 --- a/examples/dec_treplay_imdf.py +++ b/examples/dec_treplay_imdf.py @@ -2,9 +2,9 @@ from pm4py.algo.discovery.inductive import algorithm as inductive_miner from pm4py.objects.log.importer.xes import importer as xes_importer -from pm4py.visualization.petri_net import visualizer as pn_vis from pm4py.objects.conversion.process_tree import converter as process_tree_converter from examples import examples_conf +import importlib.util def execute_script(): @@ -14,18 +14,21 @@ def execute_script(): # apply Inductive Miner process_tree = inductive_miner.apply(log) net, initial_marking, final_marking = process_tree_converter.apply(process_tree) - # get visualization - variant = pn_vis.Variants.PERFORMANCE - parameters_viz = {pn_vis.Variants.PERFORMANCE.value.Parameters.AGGREGATION_MEASURE: "mean", pn_vis.Variants.PERFORMANCE.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT} - gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant, - parameters=parameters_viz) - pn_vis.view(gviz) - # do another visualization with frequency - variant = pn_vis.Variants.FREQUENCY - parameters_viz = {pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT} - gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant, - parameters=parameters_viz) - pn_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_vis + # get visualization + variant = pn_vis.Variants.PERFORMANCE + parameters_viz = {pn_vis.Variants.PERFORMANCE.value.Parameters.AGGREGATION_MEASURE: "mean", pn_vis.Variants.PERFORMANCE.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT} + gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant, + parameters=parameters_viz) + pn_vis.view(gviz) + # do another visualization with frequency + variant = pn_vis.Variants.FREQUENCY + parameters_viz = {pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT} + gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant, + parameters=parameters_viz) + pn_vis.view(gviz) if __name__ == "__main__": diff --git a/examples/decisiontree_align_example.py b/examples/decisiontree_align_example.py index 59bf894ad..375115dcb 100644 --- a/examples/decisiontree_align_example.py +++ b/examples/decisiontree_align_example.py @@ -1,10 +1,10 @@ from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.algo.discovery.inductive import algorithm as inductive_miner from pm4py.algo.decision_mining import algorithm -from pm4py.visualization.decisiontree import visualizer as visualizer from pm4py.objects.conversion.process_tree import converter as process_tree_converter from examples import examples_conf import os +import importlib.util def execute_script(): @@ -12,12 +12,16 @@ def execute_script(): log = xes_importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes")) process_tree = inductive_miner.apply(log) net, im, fm = process_tree_converter.apply(process_tree) - # we need to specify a decision point. In this case, the place p_10 is a suitable decision point - clf, feature_names, classes = algorithm.get_decision_tree(log, net, im, fm, decision_point="p_10") - # we can visualize the decision tree - gviz = visualizer.apply(clf, feature_names, classes, - parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - visualizer.view(gviz) + + if importlib.util.find_spec("sklearn") and importlib.util.find_spec("graphviz"): + # we need to specify a decision point. In this case, the place p_10 is a suitable decision point + clf, feature_names, classes = algorithm.get_decision_tree(log, net, im, fm, decision_point="p_10") + + # we can visualize the decision tree + from pm4py.visualization.decisiontree import visualizer as visualizer + gviz = visualizer.apply(clf, feature_names, classes, + parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/decisiontree_trivial_example.py b/examples/decisiontree_trivial_example.py index 4ca5e4af5..08758206b 100644 --- a/examples/decisiontree_trivial_example.py +++ b/examples/decisiontree_trivial_example.py @@ -4,8 +4,8 @@ from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.objects.log.util import get_class_representation from pm4py.algo.transformation.log_to_features import algorithm as log_to_features -from pm4py.visualization.decisiontree import visualizer as dt_vis from examples import examples_conf +import importlib.util def execute_script(): @@ -16,21 +16,29 @@ def execute_script(): data, feature_names = log_to_features.apply(log, variant=log_to_features.Variants.TRACE_BASED) # gets classes representation by final concept:name value (end activity) target, classes = get_class_representation.get_class_representation_by_str_ev_attr_value_value(log, "concept:name") - # mine the decision tree given 'data' and 'target' - clf = ml_utils.DecisionTreeClassifier(max_depth=7) - clf.fit(data, target) - # visualize the decision tree - gviz = dt_vis.apply(clf, feature_names, classes, parameters={dt_vis.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - dt_vis.view(gviz) + + if importlib.util.find_spec("sklearn") and importlib.util.find_spec("graphviz"): + # mine the decision tree given 'data' and 'target' + clf = ml_utils.DecisionTreeClassifier(max_depth=7) + clf.fit(data, target) + + # visualize the decision tree + from pm4py.visualization.decisiontree import visualizer as dt_vis + gviz = dt_vis.apply(clf, feature_names, classes, parameters={dt_vis.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + dt_vis.view(gviz) # gets classes representation by trace duration (threshold between the two classes = 200D) target, classes = get_class_representation.get_class_representation_by_trace_duration(log, 2 * 8640000) - # mine the decision tree given 'data' and 'target' - clf = ml_utils.DecisionTreeClassifier(max_depth=7) - clf.fit(data, target) - # visualize the decision tree - gviz = dt_vis.apply(clf, feature_names, classes, parameters={dt_vis.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - dt_vis.view(gviz) + + if importlib.util.find_spec("sklearn") and importlib.util.find_spec("graphviz"): + # mine the decision tree given 'data' and 'target' + clf = ml_utils.DecisionTreeClassifier(max_depth=7) + clf.fit(data, target) + + # visualize the decision tree + from pm4py.visualization.decisiontree import visualizer as dt_vis + gviz = dt_vis.apply(clf, feature_names, classes, parameters={dt_vis.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + dt_vis.view(gviz) if __name__ == "__main__": diff --git a/examples/dfg_align_log.py b/examples/dfg_align_log.py index f19c687e4..502498bd3 100644 --- a/examples/dfg_align_log.py +++ b/examples/dfg_align_log.py @@ -6,9 +6,9 @@ from pm4py.algo.filtering.dfg import dfg_filtering from pm4py.algo.conformance.alignments.dfg import algorithm as dfg_alignment from pm4py.statistics.attributes.log import get -from pm4py.visualization.dfg import visualizer from pm4py.objects.petri_net.utils import align_utils from examples import examples_conf +import importlib.util def execute_script(): @@ -32,9 +32,13 @@ def execute_script(): print(bb - aa) print(sum(x["visited_states"] for x in aligned_traces)) print(sum(x["cost"] // align_utils.STD_MODEL_LOG_MOVE_COST for x in aligned_traces)) - gviz = visualizer.apply(dfg, activities_count=ac, parameters={"start_activities": sa, "end_activities": ea, - "format": examples_conf.TARGET_IMG_FORMAT}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.dfg import visualizer + gviz = visualizer.apply(dfg, activities_count=ac, parameters={"start_activities": sa, "end_activities": ea, + "format": examples_conf.TARGET_IMG_FORMAT}) + visualizer.view(gviz) + cc = time.time() aligned_traces2 = petri_alignments.apply(log, net, im, fm, variant=petri_alignments.Variants.VERSION_DIJKSTRA_LESS_MEMORY) diff --git a/examples/dfg_filt_act_paths_perc.py b/examples/dfg_filt_act_paths_perc.py index dbc965bcd..104276886 100644 --- a/examples/dfg_filt_act_paths_perc.py +++ b/examples/dfg_filt_act_paths_perc.py @@ -1,7 +1,7 @@ import pm4py -from pm4py.visualization.dfg import visualizer as dfg_visualizer from pm4py.algo.filtering.dfg import dfg_filtering from examples import examples_conf +import importlib.util def execute_script(): @@ -12,11 +12,14 @@ def execute_script(): dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_activities_percentage(dfg, sa, ea, act_count, 0.3) # keep the specified amount of paths dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_paths_percentage(dfg, sa, ea, act_count, 0.3) - # view the DFG - gviz = dfg_visualizer.apply(dfg, activities_count=act_count, parameters={dfg_visualizer.Variants.FREQUENCY.value.Parameters.START_ACTIVITIES: sa, - dfg_visualizer.Variants.FREQUENCY.value.Parameters.END_ACTIVITIES: ea, - dfg_visualizer.Variants.FREQUENCY.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - dfg_visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + # view the DFG + from pm4py.visualization.dfg import visualizer as dfg_visualizer + gviz = dfg_visualizer.apply(dfg, activities_count=act_count, parameters={dfg_visualizer.Variants.FREQUENCY.value.Parameters.START_ACTIVITIES: sa, + dfg_visualizer.Variants.FREQUENCY.value.Parameters.END_ACTIVITIES: ea, + dfg_visualizer.Variants.FREQUENCY.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + dfg_visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/dfg_min_ex_log.py b/examples/dfg_min_ex_log.py index adffcff28..f18630e8a 100644 --- a/examples/dfg_min_ex_log.py +++ b/examples/dfg_min_ex_log.py @@ -9,9 +9,8 @@ from pm4py.statistics.concurrent_activities.log import get as conc_act_get from pm4py.statistics.eventually_follows.log import get as efg_get from pm4py.util import constants -from pm4py.visualization.dfg import visualizer as dfg_vis_fact -from pm4py.visualization.petri_net import visualizer as pn_vis from examples import examples_conf +import importlib.util def execute_script(): @@ -39,15 +38,19 @@ def execute_script(): print(efg) dfg_freq = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.FREQUENCY) dfg_perf = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.PERFORMANCE) - dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, log=log, variant=dfg_vis_fact.Variants.FREQUENCY, - parameters=parameters) - dfg_vis_fact.view(dfg_gv_freq) - dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, log=log, variant=dfg_vis_fact.Variants.PERFORMANCE, - parameters=parameters) - dfg_vis_fact.view(dfg_gv_perf) - net, im, fm = dfg_conv.apply(dfg_freq) - gviz = pn_vis.apply(net, im, fm, parameters=parameters) - pn_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.dfg import visualizer as dfg_vis_fact + from pm4py.visualization.petri_net import visualizer as pn_vis + dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, log=log, variant=dfg_vis_fact.Variants.FREQUENCY, + parameters=parameters) + dfg_vis_fact.view(dfg_gv_freq) + dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, log=log, variant=dfg_vis_fact.Variants.PERFORMANCE, + parameters=parameters) + dfg_vis_fact.view(dfg_gv_perf) + net, im, fm = dfg_conv.apply(dfg_freq) + gviz = pn_vis.apply(net, im, fm, parameters=parameters) + pn_vis.view(gviz) if __name__ == "__main__": diff --git a/examples/dfg_min_ex_pandas.py b/examples/dfg_min_ex_pandas.py index 169976ece..32af9b8b4 100644 --- a/examples/dfg_min_ex_pandas.py +++ b/examples/dfg_min_ex_pandas.py @@ -10,9 +10,8 @@ from pm4py.statistics.concurrent_activities.pandas import get as conc_act_get from pm4py.statistics.eventually_follows.pandas import get as efg_get from pm4py.statistics.start_activities.pandas import get as sa_get -from pm4py.visualization.dfg import visualizer as dfg_vis_fact -from pm4py.visualization.petri_net import visualizer as pn_vis from examples import examples_conf +import importlib.util def execute_script(): @@ -42,16 +41,20 @@ def execute_script(): efg = efg_get.apply(dataframe, parameters=parameters) print("efg") print(efg) - dfg_freq, dfg_perf = df_statistics.get_dfg_graph(dataframe, measure="both", start_timestamp_key="start_timestamp") - dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, activities_count=att_count, variant=dfg_vis_fact.Variants.FREQUENCY, - serv_time=soj_time, parameters=parameters) - dfg_vis_fact.view(dfg_gv_freq) - dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, activities_count=att_count, variant=dfg_vis_fact.Variants.PERFORMANCE, - serv_time=soj_time, parameters=parameters) - dfg_vis_fact.view(dfg_gv_perf) - net, im, fm = dfg_conv.apply(dfg_freq) - gviz = pn_vis.apply(net, im, fm, parameters=parameters) - pn_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.dfg import visualizer as dfg_vis_fact + from pm4py.visualization.petri_net import visualizer as pn_vis + dfg_freq, dfg_perf = df_statistics.get_dfg_graph(dataframe, measure="both", start_timestamp_key="start_timestamp") + dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, activities_count=att_count, variant=dfg_vis_fact.Variants.FREQUENCY, + serv_time=soj_time, parameters=parameters) + dfg_vis_fact.view(dfg_gv_freq) + dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, activities_count=att_count, variant=dfg_vis_fact.Variants.PERFORMANCE, + serv_time=soj_time, parameters=parameters) + dfg_vis_fact.view(dfg_gv_perf) + net, im, fm = dfg_conv.apply(dfg_freq) + gviz = pn_vis.apply(net, im, fm, parameters=parameters) + pn_vis.view(gviz) if __name__ == "__main__": diff --git a/examples/dfg_playout.py b/examples/dfg_playout.py index 663f7c19f..f9b27052d 100644 --- a/examples/dfg_playout.py +++ b/examples/dfg_playout.py @@ -2,6 +2,7 @@ from pm4py.algo.filtering.dfg import dfg_filtering from pm4py.algo.simulation.playout.dfg.variants import classic as dfg_playout from examples import examples_conf +import importlib.util import os @@ -19,9 +20,14 @@ def execute_script(): print(len(simulated_log)) print(sum(x.attributes["probability"] for x in simulated_log)) # shows the two DFGs to show that they are identical - pm4py.view_dfg(dfg, sa, ea, log=log, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_dfg(dfg, sa, ea, log=log, format=examples_conf.TARGET_IMG_FORMAT) new_dfg, new_sa, new_ea = pm4py.discover_dfg(simulated_log) - pm4py.view_dfg(new_dfg, new_sa, new_ea, log=simulated_log, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_dfg(new_dfg, new_sa, new_ea, log=simulated_log, format=examples_conf.TARGET_IMG_FORMAT) + for trace in simulated_log: print(list(x["concept:name"] for x in trace)) print(trace.attributes["probability"], dfg_playout.get_trace_probability(trace, dfg, sa, ea)) diff --git a/examples/discovery_data_petri_net.py b/examples/discovery_data_petri_net.py index 026915a8b..85903578e 100644 --- a/examples/discovery_data_petri_net.py +++ b/examples/discovery_data_petri_net.py @@ -2,6 +2,7 @@ from pm4py.algo.decision_mining import algorithm as decision_mining from examples import examples_conf import os +import importlib.util def execute_script(): @@ -9,7 +10,9 @@ def execute_script(): log = pm4py.read_xes(log_path) net, im, fm = pm4py.discover_petri_net_inductive(log) net, im, fm = decision_mining.create_data_petri_nets_with_decisions(log, net, im, fm) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/dotted_chart.py b/examples/dotted_chart.py index 921912984..677d50c8c 100644 --- a/examples/dotted_chart.py +++ b/examples/dotted_chart.py @@ -1,16 +1,19 @@ import pm4py from examples import examples_conf +import importlib.util import os def execute_script(): # reads a XES log log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "receipt.xes")) - # generates the default dotted chart (timestamp on X-axis, case ID on Y-axis, activity as color) - pm4py.view_dotted_chart(log, format=examples_conf.TARGET_IMG_FORMAT) - # generates the dotted chart with the activity on the X-axis, the resource on the Y-axis, and the group - # as color - pm4py.view_dotted_chart(log, format=examples_conf.TARGET_IMG_FORMAT, attributes=["concept:name", "org:resource", "org:group"]) + + if importlib.util.find_spec("graphviz"): + # generates the default dotted chart (timestamp on X-axis, case ID on Y-axis, activity as color) + pm4py.view_dotted_chart(log, format=examples_conf.TARGET_IMG_FORMAT) + # generates the dotted chart with the activity on the X-axis, the resource on the Y-axis, and the group + # as color + pm4py.view_dotted_chart(log, format=examples_conf.TARGET_IMG_FORMAT, attributes=["concept:name", "org:resource", "org:group"]) if __name__ == "__main__": diff --git a/examples/ev_to_obj_types_graph.py b/examples/ev_to_obj_types_graph.py index 039908771..fd3d60211 100644 --- a/examples/ev_to_obj_types_graph.py +++ b/examples/ev_to_obj_types_graph.py @@ -1,12 +1,15 @@ import pm4py -from pm4py.visualization.ocel.eve_to_obj_types import visualizer from examples import examples_conf +import importlib.util def execute_script(): ocel = pm4py.read_ocel('../tests/input_data/ocel/example_log.jsonocel') - gviz = visualizer.apply(ocel, parameters={"format": examples_conf.TARGET_IMG_FORMAT, "annotate_frequency": True}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.ocel.eve_to_obj_types import visualizer + gviz = visualizer.apply(ocel, parameters={"format": examples_conf.TARGET_IMG_FORMAT, "annotate_frequency": True}) + visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/events_distribution.py b/examples/events_distribution.py index 786fdb111..717798399 100644 --- a/examples/events_distribution.py +++ b/examples/events_distribution.py @@ -3,8 +3,8 @@ from pm4py.util import constants, pandas_utils from pm4py.objects.log.util import dataframe_utils from pm4py.statistics.attributes.pandas import get as attr_get -from pm4py.visualization.graphs import visualizer from examples import examples_conf +import importlib.util def execute_script(): @@ -13,34 +13,53 @@ def execute_script(): # plots the distribution of the events over the days of a month x0, y0 = attr_get.get_events_distribution(df, distr_type="days_month") - gviz = visualizer.apply(x0, y0, variant=visualizer.Variants.BARPLOT, - parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Days of a Month", - "x_axis": "Day of month", "y_axis": "Number of Events"}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("matplotlib"): + from pm4py.visualization.graphs import visualizer + gviz = visualizer.apply(x0, y0, variant=visualizer.Variants.BARPLOT, + parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Days of a Month", + "x_axis": "Day of month", "y_axis": "Number of Events"}) + visualizer.view(gviz) + # plots the distribution of the events over the months x1, y1 = attr_get.get_events_distribution(df, distr_type="months") - gviz = visualizer.apply(x1, y1, variant=visualizer.Variants.BARPLOT, - parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Months", - "x_axis": "Month", "y_axis": "Number of Events"}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("matplotlib"): + from pm4py.visualization.graphs import visualizer + gviz = visualizer.apply(x1, y1, variant=visualizer.Variants.BARPLOT, + parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Months", + "x_axis": "Month", "y_axis": "Number of Events"}) + visualizer.view(gviz) + # plots the distribution of the events over the years x2, y2 = attr_get.get_events_distribution(df, distr_type="years") - gviz = visualizer.apply(x2, y2, variant=visualizer.Variants.BARPLOT, - parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Years", - "x_axis": "Year", "y_axis": "Number of Events"}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("matplotlib"): + from pm4py.visualization.graphs import visualizer + gviz = visualizer.apply(x2, y2, variant=visualizer.Variants.BARPLOT, + parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Years", + "x_axis": "Year", "y_axis": "Number of Events"}) + visualizer.view(gviz) + # plots the distribution of the events over the hours (of the day) x3, y3 = attr_get.get_events_distribution(df, distr_type="hours") - gviz = visualizer.apply(x3, y3, variant=visualizer.Variants.BARPLOT, - parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Hours", - "x_axis": "Hour (of day)", "y_axis": "Number of Events"}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("matplotlib"): + from pm4py.visualization.graphs import visualizer + gviz = visualizer.apply(x3, y3, variant=visualizer.Variants.BARPLOT, + parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Hours", + "x_axis": "Hour (of day)", "y_axis": "Number of Events"}) + visualizer.view(gviz) + # plots the distribution of the events over the days of the week x4, y4 = attr_get.get_events_distribution(df, distr_type="days_week") - gviz = visualizer.apply(x4, y4, variant=visualizer.Variants.BARPLOT, - parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Days of a Week", - "x_axis": "Day of the Week", "y_axis": "Number of Events"}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("matplotlib"): + from pm4py.visualization.graphs import visualizer + gviz = visualizer.apply(x4, y4, variant=visualizer.Variants.BARPLOT, + parameters={"format": examples_conf.TARGET_IMG_FORMAT, "title": "Distribution of the Events over the Days of a Week", + "x_axis": "Day of the Week", "y_axis": "Number of Events"}) + visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/execute_everything.py b/examples/execute_everything.py index 4ab154b85..4f7c8273f 100644 --- a/examples/execute_everything.py +++ b/examples/execute_everything.py @@ -2,6 +2,10 @@ import os import sys import traceback +import importlib.util + + +EXECUTE_EXAMPLES = True def bpmn_js_visualization(): @@ -874,6 +878,10 @@ def execute_script(f): import time traceback.print_exc() time.sleep(3) + except KeyError: + import time + traceback.print_exc() + time.sleep(3) except: traceback.print_exc() input("\npress INPUT if you want to continue") @@ -883,141 +891,167 @@ def main(): sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))))) import pm4py + import numpy + import pandas + import networkx pm4py.util.constants.SHOW_PROGRESS_BAR = True pm4py.util.constants.SHOW_EVENT_LOG_DEPRECATION = False pm4py.util.constants.SHOW_INTERNAL_WARNINGS = False #pm4py.util.constants.DEFAULT_TIMESTAMP_PARSE_FORMAT = None - execute_script(log_projection_dfg_variant) - execute_script(streaming_live_to_static_stream) - execute_script(powl_discovery) - execute_script(powl_parsing) - execute_script(ev_to_obj_types_graph) - execute_script(label_splitting) - execute_script(nx_ocel_to_graphviz) - execute_script(nx_traditional_to_graphviz) - execute_script(segments_retrieval_filtering) - execute_script(stochastic_petri_playout) - execute_script(simplified_interface) - execute_script(bpmn_js_visualization) - execute_script(read_write_ocel) - execute_script(discovery_data_petri_net) - execute_script(data_petri_nets) - execute_script(inhibitor_reset_arcs) - execute_script(logs_petri_visual_comparison) - execute_script(align_decomposition_example) - execute_script(ocdfg_discovery) - execute_script(woflan) - execute_script(inductive_miner) - execute_script(inductive_miner_dfg) - execute_script(inductive_miner_variants) - execute_script(heu_miner_plus_plus) - execute_script(activities_to_alphabet) - execute_script(ocel_filter_cc) - execute_script(queue_check_exponential) - execute_script(queue_check_max_conc_exec) - execute_script(timestamp_granularity) - execute_script(ocel_occm_example) - execute_script(ocel_clustering) - execute_script(ocel_enrichment) - execute_script(validation_ocel20_xml) - execute_script(consecutive_act_case_grouping_filter) - execute_script(cost_based_dfg) - execute_script(df_to_log_postpro) - execute_script(hybrid_ilp_miner) - execute_script(ml_insert_case_arrival_finish) - execute_script(ml_insert_waiting_service_time) - execute_script(ml_log_to_target_vector) - execute_script(ml_outcome_enriched) - execute_script(ocel20_import_export) - execute_script(revised_playout) - execute_script(timestamp_case_grouping_filter) - execute_script(trace_clustering) - execute_script(validation_ocel20_relational) - execute_script(interval_events_overlap) - execute_script(kneighb_regression) - execute_script(log_to_int_tree_open_paths) - execute_script(murata_reduction) - execute_script(ocel_merge_duplicates) - execute_script(ocel_saw_net_disc) - execute_script(ocel_to_nx) - execute_script(saw_net_ocel_multi) - execute_script(saw_net_ocel_single) - execute_script(temporal_features) - execute_script(transform_db_to_ocel) - execute_script(transform_db_to_xes) - execute_script(transform_db_to_ocel_2) - execute_script(feature_extraction_ocel) - execute_script(ocel_validation) - execute_script(process_tree_frequency_annotation) - execute_script(tree_manual_generation) - execute_script(workalendar_example) - execute_script(merging_case_relations) - execute_script(activity_position) - execute_script(link_analysis_vbfa) - execute_script(ocel_streaming) - execute_script(petri_manual_generation) - #execute_script(timestamp_interleavings) - execute_script(object_centric_petri_net_discovery) - execute_script(trans_system_stochastic_view) - execute_script(network_analysis) - execute_script(enrich_log_with_align) - execute_script(extended_marking_equation) - execute_script(features_locally_linear_embedding) - execute_script(dotted_chart) - execute_script(performance_spectrum) - execute_script(orgmining_local_diagn) - execute_script(resource_profiles_log) - execute_script(resource_profile_pandas) - execute_script(process_tree_reduction) - execute_script(dataframe_prefix_and_fea_extraction) - execute_script(logs_alignments) - execute_script(bpmn_from_pt) - execute_script(bpmn_import_and_to_petri_net) - execute_script(tree_playout) - execute_script(emd_evaluation) - execute_script(footprints_tree_conf) - execute_script(footprints_petri_net) - execute_script(corr_mining) - execute_script(log_skeleton) - execute_script(roles_detection) - execute_script(alignment_test) - execute_script(dec_treplay_imdf) - execute_script(imdf_example) - execute_script(test_evaluation) - execute_script(sna_log) - execute_script(token_replay_alpha) - execute_script(manual_log_generation) - execute_script(token_replay_imdf) - execute_script(decisiontree_trivial_example) - execute_script(decisiontree_align_example) - execute_script(transition_system_test) - execute_script(heu_miner_test) - execute_script(dfg_min_ex_log) - execute_script(dfg_min_ex_pandas) - execute_script(graphs_visualization) - execute_script(backwards_token_replay) - execute_script(transient_dfg) - execute_script(transient_petri_net) - execute_script(example_check_fitness) - execute_script(pn_to_pt) - execute_script(align_approx_pt) - execute_script(visualization_processtree) - execute_script(visualization_align_table) - execute_script(declare_simple) - execute_script(variants_paths_duration) - execute_script(feature_extraction_case_loc) - execute_script(log_skeleton_manual_constraints) - execute_script(trace_attrib_hierarch_cluster) - execute_script(streaming_conformance_footprints) - execute_script(streaming_conformance_tbr) - execute_script(streaming_csv_reader_event_stream) - execute_script(streaming_discovery_dfg) - execute_script(streaming_xes_reader_event_stream) - execute_script(streaming_xes_reader_trace_stream) - execute_script(monte_carlo_dfg) - execute_script(monte_carlo_petri_net) + if EXECUTE_EXAMPLES: + execute_script(log_projection_dfg_variant) + execute_script(streaming_live_to_static_stream) + execute_script(powl_discovery) + execute_script(powl_parsing) + execute_script(ev_to_obj_types_graph) + execute_script(label_splitting) + execute_script(nx_ocel_to_graphviz) + execute_script(nx_traditional_to_graphviz) + execute_script(segments_retrieval_filtering) + execute_script(stochastic_petri_playout) + execute_script(simplified_interface) + execute_script(bpmn_js_visualization) + execute_script(read_write_ocel) + execute_script(discovery_data_petri_net) + execute_script(data_petri_nets) + execute_script(inhibitor_reset_arcs) + execute_script(logs_petri_visual_comparison) + execute_script(align_decomposition_example) + execute_script(ocdfg_discovery) + execute_script(woflan) + execute_script(inductive_miner) + execute_script(inductive_miner_dfg) + execute_script(inductive_miner_variants) + execute_script(heu_miner_plus_plus) + execute_script(activities_to_alphabet) + execute_script(ocel_filter_cc) + execute_script(queue_check_exponential) + execute_script(queue_check_max_conc_exec) + execute_script(timestamp_granularity) + execute_script(ocel_occm_example) + execute_script(ocel_clustering) + execute_script(ocel_enrichment) + execute_script(validation_ocel20_xml) + execute_script(consecutive_act_case_grouping_filter) + execute_script(cost_based_dfg) + execute_script(df_to_log_postpro) + execute_script(hybrid_ilp_miner) + execute_script(ml_insert_case_arrival_finish) + execute_script(ml_insert_waiting_service_time) + execute_script(ml_log_to_target_vector) + execute_script(ml_outcome_enriched) + execute_script(ocel20_import_export) + execute_script(revised_playout) + execute_script(timestamp_case_grouping_filter) + execute_script(trace_clustering) + execute_script(validation_ocel20_relational) + execute_script(interval_events_overlap) + execute_script(kneighb_regression) + execute_script(log_to_int_tree_open_paths) + execute_script(murata_reduction) + execute_script(ocel_merge_duplicates) + execute_script(ocel_saw_net_disc) + execute_script(ocel_to_nx) + execute_script(saw_net_ocel_multi) + execute_script(saw_net_ocel_single) + execute_script(temporal_features) + execute_script(transform_db_to_ocel) + execute_script(transform_db_to_xes) + execute_script(transform_db_to_ocel_2) + execute_script(feature_extraction_ocel) + execute_script(ocel_validation) + execute_script(process_tree_frequency_annotation) + execute_script(tree_manual_generation) + execute_script(workalendar_example) + execute_script(merging_case_relations) + execute_script(activity_position) + execute_script(link_analysis_vbfa) + execute_script(ocel_streaming) + execute_script(petri_manual_generation) + #execute_script(timestamp_interleavings) + execute_script(object_centric_petri_net_discovery) + execute_script(trans_system_stochastic_view) + execute_script(network_analysis) + execute_script(enrich_log_with_align) + execute_script(extended_marking_equation) + execute_script(features_locally_linear_embedding) + execute_script(dotted_chart) + execute_script(performance_spectrum) + execute_script(orgmining_local_diagn) + execute_script(resource_profiles_log) + execute_script(resource_profile_pandas) + execute_script(process_tree_reduction) + execute_script(dataframe_prefix_and_fea_extraction) + execute_script(logs_alignments) + execute_script(bpmn_from_pt) + execute_script(bpmn_import_and_to_petri_net) + execute_script(tree_playout) + execute_script(emd_evaluation) + execute_script(footprints_tree_conf) + execute_script(footprints_petri_net) + execute_script(corr_mining) + execute_script(log_skeleton) + execute_script(roles_detection) + execute_script(alignment_test) + execute_script(dec_treplay_imdf) + execute_script(imdf_example) + execute_script(test_evaluation) + execute_script(sna_log) + execute_script(token_replay_alpha) + execute_script(manual_log_generation) + execute_script(token_replay_imdf) + execute_script(decisiontree_trivial_example) + execute_script(decisiontree_align_example) + execute_script(transition_system_test) + execute_script(heu_miner_test) + execute_script(dfg_min_ex_log) + execute_script(dfg_min_ex_pandas) + execute_script(graphs_visualization) + execute_script(backwards_token_replay) + execute_script(transient_dfg) + execute_script(transient_petri_net) + execute_script(example_check_fitness) + execute_script(pn_to_pt) + execute_script(align_approx_pt) + execute_script(visualization_processtree) + execute_script(visualization_align_table) + execute_script(declare_simple) + execute_script(variants_paths_duration) + execute_script(feature_extraction_case_loc) + execute_script(log_skeleton_manual_constraints) + execute_script(trace_attrib_hierarch_cluster) + execute_script(streaming_conformance_footprints) + execute_script(streaming_conformance_tbr) + execute_script(streaming_csv_reader_event_stream) + execute_script(streaming_discovery_dfg) + execute_script(streaming_xes_reader_event_stream) + execute_script(streaming_xes_reader_trace_stream) + execute_script(monte_carlo_dfg) + execute_script(monte_carlo_petri_net) + + print("numpy version: "+str(numpy.__version__)) + print("pandas version: "+str(pandas.__version__)) + print("networkx version: "+str(networkx.__version__)) + + if importlib.util.find_spec("scipy"): + import scipy + print("scipy version: "+str(scipy.__version__)) + + if importlib.util.find_spec("lxml"): + import lxml + print("lxml version: "+str(lxml.__version__)) + + if importlib.util.find_spec("matplotlib"): + import matplotlib + print("matplotlib version: "+str(matplotlib.__version__)) + + if importlib.util.find_spec("sklearn"): + import sklearn + print("sklearn version: "+str(sklearn.__version__)) + + print("pm4py version: "+str(pm4py.__version__)) if __name__ == "__main__": diff --git a/examples/features_locally_linear_embedding.py b/examples/features_locally_linear_embedding.py index 95d31116b..41570183a 100644 --- a/examples/features_locally_linear_embedding.py +++ b/examples/features_locally_linear_embedding.py @@ -3,17 +3,22 @@ import pm4py from pm4py.algo.transformation.log_to_features.util import locally_linear_embedding from examples import examples_conf -from pm4py.visualization.graphs import visualizer +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "receipt.xes")) - # calculates the graph: - # values of y more distant from 0 signal executions that differ from the mainstream behavior - x, y = locally_linear_embedding.apply(log) - gviz = visualizer.apply(x, y, variant=visualizer.Variants.DATES, - parameters={"title": "Locally Linear Embedding", "format": examples_conf.TARGET_IMG_FORMAT, "y_axis": "Intensity"}) - visualizer.view(gviz) + + if importlib.util.find_spec("scipy") and importlib.util.find_spec("sklearn"): + # calculates the graph: + # values of y more distant from 0 signal executions that differ from the mainstream behavior + x, y = locally_linear_embedding.apply(log) + + if importlib.util.find_spec("matplotlib") and importlib.util.find_spec("graphviz"): + from pm4py.visualization.graphs import visualizer + gviz = visualizer.apply(x, y, variant=visualizer.Variants.DATES, + parameters={"title": "Locally Linear Embedding", "format": examples_conf.TARGET_IMG_FORMAT, "y_axis": "Intensity"}) + visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/footprints_petri_net.py b/examples/footprints_petri_net.py index 01f6d1df3..4048cef2c 100644 --- a/examples/footprints_petri_net.py +++ b/examples/footprints_petri_net.py @@ -4,9 +4,9 @@ from pm4py.objects.conversion.process_tree import converter from pm4py.algo.discovery.footprints import algorithm as footprints_discovery from pm4py.algo.conformance.footprints import algorithm as footprints_conformance -from pm4py.visualization.footprints import visualizer as fp_visualizer import os from examples import examples_conf +import importlib.util @@ -40,9 +40,12 @@ def execute_script(): # finds the footprints for the entire log (not case-by-case, but taking # the relations that appear inside the entire log) fp_log_entire = footprints_discovery.apply(log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG) - # visualize the footprint table - gviz = fp_visualizer.apply(fp_log_entire, fp_net, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - fp_visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + # visualize the footprint table + from pm4py.visualization.footprints import visualizer as fp_visualizer + gviz = fp_visualizer.apply(fp_log_entire, fp_net, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + fp_visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/footprints_tree_conf.py b/examples/footprints_tree_conf.py index 838526fbd..46a9f3b37 100644 --- a/examples/footprints_tree_conf.py +++ b/examples/footprints_tree_conf.py @@ -2,8 +2,6 @@ from pm4py.algo.discovery.inductive import algorithm as inductive_miner from pm4py.algo.discovery.footprints import algorithm as fp_discovery from pm4py.algo.conformance.footprints import algorithm as fp_conformance -from pm4py.algo.conformance.footprints.util import tree_visualization -from pm4py.visualization.process_tree import visualizer as pt_visualizer from pm4py.statistics.traces.generic.log import case_statistics from pm4py.algo.discovery.dfg import algorithm as dfg_discovery from pm4py.algo.filtering.log.paths import paths_filter @@ -12,6 +10,7 @@ from pm4py.statistics.variants.log import get as variants_get from examples import examples_conf import os +import importlib.util def execute_script(): @@ -49,13 +48,17 @@ def execute_script(): var_throughput = case_statistics.get_median_case_duration(variants[var]) print("%s\t\t%d\t\t%s\t\t%s\t\t%s" % (vark, occ, is_fit, throughput_time, human_readable_stat(var_throughput))) - # print(conf_occ) - conf_colors = tree_visualization.apply(tree, conf) - if True: - gviz = pt_visualizer.apply(tree, parameters={"format": examples_conf.TARGET_IMG_FORMAT, - pt_visualizer.Variants.WO_DECORATION.value.Parameters.COLOR_MAP: conf_colors, - pt_visualizer.Variants.WO_DECORATION.value.Parameters.ENABLE_DEEPCOPY: False}) - pt_visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.algo.conformance.footprints.util import tree_visualization + from pm4py.visualization.process_tree import visualizer as pt_visualizer + # print(conf_occ) + conf_colors = tree_visualization.apply(tree, conf) + if True: + gviz = pt_visualizer.apply(tree, parameters={"format": examples_conf.TARGET_IMG_FORMAT, + pt_visualizer.Variants.WO_DECORATION.value.Parameters.COLOR_MAP: conf_colors, + pt_visualizer.Variants.WO_DECORATION.value.Parameters.ENABLE_DEEPCOPY: False}) + pt_visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/graphs_visualization.py b/examples/graphs_visualization.py index 31685cf32..8d4125d86 100644 --- a/examples/graphs_visualization.py +++ b/examples/graphs_visualization.py @@ -2,16 +2,18 @@ import pm4py from examples import examples_conf +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "receipt.xes")) - # visualize case duration graph - pm4py.view_case_duration_graph(log, format=examples_conf.TARGET_IMG_FORMAT) + if importlib.util.find_spec("graphviz"): + # visualize case duration graph + pm4py.view_case_duration_graph(log, format=examples_conf.TARGET_IMG_FORMAT) - # visualize events over time graph - pm4py.view_events_per_time_graph(log, format=examples_conf.TARGET_IMG_FORMAT) + # visualize events over time graph + pm4py.view_events_per_time_graph(log, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/heu_miner_test.py b/examples/heu_miner_test.py index 241a62c11..6eb52e516 100644 --- a/examples/heu_miner_test.py +++ b/examples/heu_miner_test.py @@ -2,21 +2,27 @@ from pm4py.algo.discovery.heuristics import algorithm as heuristics_miner from pm4py.objects.log.importer.xes import importer as xes_importer -from pm4py.visualization.heuristics_net import visualizer as hn_vis -from pm4py.visualization.petri_net import visualizer as petri_vis from examples import examples_conf +import importlib.util def execute_script(): log = xes_importer.apply(os.path.join("..", "tests", "compressed_input_data", "09_a32f0n00.xes.gz")) heu_net = heuristics_miner.apply_heu(log, parameters={ heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99}) - gviz = hn_vis.apply(heu_net, parameters={hn_vis.Variants.PYDOTPLUS.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - hn_vis.view(gviz) + + if importlib.util.find_spec("pydotplus") and importlib.util.find_spec("graphviz"): + from pm4py.visualization.heuristics_net import visualizer as hn_vis + gviz = hn_vis.apply(heu_net, parameters={hn_vis.Variants.PYDOTPLUS.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + hn_vis.view(gviz) + net, im, fm = heuristics_miner.apply(log, parameters={ heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99}) - gviz2 = petri_vis.apply(net, im, fm, parameters={petri_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - petri_vis.view(gviz2) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as petri_vis + gviz2 = petri_vis.apply(net, im, fm, parameters={petri_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + petri_vis.view(gviz2) if __name__ == "__main__": diff --git a/examples/heuminer_plusplus.py b/examples/heuminer_plusplus.py index d9233da0e..aef932c85 100644 --- a/examples/heuminer_plusplus.py +++ b/examples/heuminer_plusplus.py @@ -1,10 +1,9 @@ import pm4py from pm4py.algo.discovery.heuristics.variants import plusplus -from pm4py.visualization.heuristics_net import visualizer -from pm4py.visualization.petri_net import visualizer as pn_visualizer from pm4py.util import constants, pandas_utils from pm4py.objects.log.util import dataframe_utils from examples import examples_conf +import importlib.util def execute_script(): @@ -13,16 +12,23 @@ def execute_script(): log = pm4py.read_xes("../tests/input_data/interval_event_log.xes") heu_net = plusplus.apply_heu(log, parameters={"heu_net_decoration": "performance"}) heu_net_2 = plusplus.apply_heu_pandas(df, parameters={"heu_net_decoration": "performance"}) - gviz = visualizer.apply(heu_net, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - visualizer.view(gviz) - gviz2 = visualizer.apply(heu_net_2, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - visualizer.view(gviz2) + + if importlib.util.find_spec("pydotplus") and importlib.util.find_spec("graphviz"): + from pm4py.visualization.heuristics_net import visualizer + gviz = visualizer.apply(heu_net, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + visualizer.view(gviz) + gviz2 = visualizer.apply(heu_net_2, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + visualizer.view(gviz2) + net1, im1, fm1 = plusplus.apply(log) net2, im2, fm2 = plusplus.apply(log) - gviz3 = pn_visualizer.apply(net1, im1, fm1, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - pn_visualizer.view(gviz3) - gviz4 = pn_visualizer.apply(net2, im2, fm2, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - pn_visualizer.view(gviz4) + + if importlib.util.find_spec("pydotplus") and importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_visualizer + gviz3 = pn_visualizer.apply(net1, im1, fm1, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + pn_visualizer.view(gviz3) + gviz4 = pn_visualizer.apply(net2, im2, fm2, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + pn_visualizer.view(gviz4) if __name__ == "__main__": diff --git a/examples/hybrid_ilp_miner.py b/examples/hybrid_ilp_miner.py index e4b99221b..fa70f568c 100644 --- a/examples/hybrid_ilp_miner.py +++ b/examples/hybrid_ilp_miner.py @@ -1,13 +1,16 @@ import pm4py import os from examples import examples_conf +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "running-example.xes")) net, im, fm = pm4py.discover_petri_net_ilp(log) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/im_example.py b/examples/im_example.py index d2b8ad687..b95779312 100644 --- a/examples/im_example.py +++ b/examples/im_example.py @@ -4,9 +4,9 @@ import pm4py from pm4py.algo.discovery.inductive import algorithm as inductive from pm4py.objects.log.importer.xes import importer as xes_importer -from pm4py.visualization.petri_net import visualizer as pn_vis from pm4py.objects.conversion.process_tree import converter as process_tree_converter from examples import examples_conf +import importlib.util def execute_script(): @@ -19,10 +19,13 @@ def execute_script(): print("initial marking " + place.name) for place in final_marking: print("final marking " + place.name) - gviz = pn_vis.apply(net, marking, final_marking, - parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT, - pn_vis.Variants.WO_DECORATION.value.Parameters.DEBUG: True}) - pn_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_vis + gviz = pn_vis.apply(net, marking, final_marking, + parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT, + pn_vis.Variants.WO_DECORATION.value.Parameters.DEBUG: True}) + pn_vis.view(gviz) if True: fit_traces = [] diff --git a/examples/inductive_miner.py b/examples/inductive_miner.py index 86f8c3fd9..a46eb2c03 100644 --- a/examples/inductive_miner.py +++ b/examples/inductive_miner.py @@ -1,15 +1,21 @@ import pm4py import os from examples import examples_conf +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "running-example.xes")) tree = pm4py.discover_process_tree_inductive(log, noise_threshold=0.2) - pm4py.view_process_tree(tree, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_process_tree(tree, format=examples_conf.TARGET_IMG_FORMAT) + net, im, fm = pm4py.convert_to_petri_net(tree) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/inductive_miner_dfg.py b/examples/inductive_miner_dfg.py index 8a5e2f0db..2e0d5dcb1 100644 --- a/examples/inductive_miner_dfg.py +++ b/examples/inductive_miner_dfg.py @@ -2,6 +2,7 @@ import os from pm4py.objects.dfg.obj import DFG from examples import examples_conf +import importlib.util def execute_script(): @@ -12,9 +13,11 @@ def execute_script(): typed_dfg_2 = DFG(dfg, sa, ea) tree = pm4py.discover_process_tree_inductive(typed_dfg_2, noise_threshold=0.2) - pm4py.view_process_tree(tree, format=examples_conf.TARGET_IMG_FORMAT) net, im, fm = pm4py.convert_to_petri_net(tree) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_process_tree(tree, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/inductive_miner_variants.py b/examples/inductive_miner_variants.py index 85c27671c..7a7767ef7 100644 --- a/examples/inductive_miner_variants.py +++ b/examples/inductive_miner_variants.py @@ -5,6 +5,7 @@ from pm4py.algo.discovery.inductive.variants.imf import IMFUVCL from pm4py.algo.discovery.inductive.dtypes.im_ds import IMDataStructureUVCL from examples import examples_conf +import importlib.util def execute_script(): @@ -17,9 +18,11 @@ def execute_script(): imfuvcl = IMFUVCL(parameters) tree = imfuvcl.apply(IMDataStructureUVCL(uvcl), parameters=parameters) - pm4py.view_process_tree(tree, format=examples_conf.TARGET_IMG_FORMAT) net, im, fm = pm4py.convert_to_petri_net(tree) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_process_tree(tree, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/inhibitor_reset_arcs.py b/examples/inhibitor_reset_arcs.py index 5a93603ed..1e6e4c256 100644 --- a/examples/inhibitor_reset_arcs.py +++ b/examples/inhibitor_reset_arcs.py @@ -4,6 +4,7 @@ from pm4py.objects.petri_net.inhibitor_reset import semantics from copy import deepcopy from examples import examples_conf +import importlib.util def execute_script(): @@ -42,7 +43,10 @@ def execute_script(): reset_arc = add_arc_from_to(p_reset, trans_C, net, type="reset") im = Marking({source: 1}) fm = Marking({sink: 1}) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + m = semantics.execute(trans_A, net, im) print(m) # B is enabled in m because no tokens in the "inhibitor" place diff --git a/examples/logs_petri_visual_comparison.py b/examples/logs_petri_visual_comparison.py index fcc315e30..1a01bd18d 100644 --- a/examples/logs_petri_visual_comparison.py +++ b/examples/logs_petri_visual_comparison.py @@ -4,9 +4,9 @@ from pm4py.algo.comparison.petrinet import element_usage_comparison from pm4py.objects.log.util import sorting from pm4py.objects.log.obj import EventLog -from pm4py.visualization.petri_net import visualizer as pn_vis from pm4py.objects.conversion.process_tree import converter as process_tree_converter from examples import examples_conf +import importlib.util def execute_script(): @@ -17,9 +17,12 @@ def execute_script(): log1 = EventLog(log[:500]) log2 = EventLog(log[len(log) - 500:]) statistics = element_usage_comparison.compare_element_usage_two_logs(net, im, fm, log1, log2) - gviz = pn_vis.apply(net, im, fm, variant=pn_vis.Variants.FREQUENCY, aggregated_statistics=statistics, - parameters={pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - pn_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_vis + gviz = pn_vis.apply(net, im, fm, variant=pn_vis.Variants.FREQUENCY, aggregated_statistics=statistics, + parameters={pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + pn_vis.view(gviz) if __name__ == "__main__": diff --git a/examples/neo4j_ocel.py b/examples/neo4j_ocel.py index bdc836910..a802696b3 100644 --- a/examples/neo4j_ocel.py +++ b/examples/neo4j_ocel.py @@ -2,6 +2,7 @@ from neo4j import GraphDatabase from examples import examples_conf from pm4py.util import nx_utils +import importlib.util def execute_script(): @@ -34,9 +35,10 @@ def execute_script(): print(ocel2) # shows the object-centric directly-follows graph on the screen - ocdfg = pm4py.discover_ocdfg(ocel2) - pm4py.view_ocdfg(ocdfg, annotation="frequency", format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_ocdfg(ocdfg, annotation="performance", format=examples_conf.TARGET_IMG_FORMAT) + if importlib.util.find_spec("graphviz"): + ocdfg = pm4py.discover_ocdfg(ocel2) + pm4py.view_ocdfg(ocdfg, annotation="frequency", format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_ocdfg(ocdfg, annotation="performance", format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/network_analysis.py b/examples/network_analysis.py index 504debf80..94f466fc5 100644 --- a/examples/network_analysis.py +++ b/examples/network_analysis.py @@ -1,6 +1,7 @@ import os import pm4py from examples import examples_conf +import importlib.util @@ -16,7 +17,9 @@ def execute_script(): # concept:name (activity) frequency_edges = pm4py.discover_network_analysis(log, out_column="case:concept:name", in_column="case:concept:name", node_column_source="org:group", node_column_target="org:group", edge_column="concept:name", performance=False) - pm4py.view_network_analysis(frequency_edges, variant="frequency", format=examples_conf.TARGET_IMG_FORMAT, edge_threshold=10) + + if importlib.util.find_spec("graphviz"): + pm4py.view_network_analysis(frequency_edges, variant="frequency", format=examples_conf.TARGET_IMG_FORMAT, edge_threshold=10) # performance view of the network analysis @@ -27,10 +30,14 @@ def execute_script(): # concept:name (activity) performance_edges = pm4py.discover_network_analysis(log, out_column="case:concept:name", in_column="case:concept:name", node_column_source="org:group", node_column_target="org:group", edge_column="concept:name", performance=True) - pm4py.view_network_analysis(performance_edges, variant="performance", format=examples_conf.TARGET_IMG_FORMAT, edge_threshold=10) + + if importlib.util.find_spec("graphviz"): + pm4py.view_network_analysis(performance_edges, variant="performance", format=examples_conf.TARGET_IMG_FORMAT, edge_threshold=10) resource_group_edges = pm4py.discover_network_analysis(log, out_column="case:concept:name", in_column="case:concept:name", node_column_source="org:resource", node_column_target="org:group", edge_column="org:resource", performance=False) - pm4py.view_network_analysis(resource_group_edges, variant="frequency", format=examples_conf.TARGET_IMG_FORMAT, edge_threshold=10) + + if importlib.util.find_spec("graphviz"): + pm4py.view_network_analysis(resource_group_edges, variant="frequency", format=examples_conf.TARGET_IMG_FORMAT, edge_threshold=10) if __name__ == "__main__": diff --git a/examples/nx_ocel_to_graphviz.py b/examples/nx_ocel_to_graphviz.py index 8ffe71188..9f13ebd44 100644 --- a/examples/nx_ocel_to_graphviz.py +++ b/examples/nx_ocel_to_graphviz.py @@ -1,6 +1,6 @@ import pm4py -from pm4py.visualization.networkx import visualizer as nx_to_gv_vis from examples import examples_conf +import importlib.util def execute_script(): @@ -9,9 +9,12 @@ def execute_script(): # convers the OCEL to a NetworkX graph with events, objects, E2O, O2O, and object changes event_graph = pm4py.convert_ocel_to_networkx(ocel) - # visualize the NX DiGraph using Graphviz - gviz = nx_to_gv_vis.apply(event_graph, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - nx_to_gv_vis.view(gviz) + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.networkx import visualizer as nx_to_gv_vis + + # visualize the NX DiGraph using Graphviz + gviz = nx_to_gv_vis.apply(event_graph, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + nx_to_gv_vis.view(gviz) if __name__ == "__main__": diff --git a/examples/nx_traditional_to_graphviz.py b/examples/nx_traditional_to_graphviz.py index 13d473b8f..c58b0e1ea 100644 --- a/examples/nx_traditional_to_graphviz.py +++ b/examples/nx_traditional_to_graphviz.py @@ -1,6 +1,6 @@ import pm4py -from pm4py.visualization.networkx import visualizer as nx_to_gv_vis from examples import examples_conf +import importlib.util def execute_script(): @@ -9,9 +9,12 @@ def execute_script(): # are represented in a graph (NetworkX DiGraph) event_graph = pm4py.convert_log_to_networkx(log) - # visualize the NX DiGraph using Graphviz - gviz = nx_to_gv_vis.apply(event_graph, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - nx_to_gv_vis.view(gviz) + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.networkx import visualizer as nx_to_gv_vis + + # visualize the NX DiGraph using Graphviz + gviz = nx_to_gv_vis.apply(event_graph, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + nx_to_gv_vis.view(gviz) if __name__ == "__main__": diff --git a/examples/object_centric_petri_net_discovery.py b/examples/object_centric_petri_net_discovery.py index 11794c9a8..75f7e416d 100644 --- a/examples/object_centric_petri_net_discovery.py +++ b/examples/object_centric_petri_net_discovery.py @@ -1,13 +1,16 @@ import pm4py from examples import examples_conf import os +import importlib.util def execute_script(): ocel = pm4py.read_ocel(os.path.join("..", "tests", "input_data", "ocel", "example_log.jsonocel")) model = pm4py.discover_oc_petri_net(ocel) print(model.keys()) - pm4py.view_ocpn(model, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_ocpn(model, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/ocdfg_discovery.py b/examples/ocdfg_discovery.py index bfbd4d898..82b3b112a 100644 --- a/examples/ocdfg_discovery.py +++ b/examples/ocdfg_discovery.py @@ -1,15 +1,18 @@ import pm4py from examples import examples_conf import os +import importlib.util def execute_script(): ocel = pm4py.read_ocel(os.path.join("..", "tests", "input_data", "ocel", "example_log.jsonocel")) ocdfg = pm4py.discover_ocdfg(ocel) - # views the model with the frequency annotation - pm4py.view_ocdfg(ocdfg, format=examples_conf.TARGET_IMG_FORMAT) - # views the model with the performance annotation - pm4py.view_ocdfg(ocdfg, format=examples_conf.TARGET_IMG_FORMAT, annotation="performance", performance_aggregation="median") + + if importlib.util.find_spec("graphviz"): + # views the model with the frequency annotation + pm4py.view_ocdfg(ocdfg, format=examples_conf.TARGET_IMG_FORMAT) + # views the model with the performance annotation + pm4py.view_ocdfg(ocdfg, format=examples_conf.TARGET_IMG_FORMAT, annotation="performance", performance_aggregation="median") if __name__ == "__main__": diff --git a/examples/ocel20_import_export.py b/examples/ocel20_import_export.py index 52ee0e55d..58aa14dff 100644 --- a/examples/ocel20_import_export.py +++ b/examples/ocel20_import_export.py @@ -1,18 +1,30 @@ import pm4py import os +import traceback def execute_script(): - ocel = pm4py.read_ocel2("../tests/input_data/ocel/ocel20_example.sqlite") - pm4py.write_ocel2(ocel, "ocel20_example_bis.sqlite") - pm4py.write_ocel2(ocel, "ocel20_example_bis.xmlocel") - ocel = pm4py.read_ocel2("../tests/input_data/ocel/ocel20_example.xmlocel") - pm4py.write_ocel2(ocel, "ocel20_example_tris.sqlite") - pm4py.write_ocel2(ocel, "ocel20_example_tris.xmlocel") - os.remove("ocel20_example_bis.sqlite") - os.remove("ocel20_example_bis.xmlocel") - os.remove("ocel20_example_tris.sqlite") - os.remove("ocel20_example_tris.xmlocel") + try: + ocel = pm4py.read_ocel2("../tests/input_data/ocel/ocel20_example.sqlite") + pm4py.write_ocel2(ocel, "ocel20_example_bis.sqlite") + pm4py.write_ocel2(ocel, "ocel20_example_bis.xmlocel") + ocel = pm4py.read_ocel2("../tests/input_data/ocel/ocel20_example.xmlocel") + pm4py.write_ocel2(ocel, "ocel20_example_tris.sqlite") + pm4py.write_ocel2(ocel, "ocel20_example_tris.xmlocel") + except: + traceback.print_exc() + + if os.path.exists("ocel20_example_bis.sqlite"): + os.remove("ocel20_example_bis.sqlite") + + if os.path.exists("ocel20_example_bis.xmlocel"): + os.remove("ocel20_example_bis.xmlocel") + + if os.path.exists("ocel20_example_tris.sqlite"): + os.remove("ocel20_example_tris.sqlite") + + if os.path.exists("ocel20_example_tris.xmlocel"): + os.remove("ocel20_example_tris.xmlocel") if __name__ == "__main__": diff --git a/examples/ocel_saw_net_disc.py b/examples/ocel_saw_net_disc.py index 31019ff3e..98867dade 100644 --- a/examples/ocel_saw_net_disc.py +++ b/examples/ocel_saw_net_disc.py @@ -2,15 +2,18 @@ from pm4py.algo.discovery.ocel.saw_nets import algorithm as saw_nets_disc from pm4py.objects.petri_net.obj import Marking from examples import examples_conf +import importlib.util def execute_script(): ocel = pm4py.read_ocel("../tests/input_data/ocel/ocel_order_simulated.csv") res = saw_nets_disc.apply(ocel) - for ot in res["ot_saw_nets"]: - pm4py.view_petri_net(res["ot_saw_nets"][ot], Marking(), Marking(), format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_petri_net(res["multi_saw_net"], Marking(), Marking(), decorations=res["decorations_multi_saw_net"], - format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + for ot in res["ot_saw_nets"]: + pm4py.view_petri_net(res["ot_saw_nets"][ot], Marking(), Marking(), format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_petri_net(res["multi_saw_net"], Marking(), Marking(), decorations=res["decorations_multi_saw_net"], + format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/perf_spectrum_visualization.py b/examples/perf_spectrum_visualization.py index 820ae4a8a..776d6801f 100644 --- a/examples/perf_spectrum_visualization.py +++ b/examples/perf_spectrum_visualization.py @@ -3,16 +3,22 @@ from pm4py.util import constants, pandas_utils from pm4py.objects.log.util import dataframe_utils from examples import examples_conf +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "receipt.xes")) - pm4py.view_performance_spectrum(log, ["Confirmation of receipt", "T04 Determine confirmation of receipt", - "T10 Determine necessity to stop indication"], format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_performance_spectrum(log, ["Confirmation of receipt", "T04 Determine confirmation of receipt", + "T10 Determine necessity to stop indication"], format=examples_conf.TARGET_IMG_FORMAT) + df = pandas_utils.read_csv(os.path.join("..", "tests", "input_data", "receipt.csv")) df = dataframe_utils.convert_timestamp_columns_in_df(df, timest_format=constants.DEFAULT_TIMESTAMP_PARSE_FORMAT, timest_columns=["time:timestamp"]) - pm4py.view_performance_spectrum(df, ["Confirmation of receipt", "T04 Determine confirmation of receipt", - "T10 Determine necessity to stop indication"], format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_performance_spectrum(df, ["Confirmation of receipt", "T04 Determine confirmation of receipt", + "T10 Determine necessity to stop indication"], format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/petri_manual_generation.py b/examples/petri_manual_generation.py index 6a38c1452..362dd73e6 100644 --- a/examples/petri_manual_generation.py +++ b/examples/petri_manual_generation.py @@ -2,7 +2,7 @@ from pm4py.objects.petri_net.obj import PetriNet, Marking from pm4py.objects.petri_net.utils import petri_utils from examples import examples_conf - +import importlib.util def execute_script(): @@ -48,7 +48,8 @@ def execute_script(): fm = Marking() fm[sink] = 1 - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) #pm4py.write_pnml(net, im, fm, "receipt_one_variant.pnml") diff --git a/examples/pn_to_pt.py b/examples/pn_to_pt.py index ba518e302..e6e4623a3 100644 --- a/examples/pn_to_pt.py +++ b/examples/pn_to_pt.py @@ -7,6 +7,7 @@ from pm4py.objects.conversion.process_tree import converter as pt_converter from pm4py.objects.conversion.wf_net import converter as wf_net_converter from examples import examples_conf +import importlib.util def execute_script(): diff --git a/examples/powl_discovery.py b/examples/powl_discovery.py index d4446ff5d..869c0c14d 100644 --- a/examples/powl_discovery.py +++ b/examples/powl_discovery.py @@ -1,7 +1,7 @@ import pm4py from examples import examples_conf from pm4py.algo.discovery.powl.inductive.variants.powl_discovery_varaints import POWLDiscoveryVariant -from pm4py.visualization.powl.visualizer import POWLVisualizationVariants +import importlib.util def execute_script(): @@ -14,12 +14,15 @@ def execute_script(): print(powl_model) # views the POWL model on the screen - pm4py.view_powl(powl_model, format=examples_conf.TARGET_IMG_FORMAT, variant_str="basic") - pm4py.view_powl(powl_model, format=examples_conf.TARGET_IMG_FORMAT, variant_str="net") + if importlib.util.find_spec("graphviz"): + pm4py.view_powl(powl_model, format=examples_conf.TARGET_IMG_FORMAT, variant_str="basic") + pm4py.view_powl(powl_model, format=examples_conf.TARGET_IMG_FORMAT, variant_str="net") # converts the POWL model to a Petri net (which can be used for conformance checking) net, im, fm = pm4py.convert_to_petri_net(powl_model) - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/powl_parsing.py b/examples/powl_parsing.py index 2cf5210f1..2b725f894 100644 --- a/examples/powl_parsing.py +++ b/examples/powl_parsing.py @@ -1,5 +1,6 @@ import pm4py from examples import examples_conf +import importlib.util def execute_script(): @@ -17,8 +18,9 @@ def execute_script(): print(powl_string2) print(len(powl_string), len(powl_string2)) - # represents the parsed model on the screen - pm4py.view_powl(powl_model2, format=examples_conf.TARGET_IMG_FORMAT) + if importlib.util.find_spec("graphviz"): + # represents the parsed model on the screen + pm4py.view_powl(powl_model2, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/process_tree_frequency_annotation.py b/examples/process_tree_frequency_annotation.py index a52200097..306a03080 100644 --- a/examples/process_tree_frequency_annotation.py +++ b/examples/process_tree_frequency_annotation.py @@ -3,6 +3,7 @@ from pm4py.algo.conformance.alignments.process_tree.util import search_graph_pt_frequency_annotation from pm4py.visualization.process_tree import visualizer as pt_visualizer from examples import examples_conf +import importlib.util def execute_script(): @@ -10,8 +11,10 @@ def execute_script(): tree = pm4py.discover_process_tree_inductive(log) aligned_traces = pm4py.conformance_diagnostics_alignments(log, tree, return_diagnostics_dataframe=False) tree = search_graph_pt_frequency_annotation.apply(tree, aligned_traces) - gviz = pt_visualizer.apply(tree, parameters={"format": examples_conf.TARGET_IMG_FORMAT}, variant=pt_visualizer.Variants.FREQUENCY_ANNOTATION) - pt_visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + gviz = pt_visualizer.apply(tree, parameters={"format": examples_conf.TARGET_IMG_FORMAT}, variant=pt_visualizer.Variants.FREQUENCY_ANNOTATION) + pt_visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/process_tree_reduction.py b/examples/process_tree_reduction.py index 3e4638230..624eee18a 100644 --- a/examples/process_tree_reduction.py +++ b/examples/process_tree_reduction.py @@ -3,18 +3,21 @@ from pm4py.algo.reduction.process_tree import reducer from pm4py.objects.log.importer.xes import importer as xes_importer from examples import examples_conf +import importlib.util def execute_script(): log = xes_importer.apply(os.path.join("..", "tests", "input_data", "receipt.xes")) # the tree discovered by inductive miner is huge and can replay the behavior of the log tree = pm4py.discover_process_tree_inductive(log) - pm4py.view_process_tree(tree, examples_conf.TARGET_IMG_FORMAT) # to make a more effective replay, remove the elements that are not being used during the replay of the trace # (that are the skippable ones, with empty intersection with the trace) tree_first_trace = reducer.apply(tree, log[0], variant=reducer.Variants.TREE_TR_BASED) - pm4py.view_process_tree(tree_first_trace, examples_conf.TARGET_IMG_FORMAT) - # much smaller, isn't it? :) + + if importlib.util.find_spec("graphviz"): + pm4py.view_process_tree(tree, examples_conf.TARGET_IMG_FORMAT) + pm4py.view_process_tree(tree_first_trace, examples_conf.TARGET_IMG_FORMAT) + # much smaller, isn't it? :) if __name__ == "__main__": diff --git a/examples/revised_playout.py b/examples/revised_playout.py index b503237cf..e2bb22ce4 100644 --- a/examples/revised_playout.py +++ b/examples/revised_playout.py @@ -2,6 +2,7 @@ from pm4py.objects.petri_net.obj import ResetInhibitorNet from pm4py.objects.petri_net.utils import petri_utils from examples import examples_conf +import importlib.util import uuid import os @@ -21,13 +22,15 @@ def execute_script(): net.places.add(new_place) petri_utils.add_arc_from_to(new_place, trans, net, type=None) im[new_place] = 1 - pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) # ensure that superset of the final marking (given the huge number of remaining tokens) are also considered valid new_log2 = pm4py.play_out(net, im, fm, parameters={"add_only_if_fm_is_reached": True, "fm_leq_accepted": True}) print(len(new_log2)) print(pm4py.get_event_attribute_values(new_log2, "concept:name")) print(pm4py.get_end_activities(new_log2)) + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(net, im, fm, format=examples_conf.TARGET_IMG_FORMAT) + if __name__ == "__main__": execute_script() diff --git a/examples/saw_net_ocel_multi.py b/examples/saw_net_ocel_multi.py index 13a6f3df7..e1936ddfd 100644 --- a/examples/saw_net_ocel_multi.py +++ b/examples/saw_net_ocel_multi.py @@ -2,7 +2,7 @@ from pm4py.objects.petri_net.utils import petri_utils from pm4py.objects.petri_net.saw_net.obj import StochasticArcWeightNet from uuid import uuid4 -from pm4py.visualization.petri_net import visualizer as pn_visualizer +import importlib.util import os @@ -135,10 +135,11 @@ def execute_script(): decorations[p3e] = {"color": "red"} decorations[skip_e] = {"color": "red"} - gviz = pn_visualizer.apply(neto, imo, fmo, parameters={"decorations": decorations}) - pn_visualizer.save(gviz, "total.png") - - os.remove("total.png") + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_visualizer + gviz = pn_visualizer.apply(neto, imo, fmo, parameters={"decorations": decorations}) + pn_visualizer.save(gviz, "total.png") + os.remove("total.png") if __name__ == "__main__": diff --git a/examples/saw_net_ocel_single.py b/examples/saw_net_ocel_single.py index 8da7e42a9..0c0bb814c 100644 --- a/examples/saw_net_ocel_single.py +++ b/examples/saw_net_ocel_single.py @@ -2,8 +2,8 @@ from pm4py.objects.petri_net.utils import petri_utils from pm4py.objects.petri_net.saw_net.obj import StochasticArcWeightNet from uuid import uuid4 -from pm4py.visualization.petri_net import visualizer as pn_visualizer import os +import importlib.util def execute_script(): @@ -61,8 +61,11 @@ def execute_script(): arc11o.weight = {1: 3} arc12o.weight = {1: 3} - gviz = pn_visualizer.apply(neto, imo, fmo) - pn_visualizer.save(gviz, "folded_order.png") + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_visualizer + gviz = pn_visualizer.apply(neto, imo, fmo) + pn_visualizer.save(gviz, "folded_order.png") + os.remove("folded_order.png") nete = StochasticArcWeightNet() ime = Marking() @@ -110,11 +113,11 @@ def execute_script(): arc9.weight = {2: 1, 3: 2} arc10.weight = {2: 1, 3: 2} - gviz = pn_visualizer.apply(nete, ime, fme) - pn_visualizer.save(gviz, "folded_item.png") - - os.remove("folded_order.png") - os.remove("folded_item.png") + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_visualizer + gviz = pn_visualizer.apply(nete, ime, fme) + pn_visualizer.save(gviz, "folded_item.png") + os.remove("folded_item.png") if __name__ == "__main__": diff --git a/examples/simplified_interface.py b/examples/simplified_interface.py index 721b29c7d..248c9c0b0 100644 --- a/examples/simplified_interface.py +++ b/examples/simplified_interface.py @@ -4,186 +4,208 @@ from pm4py.util import constants, pandas_utils from pm4py.objects.log.util import dataframe_utils from examples import examples_conf +import importlib.util +import traceback def execute_script(): ENABLE_VISUALIZATION = True - # reads a XES into an event log - log1 = pm4py.read_xes("../tests/input_data/running-example.xes") - - # reads a CSV into a dataframe - df = pandas_utils.read_csv("../tests/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") - - # converts the dataframe to an event log - log2 = pm4py.convert_to_event_log(df) - - # converts the log read from XES into a stream and dataframe respectively - stream1 = pm4py.convert_to_event_stream(log1) - df2 = pm4py.convert_to_dataframe(log1) - - # writes the log1 to a XES file - pm4py.write_xes(log1, "ru1.xes") - - dfg, dfg_sa, dfg_ea = pm4py.discover_dfg(log1) - petri_alpha, im_alpha, fm_alpha = pm4py.discover_petri_net_alpha(log1) - petri_inductive, im_inductive, fm_inductive = pm4py.discover_petri_net_inductive(log1) - petri_heuristics, im_heuristics, fm_heuristics = pm4py.discover_petri_net_heuristics(log1) - tree_inductive = pm4py.discover_process_tree_inductive(log1) - heu_net = pm4py.discover_heuristics_net(log1) - - pm4py.write_dfg(dfg, dfg_sa, dfg_ea, "ru_dfg.dfg") - pm4py.write_pnml(petri_alpha, im_alpha, fm_alpha, "ru_alpha.pnml") - pm4py.write_pnml(petri_inductive, im_inductive, fm_inductive, "ru_inductive.pnml") - pm4py.write_pnml(petri_heuristics, im_heuristics, fm_heuristics, "ru_heuristics.pnml") - pm4py.write_ptml(tree_inductive, "ru_inductive.ptml") - - dfg, dfg_sa, dfg_ea = pm4py.read_dfg("ru_dfg.dfg") - petri_alpha, im_alpha, fm_alpha = pm4py.read_pnml("ru_alpha.pnml", auto_guess_final_marking=True) - petri_inductive, im_inductive, fm_inductive = pm4py.read_pnml("ru_inductive.pnml", auto_guess_final_marking=True) - petri_heuristics, im_heuristics, fm_heuristics = pm4py.read_pnml("ru_heuristics.pnml", auto_guess_final_marking=True) - tree_inductive = pm4py.read_ptml("ru_inductive.ptml") - - pm4py.save_vis_petri_net(petri_alpha, im_alpha, fm_alpha, "ru_alpha.png") - pm4py.save_vis_petri_net(petri_inductive, im_inductive, fm_inductive, "ru_inductive.png") - pm4py.save_vis_petri_net(petri_heuristics, im_heuristics, fm_heuristics, "ru_heuristics.png") - pm4py.save_vis_process_tree(tree_inductive, "ru_inductive_tree.png") - pm4py.save_vis_heuristics_net(heu_net, "ru_heunet.png") - pm4py.save_vis_dfg(dfg, dfg_sa, dfg_ea, "ru_dfg.png") - - pm4py.save_vis_events_per_time_graph(log1, "ev_time.png") - pm4py.save_vis_case_duration_graph(log1, "cd.png") - pm4py.save_vis_dotted_chart(log1, "dotted_chart.png") - pm4py.save_vis_performance_spectrum(log1, ["register request", "decide"], "ps.png") - - if ENABLE_VISUALIZATION: - pm4py.view_petri_net(petri_alpha, im_alpha, fm_alpha, format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_petri_net(petri_inductive, im_inductive, fm_inductive, format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_petri_net(petri_heuristics, im_heuristics, fm_heuristics, format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_process_tree(tree_inductive, format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_heuristics_net(heu_net, format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_dfg(dfg, dfg_sa, dfg_ea, format=examples_conf.TARGET_IMG_FORMAT) - - aligned_traces = pm4py.conformance_diagnostics_alignments(log1, petri_inductive, im_inductive, fm_inductive, return_diagnostics_dataframe=False) - replayed_traces = pm4py.conformance_diagnostics_token_based_replay(log1, petri_inductive, im_inductive, fm_inductive, return_diagnostics_dataframe=False) - - fitness_tbr = pm4py.fitness_token_based_replay(log1, petri_inductive, im_inductive, fm_inductive) - print("fitness_tbr", fitness_tbr) - fitness_align = pm4py.fitness_alignments(log1, petri_inductive, im_inductive, fm_inductive) - print("fitness_align", fitness_align) - precision_tbr = pm4py.precision_token_based_replay(log1, petri_inductive, im_inductive, fm_inductive) - print("precision_tbr", precision_tbr) - precision_align = pm4py.precision_alignments(log1, petri_inductive, im_inductive, fm_inductive) - print("precision_align", precision_align) - - print("log start activities = ", pm4py.get_start_activities(log2)) - print("df start activities = ", pm4py.get_start_activities(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) - print("log end activities = ", pm4py.get_end_activities(log2)) - print("df end activities = ", pm4py.get_end_activities(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) - print("log attributes = ", pm4py.get_event_attributes(log2)) - print("df attributes = ", pm4py.get_event_attributes(df2)) - print("log org:resource values = ", pm4py.get_event_attribute_values(log2, "org:resource")) - print("df org:resource values = ", pm4py.get_event_attribute_values(df2, "org:resource", case_id_key="case:concept:name")) - - print("start_activities len(filt_log) = ", len(pm4py.filter_start_activities(log2, ["register request"]))) - print("start_activities len(filt_df) = ", len(pm4py.filter_start_activities(df2, ["register request"], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) - print("end_activities len(filt_log) = ", len(pm4py.filter_end_activities(log2, ["pay compensation"]))) - print("end_activities len(filt_df) = ", len(pm4py.filter_end_activities(df2, ["pay compensation"], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) - print("attributes org:resource len(filt_log) (cases) cases = ", - len(pm4py.filter_event_attribute_values(log2, "org:resource", ["Ellen"], level="case"))) - print("attributes org:resource len(filt_log) (cases) events = ", - len(pm4py.filter_event_attribute_values(log2, "org:resource", ["Ellen"], level="event"))) - print("attributes org:resource len(filt_df) (events) cases = ", - len(pm4py.filter_event_attribute_values(df2, "org:resource", ["Ellen"], level="case", case_id_key="case:concept:name"))) - print("attributes org:resource len(filt_df) (events) events = ", - len(pm4py.filter_event_attribute_values(df2, "org:resource", ["Ellen"], level="event", case_id_key="case:concept:name"))) - print("attributes org:resource len(filt_df) (events) events notpositive = ", - len(pm4py.filter_event_attribute_values(df2, "org:resource", ["Ellen"], level="event", retain=False))) - - print("rework df = ", pm4py.get_rework_cases_per_activity(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) - print("rework log = ", pm4py.get_rework_cases_per_activity(log2)) - print("cases overlap df = ", pm4py.get_case_overlap(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) - print("cases overlap log = ", pm4py.get_case_overlap(log2)) - print("cycle time df = ", pm4py.get_cycle_time(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) - print("cycle time log = ", pm4py.get_cycle_time(log2)) - pm4py.view_events_distribution_graph(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp", format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_events_distribution_graph(log2, format=examples_conf.TARGET_IMG_FORMAT) - - print("variants log = ", pm4py.get_variants_as_tuples(log2)) - print("variants df = ", pm4py.get_variants_as_tuples(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) - print("variants filter log = ", - len(pm4py.filter_variants(log2, [ - ("register request", "examine thoroughly", "check ticket", "decide", "reject request")]))) - print("variants filter df = ", - len(pm4py.filter_variants(df2, [ - ("register request", "examine thoroughly", "check ticket", "decide", "reject request")], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) - - print("paths filter log len = ", - len(pm4py.filter_directly_follows_relation(log2, [("register request", "examine casually")]))) - print("paths filter dataframe len = ", - len(pm4py.filter_directly_follows_relation(df2, [("register request", "examine casually")], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) - - print("timeframe filter log events len = ", - len(pm4py.filter_time_range(log2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="events"))) - print("timeframe filter log traces_contained len = ", - len(pm4py.filter_time_range(log2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_contained", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) - print("timeframe filter log traces_intersecting len = ", - len(pm4py.filter_time_range(log2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_intersecting"))) - print("timeframe filter df events len = ", - len(pm4py.filter_time_range(df2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="events", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) - print("timeframe filter df traces_contained len = ", - len(pm4py.filter_time_range(df2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_contained", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) - print("timeframe filter df traces_intersecting len = ", - len(pm4py.filter_time_range(df2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_intersecting", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) + try: + # reads a XES into an event log + log1 = pm4py.read_xes("../tests/input_data/running-example.xes") + + # reads a CSV into a dataframe + df = pandas_utils.read_csv("../tests/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") + + # converts the dataframe to an event log + log2 = pm4py.convert_to_event_log(df) + + # converts the log read from XES into a stream and dataframe respectively + stream1 = pm4py.convert_to_event_stream(log1) + df2 = pm4py.convert_to_dataframe(log1) + + # writes the log1 to a XES file + pm4py.write_xes(log1, "ru1.xes") + + dfg, dfg_sa, dfg_ea = pm4py.discover_dfg(log1) + petri_alpha, im_alpha, fm_alpha = pm4py.discover_petri_net_alpha(log1) + petri_inductive, im_inductive, fm_inductive = pm4py.discover_petri_net_inductive(log1) + petri_heuristics, im_heuristics, fm_heuristics = pm4py.discover_petri_net_heuristics(log1) + tree_inductive = pm4py.discover_process_tree_inductive(log1) + heu_net = pm4py.discover_heuristics_net(log1) + + pm4py.write_dfg(dfg, dfg_sa, dfg_ea, "ru_dfg.dfg") + dfg, dfg_sa, dfg_ea = pm4py.read_dfg("ru_dfg.dfg") + + if importlib.util.find_spec("lxml"): + pm4py.write_pnml(petri_alpha, im_alpha, fm_alpha, "ru_alpha.pnml") + pm4py.write_pnml(petri_inductive, im_inductive, fm_inductive, "ru_inductive.pnml") + pm4py.write_pnml(petri_heuristics, im_heuristics, fm_heuristics, "ru_heuristics.pnml") + pm4py.write_ptml(tree_inductive, "ru_inductive.ptml") + + petri_alpha, im_alpha, fm_alpha = pm4py.read_pnml("ru_alpha.pnml", auto_guess_final_marking=True) + petri_inductive, im_inductive, fm_inductive = pm4py.read_pnml("ru_inductive.pnml", auto_guess_final_marking=True) + petri_heuristics, im_heuristics, fm_heuristics = pm4py.read_pnml("ru_heuristics.pnml", auto_guess_final_marking=True) + tree_inductive = pm4py.read_ptml("ru_inductive.ptml") + + if ENABLE_VISUALIZATION: + if importlib.util.find_spec("graphviz"): + pm4py.view_petri_net(petri_alpha, im_alpha, fm_alpha, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_petri_net(petri_inductive, im_inductive, fm_inductive, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_petri_net(petri_heuristics, im_heuristics, fm_heuristics, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_process_tree(tree_inductive, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_dfg(dfg, dfg_sa, dfg_ea, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.save_vis_petri_net(petri_alpha, im_alpha, fm_alpha, "ru_alpha.png") + pm4py.save_vis_petri_net(petri_inductive, im_inductive, fm_inductive, "ru_inductive.png") + pm4py.save_vis_petri_net(petri_heuristics, im_heuristics, fm_heuristics, "ru_heuristics.png") + pm4py.save_vis_process_tree(tree_inductive, "ru_inductive_tree.png") + pm4py.save_vis_dfg(dfg, dfg_sa, dfg_ea, "ru_dfg.png") + pm4py.save_vis_dotted_chart(log1, "dotted_chart.png") + pm4py.save_vis_performance_spectrum(log1, ["register request", "decide"], "ps.png") + + if importlib.util.find_spec("pydotplus"): + pm4py.view_heuristics_net(heu_net, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.save_vis_heuristics_net(heu_net, "ru_heunet.png") + os.remove("ru_heunet.png") + + if importlib.util.find_spec("matplotlib"): + pm4py.save_vis_events_per_time_graph(log1, "ev_time.png") + pm4py.save_vis_case_duration_graph(log1, "cd.png") + os.remove("ev_time.png") + os.remove("cd.png") + + os.remove("ru_alpha.png") + os.remove("ru_inductive.png") + os.remove("ru_inductive_tree.png") + os.remove("ru_dfg.png") + os.remove("ru_heuristics.png") + os.remove("dotted_chart.png") + os.remove("ps.png") + + aligned_traces = pm4py.conformance_diagnostics_alignments(log1, petri_inductive, im_inductive, fm_inductive, return_diagnostics_dataframe=False) + replayed_traces = pm4py.conformance_diagnostics_token_based_replay(log1, petri_inductive, im_inductive, fm_inductive, return_diagnostics_dataframe=False) + + fitness_tbr = pm4py.fitness_token_based_replay(log1, petri_inductive, im_inductive, fm_inductive) + print("fitness_tbr", fitness_tbr) + fitness_align = pm4py.fitness_alignments(log1, petri_inductive, im_inductive, fm_inductive) + print("fitness_align", fitness_align) + precision_tbr = pm4py.precision_token_based_replay(log1, petri_inductive, im_inductive, fm_inductive) + print("precision_tbr", precision_tbr) + precision_align = pm4py.precision_alignments(log1, petri_inductive, im_inductive, fm_inductive) + print("precision_align", precision_align) + + print("log start activities = ", pm4py.get_start_activities(log2)) + print("df start activities = ", pm4py.get_start_activities(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) + print("log end activities = ", pm4py.get_end_activities(log2)) + print("df end activities = ", pm4py.get_end_activities(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) + print("log attributes = ", pm4py.get_event_attributes(log2)) + print("df attributes = ", pm4py.get_event_attributes(df2)) + print("log org:resource values = ", pm4py.get_event_attribute_values(log2, "org:resource")) + print("df org:resource values = ", pm4py.get_event_attribute_values(df2, "org:resource", case_id_key="case:concept:name")) + + print("start_activities len(filt_log) = ", len(pm4py.filter_start_activities(log2, ["register request"]))) + print("start_activities len(filt_df) = ", len(pm4py.filter_start_activities(df2, ["register request"], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) + print("end_activities len(filt_log) = ", len(pm4py.filter_end_activities(log2, ["pay compensation"]))) + print("end_activities len(filt_df) = ", len(pm4py.filter_end_activities(df2, ["pay compensation"], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) + print("attributes org:resource len(filt_log) (cases) cases = ", + len(pm4py.filter_event_attribute_values(log2, "org:resource", ["Ellen"], level="case"))) + print("attributes org:resource len(filt_log) (cases) events = ", + len(pm4py.filter_event_attribute_values(log2, "org:resource", ["Ellen"], level="event"))) + print("attributes org:resource len(filt_df) (events) cases = ", + len(pm4py.filter_event_attribute_values(df2, "org:resource", ["Ellen"], level="case", case_id_key="case:concept:name"))) + print("attributes org:resource len(filt_df) (events) events = ", + len(pm4py.filter_event_attribute_values(df2, "org:resource", ["Ellen"], level="event", case_id_key="case:concept:name"))) + print("attributes org:resource len(filt_df) (events) events notpositive = ", + len(pm4py.filter_event_attribute_values(df2, "org:resource", ["Ellen"], level="event", retain=False))) + + print("rework df = ", pm4py.get_rework_cases_per_activity(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) + print("rework log = ", pm4py.get_rework_cases_per_activity(log2)) + print("cases overlap df = ", pm4py.get_case_overlap(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) + print("cases overlap log = ", pm4py.get_case_overlap(log2)) + print("cycle time df = ", pm4py.get_cycle_time(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) + print("cycle time log = ", pm4py.get_cycle_time(log2)) + + if ENABLE_VISUALIZATION: + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("matplotlib"): + pm4py.view_events_distribution_graph(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp", format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_events_distribution_graph(log2, format=examples_conf.TARGET_IMG_FORMAT) + + print("variants log = ", pm4py.get_variants_as_tuples(log2)) + print("variants df = ", pm4py.get_variants_as_tuples(df2, case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp")) + print("variants filter log = ", + len(pm4py.filter_variants(log2, [ + ("register request", "examine thoroughly", "check ticket", "decide", "reject request")]))) + print("variants filter df = ", + len(pm4py.filter_variants(df2, [ + ("register request", "examine thoroughly", "check ticket", "decide", "reject request")], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) + + print("paths filter log len = ", + len(pm4py.filter_directly_follows_relation(log2, [("register request", "examine casually")]))) + print("paths filter dataframe len = ", + len(pm4py.filter_directly_follows_relation(df2, [("register request", "examine casually")], case_id_key="case:concept:name", activity_key="concept:name", timestamp_key="time:timestamp"))) + + print("timeframe filter log events len = ", + len(pm4py.filter_time_range(log2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="events"))) + print("timeframe filter log traces_contained len = ", + len(pm4py.filter_time_range(log2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_contained", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) + print("timeframe filter log traces_intersecting len = ", + len(pm4py.filter_time_range(log2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_intersecting"))) + print("timeframe filter df events len = ", + len(pm4py.filter_time_range(df2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="events", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) + print("timeframe filter df traces_contained len = ", + len(pm4py.filter_time_range(df2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_contained", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) + print("timeframe filter df traces_intersecting len = ", + len(pm4py.filter_time_range(df2, "2011-01-01 00:00:00", "2011-02-01 00:00:00", mode="traces_intersecting", case_id_key="case:concept:name", timestamp_key="time:timestamp"))) + + wt_log = pm4py.discover_working_together_network(log2) + wt_df = pm4py.discover_working_together_network(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp") + print("log working together", wt_log) + print("df working together", wt_df) + print("log subcontracting", pm4py.discover_subcontracting_network(log2)) + print("df subcontracting", pm4py.discover_subcontracting_network(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp")) + print("log working together", pm4py.discover_working_together_network(log2)) + print("df working together", pm4py.discover_working_together_network(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp")) + print("log similar activities", pm4py.discover_activity_based_resource_similarity(log2)) + print("df similar activities", pm4py.discover_activity_based_resource_similarity(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp", activity_key="concept:name")) + print("log org roles", pm4py.discover_organizational_roles(log2)) + print("df org roles", pm4py.discover_organizational_roles(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp", activity_key="concept:name")) + + if ENABLE_VISUALIZATION: + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("pyvis") and importlib.util.find_spec("networkx"): + pm4py.view_sna(wt_log) + pm4py.save_vis_sna(wt_df, "ru_wt_df.png") + os.remove("ru_wt_df.png") + + footprints = pm4py.discover_footprints(log1) + alignments = pm4py.conformance_diagnostics_alignments(log1, petri_inductive, im_inductive, fm_inductive, return_diagnostics_dataframe=False) + + if ENABLE_VISUALIZATION: + if importlib.util.find_spec("graphviz"): + pm4py.view_footprints(footprints, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.view_alignments(log1, alignments, format=examples_conf.TARGET_IMG_FORMAT) + pm4py.save_vis_footprints(footprints, "footprints.png") + pm4py.save_vis_alignments(log1, aligned_traces, "alignments.png") + os.remove("footprints.png") + os.remove("alignments.png") + except: + traceback.print_exc() # remove the temporary files - os.remove("ru1.xes") - os.remove("ru_dfg.dfg") - os.remove("ru_alpha.pnml") - os.remove("ru_inductive.pnml") - os.remove("ru_heuristics.pnml") - os.remove("ru_inductive.ptml") - os.remove("ru_alpha.png") - os.remove("ru_inductive.png") - os.remove("ru_heuristics.png") - os.remove("ru_inductive_tree.png") - os.remove("ru_heunet.png") - os.remove("ru_dfg.png") - - os.remove("ev_time.png") - os.remove("cd.png") - os.remove("dotted_chart.png") - os.remove("ps.png") - - wt_log = pm4py.discover_working_together_network(log2) - wt_df = pm4py.discover_working_together_network(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp") - print("log working together", wt_log) - print("df working together", wt_df) - print("log subcontracting", pm4py.discover_subcontracting_network(log2)) - print("df subcontracting", pm4py.discover_subcontracting_network(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp")) - print("log working together", pm4py.discover_working_together_network(log2)) - print("df working together", pm4py.discover_working_together_network(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp")) - print("log similar activities", pm4py.discover_activity_based_resource_similarity(log2)) - print("df similar activities", pm4py.discover_activity_based_resource_similarity(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp", activity_key="concept:name")) - print("log org roles", pm4py.discover_organizational_roles(log2)) - print("df org roles", pm4py.discover_organizational_roles(df2, case_id_key="case:concept:name", resource_key="org:resource", timestamp_key="time:timestamp", activity_key="concept:name")) - pm4py.view_sna(wt_log) - - pm4py.save_vis_sna(wt_df, "ru_wt_df.png") - os.remove("ru_wt_df.png") - - footprints = pm4py.discover_footprints(log1) - alignments = pm4py.conformance_diagnostics_alignments(log1, petri_inductive, im_inductive, fm_inductive, return_diagnostics_dataframe=False) - - pm4py.view_footprints(footprints, format=examples_conf.TARGET_IMG_FORMAT) - pm4py.view_alignments(log1, alignments, format=examples_conf.TARGET_IMG_FORMAT) - - pm4py.save_vis_footprints(footprints, "footprints.png") - pm4py.save_vis_alignments(log1, aligned_traces, "alignments.png") - os.remove("footprints.png") - os.remove("alignments.png") + if os.path.exists("ru1.xes"): + os.remove("ru1.xes") + if os.path.exists("ru_dfg.dfg"): + os.remove("ru_dfg.dfg") + if os.path.exists("ru_alpha.pnml"): + os.remove("ru_alpha.pnml") + if os.path.exists("ru_inductive.pnml"): + os.remove("ru_inductive.pnml") + if os.path.exists("ru_heuristics.pnml"): + os.remove("ru_heuristics.pnml") + if os.path.exists("ru_inductive.ptml"): + os.remove("ru_inductive.ptml") if __name__ == "__main__": diff --git a/examples/sna_log.py b/examples/sna_log.py index 7840dc097..013a925d8 100644 --- a/examples/sna_log.py +++ b/examples/sna_log.py @@ -2,8 +2,8 @@ from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.algo.organizational_mining.sna import algorithm as sna_algorithm -from pm4py.visualization.sna import visualizer as pn_vis from examples import examples_conf +import importlib.util def execute_script(): @@ -14,17 +14,18 @@ def execute_script(): sub_values = sna_algorithm.apply(log, variant=sna_algorithm.Variants.SUBCONTRACTING_LOG) ja_values = sna_algorithm.apply(log, variant=sna_algorithm.Variants.JOINTACTIVITIES_LOG) - gviz_sub = pn_vis.apply(sub_values, variant=pn_vis.Variants.NETWORKX, - parameters={pn_vis.Variants.NETWORKX.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - gviz_hw = pn_vis.apply(hw_values, variant=pn_vis.Variants.PYVIS) - gviz_wt = pn_vis.apply(wt_values, variant=pn_vis.Variants.NETWORKX, - parameters={pn_vis.Variants.NETWORKX.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - gviz_ja = pn_vis.apply(ja_values, variant=pn_vis.Variants.PYVIS) - - pn_vis.view(gviz_sub, variant=pn_vis.Variants.NETWORKX) - pn_vis.view(gviz_hw, variant=pn_vis.Variants.PYVIS) - pn_vis.view(gviz_wt, variant=pn_vis.Variants.NETWORKX) - pn_vis.view(gviz_ja, variant=pn_vis.Variants.PYVIS) + if importlib.util.find_spec("graphviz") and importlib.util.find_spec("pyvis") and importlib.util.find_spec("networkx"): + from pm4py.visualization.sna import visualizer as pn_vis + gviz_sub = pn_vis.apply(sub_values, variant=pn_vis.Variants.NETWORKX, + parameters={pn_vis.Variants.NETWORKX.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + gviz_hw = pn_vis.apply(hw_values, variant=pn_vis.Variants.PYVIS) + gviz_wt = pn_vis.apply(wt_values, variant=pn_vis.Variants.NETWORKX, + parameters={pn_vis.Variants.NETWORKX.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + gviz_ja = pn_vis.apply(ja_values, variant=pn_vis.Variants.PYVIS) + pn_vis.view(gviz_sub, variant=pn_vis.Variants.NETWORKX) + pn_vis.view(gviz_hw, variant=pn_vis.Variants.PYVIS) + pn_vis.view(gviz_wt, variant=pn_vis.Variants.NETWORKX) + pn_vis.view(gviz_ja, variant=pn_vis.Variants.PYVIS) if __name__ == "__main__": diff --git a/examples/streaming_discovery_dfg.py b/examples/streaming_discovery_dfg.py index a15adfa45..9c5307d55 100644 --- a/examples/streaming_discovery_dfg.py +++ b/examples/streaming_discovery_dfg.py @@ -3,8 +3,8 @@ import pm4py from pm4py.streaming.algo.discovery.dfg import algorithm as dfg_discovery from pm4py.streaming.stream.live_event_stream import LiveEventStream -from pm4py.visualization.dfg import visualizer as dfg_visualizer from examples import examples_conf +import importlib.util def execute_script(): @@ -28,11 +28,14 @@ def execute_script(): live_stream.stop() # gets the DFG along with the start and end activities from the stream dfg, activities, start_activities, end_activities = stream_dfg_disc.get() - # visualize the DFG - gviz = dfg_visualizer.apply(dfg, variant=dfg_visualizer.Variants.FREQUENCY, activities_count=activities, - parameters={"format": examples_conf.TARGET_IMG_FORMAT, "start_activities": start_activities, - "end_activities": end_activities}) - dfg_visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + # visualize the DFG + from pm4py.visualization.dfg import visualizer as dfg_visualizer + gviz = dfg_visualizer.apply(dfg, variant=dfg_visualizer.Variants.FREQUENCY, activities_count=activities, + parameters={"format": examples_conf.TARGET_IMG_FORMAT, "start_activities": start_activities, + "end_activities": end_activities}) + dfg_visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/timestamp_interleavings.py b/examples/timestamp_interleavings.py index d2e22463a..15c9d8827 100644 --- a/examples/timestamp_interleavings.py +++ b/examples/timestamp_interleavings.py @@ -1,8 +1,8 @@ from pm4py.util import constants, pandas_utils from pm4py.algo.discovery.ocel.interleavings import algorithm as interleavings_miner -from pm4py.visualization.ocel.interleavings import visualizer as interleavings_visualizer from pm4py.objects.log.util import dataframe_utils from examples import examples_conf +import importlib.util import os @@ -18,12 +18,15 @@ def execute_script(): print(interleavings_dataframe[["@@source_activity", "@@target_activity", "@@direction"]].value_counts()) # print the performance of the interleavings print(interleavings_dataframe.groupby(["@@source_activity", "@@target_activity", "@@direction"])["@@timestamp_diff"].agg("mean")) - # visualizes the frequency of the interleavings - gviz_freq = interleavings_visualizer.apply(receipt_even, receipt_odd, interleavings_dataframe, parameters={"annotation": "frequency", "format": examples_conf.TARGET_IMG_FORMAT}) - interleavings_visualizer.view(gviz_freq) - # visualizes the performance of the interleavings - gviz_perf = interleavings_visualizer.apply(receipt_even, receipt_odd, interleavings_dataframe, parameters={"annotation": "performance", "aggregation_measure": "median", "format": examples_conf.TARGET_IMG_FORMAT}) - interleavings_visualizer.view(gviz_perf) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.ocel.interleavings import visualizer as interleavings_visualizer + # visualizes the frequency of the interleavings + gviz_freq = interleavings_visualizer.apply(receipt_even, receipt_odd, interleavings_dataframe, parameters={"annotation": "frequency", "format": examples_conf.TARGET_IMG_FORMAT}) + interleavings_visualizer.view(gviz_freq) + # visualizes the performance of the interleavings + gviz_perf = interleavings_visualizer.apply(receipt_even, receipt_odd, interleavings_dataframe, parameters={"annotation": "performance", "aggregation_measure": "median", "format": examples_conf.TARGET_IMG_FORMAT}) + interleavings_visualizer.view(gviz_perf) if __name__ == "__main__": diff --git a/examples/token_replay_alpha.py b/examples/token_replay_alpha.py index 949ccdb55..f7588534b 100644 --- a/examples/token_replay_alpha.py +++ b/examples/token_replay_alpha.py @@ -3,8 +3,8 @@ from pm4py.algo.conformance.tokenreplay import algorithm as token_replay from pm4py.algo.discovery.alpha import algorithm as alpha_miner from pm4py.objects.log.importer.xes import importer as xes_importer -from pm4py.visualization.petri_net import visualizer as pn_vis from examples import examples_conf +import importlib.util def execute_script(): @@ -15,9 +15,13 @@ def execute_script(): print("initial marking " + place.name) for place in final_marking: print("final marking " + place.name) - gviz = pn_vis.apply(net, marking, final_marking, - parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - pn_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_vis + gviz = pn_vis.apply(net, marking, final_marking, + parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + pn_vis.view(gviz) + print("started token replay") aligned_traces = token_replay.apply(log, net, marking, final_marking) fit_traces = [x for x in aligned_traces if x['trace_is_fit']] diff --git a/examples/token_replay_imdf.py b/examples/token_replay_imdf.py index a1781cf82..2d178b20e 100644 --- a/examples/token_replay_imdf.py +++ b/examples/token_replay_imdf.py @@ -3,9 +3,9 @@ from pm4py.algo.conformance.tokenreplay import algorithm as token_replay from pm4py.algo.discovery.inductive import algorithm as inductive_miner from pm4py.objects.log.importer.xes import importer as xes_importer -from pm4py.visualization.petri_net import visualizer as pn_vis from pm4py.objects.conversion.process_tree import converter as process_tree_converter from examples import examples_conf +import importlib.util def execute_script(): @@ -18,9 +18,13 @@ def execute_script(): print("initial marking " + place.name) for place in final_marking: print("final marking " + place.name) - gviz = pn_vis.apply(net, marking, final_marking, - parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - pn_vis.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.petri_net import visualizer as pn_vis + gviz = pn_vis.apply(net, marking, final_marking, + parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + pn_vis.view(gviz) + print("started token replay") aligned_traces = token_replay.apply(log, net, marking, final_marking) fit_traces = [x for x in aligned_traces if x['trace_is_fit']] diff --git a/examples/trace_clustering.py b/examples/trace_clustering.py index 2fce0712e..b6e143bb8 100644 --- a/examples/trace_clustering.py +++ b/examples/trace_clustering.py @@ -1,6 +1,7 @@ import pm4py import os from examples import examples_conf +import importlib.util def execute_script(): @@ -13,7 +14,9 @@ def execute_script(): for clust_log in pm4py.cluster_log(dataframe, sklearn_clusterer=clusterer): print(clust_log) process_tree = pm4py.discover_process_tree_inductive(clust_log) - pm4py.view_process_tree(process_tree, format=examples_conf.TARGET_IMG_FORMAT) + + if importlib.util.find_spec("graphviz"): + pm4py.view_process_tree(process_tree, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/trans_system_stochastic_vis.py b/examples/trans_system_stochastic_vis.py index 36a2e7c28..16520079a 100644 --- a/examples/trans_system_stochastic_vis.py +++ b/examples/trans_system_stochastic_vis.py @@ -1,16 +1,19 @@ import pm4py from pm4py.algo.discovery.transition_system import algorithm as transition_system_discovery -from pm4py.visualization.transition_system.variants import trans_frequency -from pm4py.visualization.transition_system import visualizer as transition_system_visualizer from examples import examples_conf import os +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "running-example.xes")) ts = transition_system_discovery.apply(log, parameters={"include_data": True, "direction": "forward"}) - gviz = trans_frequency.apply(ts, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - transition_system_visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.transition_system.variants import trans_frequency + from pm4py.visualization.transition_system import visualizer as transition_system_visualizer + gviz = trans_frequency.apply(ts, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + transition_system_visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/transition_system_test.py b/examples/transition_system_test.py index 96fe47ec8..9812a9f12 100644 --- a/examples/transition_system_test.py +++ b/examples/transition_system_test.py @@ -1,8 +1,8 @@ from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.algo.discovery.transition_system import algorithm as ts_discovery -from pm4py.visualization.transition_system import visualizer as ts_vis from examples import examples_conf import os +import importlib.util def execute_script(): @@ -10,8 +10,12 @@ def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_importer.apply(log_path) ts = ts_discovery.apply(log, parameters={"include_data": True}) - viz = ts_vis.apply(ts, parameters={ts_vis.Variants.VIEW_BASED.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - ts_vis.view(viz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.transition_system import visualizer as ts_vis + viz = ts_vis.apply(ts, parameters={ts_vis.Variants.VIEW_BASED.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + ts_vis.view(viz) + for state in ts.states: print(state.name, "ingoing=", len(state.data["ingoing_events"]), "outgoing=", len(state.data["outgoing_events"])) diff --git a/examples/tree_manual_generation.py b/examples/tree_manual_generation.py index 16a906546..61ba05423 100644 --- a/examples/tree_manual_generation.py +++ b/examples/tree_manual_generation.py @@ -1,7 +1,7 @@ import pm4py from pm4py.objects.process_tree.obj import ProcessTree, Operator from examples import examples_conf - +import importlib.util def execute_script(): @@ -29,7 +29,8 @@ def execute_script(): parallel.children.append(leaf_E) parallel.children.append(leaf_F) - pm4py.view_process_tree(root, format=examples_conf.TARGET_IMG_FORMAT) + if importlib.util.find_spec("graphviz"): + pm4py.view_process_tree(root, format=examples_conf.TARGET_IMG_FORMAT) # remove leaf_C from choice choice.children.remove(leaf_C) @@ -38,7 +39,8 @@ def execute_script(): parallel.children.remove( [parallel.children[i] for i in range(len(parallel.children)) if parallel.children[i].label == "E"][0]) - pm4py.view_process_tree(root, format=examples_conf.TARGET_IMG_FORMAT) + if importlib.util.find_spec("graphviz"): + pm4py.view_process_tree(root, format=examples_conf.TARGET_IMG_FORMAT) if __name__ == "__main__": diff --git a/examples/trie.py b/examples/trie.py index 2b6f9015e..041316d21 100644 --- a/examples/trie.py +++ b/examples/trie.py @@ -2,16 +2,18 @@ import pm4py from pm4py.algo.transformation import log_to_trie -from pm4py.visualization.trie import visualizer from examples import examples_conf - +import importlib.util def execute_script(): log = pm4py.read_xes(os.path.join("..", "tests", "input_data", "running-example.xes")) trie = log_to_trie.algorithm.apply(log) - gviz = visualizer.apply(trie, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.trie import visualizer + gviz = visualizer.apply(trie, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/validation_ocel20_relational.py b/examples/validation_ocel20_relational.py index ee772c9eb..6c12e38ee 100644 --- a/examples/validation_ocel20_relational.py +++ b/examples/validation_ocel20_relational.py @@ -4,10 +4,12 @@ def execute_script(): file_path = "../tests/input_data/ocel/ocel20_example.sqlite" - satisfied, unsatisfied = ocel20_rel_validation.apply(file_path) - - print("satisfied", satisfied) - print("unsatisfied", unsatisfied) + try: + satisfied, unsatisfied = ocel20_rel_validation.apply(file_path) + print("satisfied", satisfied) + print("unsatisfied", unsatisfied) + except: + print("Impossible to validate the OCEL!") if __name__ == "__main__": diff --git a/examples/validation_ocel20_xml.py b/examples/validation_ocel20_xml.py index 5f7cc3904..2384a417c 100644 --- a/examples/validation_ocel20_xml.py +++ b/examples/validation_ocel20_xml.py @@ -5,9 +5,11 @@ def execute_script(): file_path = "../tests/input_data/ocel/ocel20_example.xmlocel" validation_path = "../tests/input_data/ocel/ocel2-validation.xsd" - is_valid = xmlocel.apply(file_path, validation_path) - - print(is_valid) + try: + is_valid = xmlocel.apply(file_path, validation_path) + print(is_valid) + except: + print("Impossible to validate the OCEL!") if __name__ == "__main__": diff --git a/examples/visualization_align_table.py b/examples/visualization_align_table.py index 4bc1de55e..fc284d75b 100644 --- a/examples/visualization_align_table.py +++ b/examples/visualization_align_table.py @@ -2,9 +2,9 @@ from pm4py.objects.log.importer.xes import importer from pm4py.algo.discovery.inductive import algorithm as inductive_miner from pm4py.algo.conformance.alignments.petri_net import algorithm as alignments -from pm4py.visualization.align_table import visualizer from pm4py.objects.conversion.process_tree import converter as process_tree_converter from examples import examples_conf +import importlib.util def execute_script(): @@ -12,9 +12,12 @@ def execute_script(): process_tree = inductive_miner.apply(log) net, im, fm = process_tree_converter.apply(process_tree) aligned_traces = alignments.apply(log, net, im, fm) - gviz = visualizer.apply(log, aligned_traces, - parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - visualizer.view(gviz) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.align_table import visualizer + gviz = visualizer.apply(log, aligned_traces, + parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + visualizer.view(gviz) if __name__ == "__main__": diff --git a/examples/visualization_processtree.py b/examples/visualization_processtree.py index 571780002..cdb918b5e 100644 --- a/examples/visualization_processtree.py +++ b/examples/visualization_processtree.py @@ -1,18 +1,22 @@ from pm4py.objects.log.importer.xes import importer from pm4py.algo.discovery.inductive import algorithm as inductive_miner -from pm4py.visualization.process_tree import visualizer as pt_vis_factory -from pm4py.visualization.process_tree import visualizer as pt_visualizer from examples import examples_conf import os +import importlib.util def execute_script(): log = importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes")) tree = inductive_miner.apply(log) - gviz1 = pt_vis_factory.apply(tree, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) - # pt_vis_factory.view(gviz1) - gviz2 = pt_visualizer.apply(tree, parameters={pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) - pt_visualizer.view(gviz2) + + if importlib.util.find_spec("graphviz"): + from pm4py.visualization.process_tree import visualizer as pt_vis_factory + from pm4py.visualization.process_tree import visualizer as pt_visualizer + + gviz1 = pt_vis_factory.apply(tree, parameters={"format": examples_conf.TARGET_IMG_FORMAT}) + # pt_vis_factory.view(gviz1) + gviz2 = pt_visualizer.apply(tree, parameters={pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: examples_conf.TARGET_IMG_FORMAT}) + pt_visualizer.view(gviz2) if __name__ == "__main__": diff --git a/pm4py/meta.py b/pm4py/meta.py index df0c448bc..4d3f829e6 100644 --- a/pm4py/meta.py +++ b/pm4py/meta.py @@ -16,7 +16,7 @@ ''' __name__ = 'pm4py' -VERSION = '2.7.11.6' +VERSION = '2.7.11.7' __version__ = VERSION __doc__ = 'Process mining for Python' __author__ = 'Fraunhofer Institute for Applied Information Technology FIT' diff --git a/third_party/generate_dependencies.py b/third_party/generate_dependencies.py index 9a8c7141a..730ae5148 100644 --- a/third_party/generate_dependencies.py +++ b/third_party/generate_dependencies.py @@ -2,6 +2,7 @@ import networkx as nx import time import requests +import importlib.util REMOVE_DEPS_AT_END = True @@ -107,7 +108,12 @@ def get_all_third_party_dependencies(package_name, deps, packages_dictio): if UPDATE_OTHER_FILES: F = open("../requirements_complete.txt", "w") for x in packages: - F.write("%s\n" % (x[0])) + if x[0] == "numpy": + F.write("%s<2\n" % (x[0])) + elif x[0] == "pandas": + F.write("%s<3\n" % (x[0])) + else: + F.write("%s\n" % (x[0])) F.close() F = open("../requirements_stable.txt", "w") for x in packages: @@ -127,7 +133,8 @@ def get_all_third_party_dependencies(package_name, deps, packages_dictio): F.write("| %s | %s | %s | %s |\n" % (x[0].strip(), x[1].strip(), x[3].strip(), x[2].strip())) F.close() -deps, packages = get_all_third_party_dependencies("scikit-learn", deps, packages_dictio) +if importlib.util.find_spec("sklearn"): + deps, packages = get_all_third_party_dependencies("scikit-learn", deps, packages_dictio) first_line_packages = ["deprecation", "packaging", "networkx", "graphviz", "six", "python-dateutil", "pytz", "tzdata", "intervaltree", "sortedcontainers"] second_line_packages = ["pydotplus", "pyparsing", "tqdm", "colorama", "cycler", "joblib", "threadpoolctl"]