def test_csv1documentation(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
import os
from pm4py.objects.log.importer.csv import factory as csv_importer
event_log = csv_importer.import_log(
os.path.join("input_data", "running-example.csv"))
event_log_length = len(event_log)
del event_log_length
from pm4py.objects.log import transform
trace_log = transform.transform_event_log_to_trace_log(
event_log, case_glue="case:concept:name")
del trace_log
from pm4py.objects.log.importer.csv.versions import pandas_df_imp
from pm4py.objects.log import transform
dataframe = pandas_df_imp.import_dataframe_from_path(
os.path.join("input_data", "running-example.csv"))
event_log = pandas_df_imp.convert_dataframe_to_event_log(dataframe)
trace_log = transform.transform_event_log_to_trace_log(
event_log, case_glue="case:concept:name")
from pm4py.objects.log.exporter.csv import factory as csv_exporter
csv_exporter.export_log(event_log, "outputFile1.csv")
os.remove("outputFile1.csv")
from pm4py.objects.log.exporter.csv import factory as csv_exporter
csv_exporter.export_log(trace_log, "outputFile2.csv")
os.remove("outputFile2.csv")
def test_importExportCSVtoCSV(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
event_log = csv_importer.import_log(
os.path.join(INPUT_DATA_DIR, "running-example.csv"))
event_log = sorting.sort_timestamp(event_log)
event_log = sampling.sample(event_log)
event_log = index_attribute.insert_event_index_as_event_attribute(
event_log)
trace_log = log_transform.transform_event_log_to_trace_log(event_log)
trace_log = sorting.sort_timestamp(trace_log)
trace_log = sampling.sample(trace_log)
trace_log = index_attribute.insert_trace_index_as_event_attribute(
trace_log)
event_log_transformed = log_transform.transform_trace_log_to_event_log(
trace_log)
csv_exporter.export_log(
event_log_transformed,
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
event_log_imported_after_export = csv_importer.import_log(
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
trace_log_imported_after_export = log_transform.transform_event_log_to_trace_log(
event_log_imported_after_export)
self.assertEqual(len(trace_log), len(trace_log_imported_after_export))
os.remove(os.path.join(OUTPUT_DATA_DIR,
"running-example-exported.csv"))
def apply(object,
petri_net,
initial_marking,
final_marking,
parameters=None,
version=VERSION_STATE_EQUATION_A_STAR):
if isinstance(object, pm4py.objects.log.log.Trace):
return apply_trace(object, petri_net, initial_marking, final_marking,
parameters, version)
elif isinstance(object, pm4py.objects.log.log.TraceLog):
return apply_log(object, petri_net, initial_marking, final_marking,
parameters, version)
elif isinstance(object, pm4py.objects.log.log.EventLog):
if log_util.PARAMETER_KEY_CASE_GLUE in parameters:
glue = parameters[log_util.PARAMETER_KEY_CASE_GLUE]
else:
glue = log_util.CASE_ATTRIBUTE_GLUE
if log_util.PARAMETER_KEY_CASE_ATTRIBUTE_PRFIX in parameters:
case_pref = parameters[log_util.PARAMETER_KEY_CASE_ATTRIBUTE_PRFIX]
else:
case_pref = log_util.CASE_ATTRIBUTE_PREFIX
trace_log = log_transform.transform_event_log_to_trace_log(
object,
case_glue=glue,
includes_case_attributes=False,
case_attribute_prefix=case_pref)
return apply_log(object, petri_net, initial_marking, final_marking,
parameters, version)
def export_log_tree(log):
"""
Get XES log XML tree from a PM4Py trace log
Parameters
-----------
log
PM4Py trace log
Returns
-----------
tree
XML tree
"""
# If the log is in log_instance.EventLog, then transform it into log_instance.TraceLog format
if type(log) is log_instance.EventLog:
log = log_transform.transform_event_log_to_trace_log(log)
root = etree.Element(xes_util.TAG_LOG)
# add attributes at the log level
export_attributes(log, root)
# add extensions at the log level
export_extensions(log, root)
# add globals at the log level
export_globals(log, root)
# add classifiers at the log level
export_classifiers(log, root)
# add traces at the log level
export_traces(log, root)
tree = etree.ElementTree(root)
return tree
def obtainPetriNetThroughImdf(self, log_name):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
if ".xes" in log_name:
trace_log = xes_importer.import_log(log_name)
else:
event_log = csv_importer.import_log(log_name)
trace_log = log_transform.transform_event_log_to_trace_log(event_log)
net, marking, final_marking = inductive_miner.apply(trace_log, None)
return trace_log, net, marking, final_marking
def obtainPetriNetThroughAlphaMiner(self, log_name):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
if ".xes" in log_name:
trace_log = xes_importer.import_log(log_name)
else:
event_log = csv_importer.import_log(log_name)
trace_log = log_transform.transform_event_log_to_trace_log(
event_log)
net, marking, fmarking = alpha_factory.apply(trace_log)
soundness = check_soundness.check_petri_wfnet_and_soundness(net)
del soundness
return trace_log, net, marking, fmarking
def test_importExportXEStoCSV(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
trace_log = xes_importer.import_log(
os.path.join(INPUT_DATA_DIR, "running-example.xes"))
event_log = log_transform.transform_trace_log_to_event_log(trace_log)
csv_exporter.export_log(
event_log,
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
event_log_newimport = csv_importer.import_log(
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
trace_log_imported_after_export = log_transform.transform_event_log_to_trace_log(
event_log_newimport)
self.assertEqual(len(trace_log), len(trace_log_imported_after_export))
os.remove(os.path.join(OUTPUT_DATA_DIR,
"running-example-exported.csv"))
def test_prefiltering_dataframe(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
input_log = os.path.join(INPUT_DATA_DIR, "running-example.csv")
dataframe = csv_import_adapter.import_dataframe_from_path_wo_timeconversion(
input_log, sep=',')
dataframe = attributes_filter.filter_df_keeping_spno_activities(
dataframe, activity_key="concept:name")
dataframe = case_filter.filter_on_ncases(
dataframe, case_id_glue="case:concept:name")
dataframe = csv_import_adapter.convert_timestamp_columns_in_df(
dataframe)
dataframe = dataframe.sort_values('time:timestamp')
event_log = pandas_df_imp.convert_dataframe_to_event_log(dataframe)
trace_log = transform.transform_event_log_to_trace_log(event_log)
del trace_log
def apply_events(trace_log, dt1, dt2, parameters=None):
"""
Get a new trace log containing all the events contained in the given interval
Parameters
-----------
trace_log
Trace log
dt1
Lower bound to the interval
dt2
Upper bound to the interval
parameters
Possible parameters of the algorithm, including:
timestamp_key -> Attribute to use as timestamp
Returns
------------
filtered_log
Filtered trace log
"""
if parameters is None:
parameters = {}
timestamp_key = parameters[
PARAMETER_CONSTANT_TIMESTAMP_KEY] if PARAMETER_CONSTANT_TIMESTAMP_KEY in parameters else DEFAULT_TIMESTAMP_KEY
dt1 = get_dt_from_string(dt1)
dt2 = get_dt_from_string(dt2)
event_log = transform.transform_trace_log_to_event_log(trace_log)
filtered_event_log = EventLog([
x for x in event_log
if dt1 < x[timestamp_key].replace(tzinfo=None) < dt2
])
filtered_trace_log = transform.transform_event_log_to_trace_log(
filtered_event_log)
return filtered_trace_log
from pm4py.visualization.petrinet import factory as pn_vis_factory
import os
rename = {
"ActivityName": "concept:name",
"TimeStamp": "time:timestamp",
"Event_type": "lifecycle:transition",
"ProcessInstanceId": "case:concept:name",
}
event_log = json_importer.import_log(os.path.join("form_json.json"),
parameters={"rename_map": rename})
event_log.sort()
trace_log = log_transform.transform_event_log_to_trace_log(event_log)
trace_log.sort()
trace_log.insert_trace_index_as_event_attribute()
net, marking, final_marking = alpha_factory.apply(trace_log)
for place in marking:
print("initial marking " + place.name)
for place in final_marking:
print("final marking " + place.name)
gviz = pn_vis_factory.apply(net,
marking,
final_marking,
parameters={"format": "svg"})
pn_vis_factory.view(gviz)
#xes_exporter.export_log(trace_log, "form_json.xes")
def apply(df, parameters=None):
"""
Returns a Pandas dataframe from which a sound workflow net could be extracted taking into account
a discovery algorithm returning models only with visible transitions
Parameters
------------
df
Pandas dataframe
parameters
Possible parameters of the algorithm, including:
max_no_variants -> Maximum number of variants to consider to return a Petri net
Returns
------------
filtered_df
Filtered dataframe
"""
if parameters is None:
parameters = {}
if PARAMETER_CONSTANT_CASEID_KEY not in parameters:
parameters[PARAMETER_CONSTANT_CASEID_KEY] = CASE_CONCEPT_NAME
if PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters:
parameters[PARAMETER_CONSTANT_ACTIVITY_KEY] = DEFAULT_NAME_KEY
if PARAMETER_CONSTANT_TIMESTAMP_KEY not in parameters:
parameters[PARAMETER_CONSTANT_TIMESTAMP_KEY] = DEFAULT_TIMESTAMP_KEY
if PARAMETER_CONSTANT_ATTRIBUTE_KEY not in parameters:
parameters[PARAMETER_CONSTANT_ATTRIBUTE_KEY] = parameters[
PARAMETER_CONSTANT_ACTIVITY_KEY]
caseid_glue = parameters[PARAMETER_CONSTANT_CASEID_KEY]
activity_key = parameters[PARAMETER_CONSTANT_ACTIVITY_KEY]
timest_key = parameters[PARAMETER_CONSTANT_TIMESTAMP_KEY]
max_no_variants = parameters[
"max_no_variants"] if "max_no_variants" in parameters else 20
variants_df = case_statistics.get_variants_df(df, parameters=parameters)
parameters["variants_df"] = variants_df
variant_stats = case_statistics.get_variant_statistics(
df, parameters=parameters)
all_variants_list = []
for var in variant_stats:
all_variants_list.append([var["variant"], var[caseid_glue]])
all_variants_list = sorted(all_variants_list,
key=lambda x: (x[1], x[0]),
reverse=True)
considered_variants = []
considered_traces = []
i = 0
while i < min(len(all_variants_list), max_no_variants):
variant = all_variants_list[i][0]
considered_variants.append(variant)
filtered_df = variants_filter.apply(df,
considered_variants,
parameters=parameters)
dfg_frequency = dfg_util.get_dfg_graph(filtered_df,
measure="frequency",
perf_aggregation_key="median",
case_id_glue=caseid_glue,
activity_key=activity_key,
timestamp_key=timest_key)
net, initial_marking, final_marking = alpha_miner.apply_dfg(
dfg_frequency, parameters=parameters)
is_sound = check_soundness.check_petri_wfnet_and_soundness(net)
if not is_sound:
del considered_variants[-1]
else:
traces_of_this_variant = variants_filter.apply(
df, [variant], parameters=parameters).groupby(caseid_glue)
traces_of_this_variant_keys = list(
traces_of_this_variant.groups.keys())
trace_of_this_variant = traces_of_this_variant.get_group(
traces_of_this_variant_keys[0])
this_trace = transform.transform_event_log_to_trace_log(
pandas_df_imp.convert_dataframe_to_event_log(
trace_of_this_variant),
case_glue=caseid_glue)[0]
if not activity_key == DEFAULT_NAME_KEY:
for j in range(len(this_trace)):
this_trace[j][DEFAULT_NAME_KEY] = this_trace[j][
activity_key]
considered_traces.append(this_trace)
filtered_log = TraceLog(considered_traces)
try:
alignments = alignment_factory.apply(filtered_log, net,
initial_marking,
final_marking)
del alignments
fitness = replay_fitness_factory.apply(filtered_log,
net,
initial_marking,
final_marking,
parameters=parameters)
if fitness["log_fitness"] < 0.99999:
del considered_variants[-1]
del considered_traces[-1]
except TypeError:
del considered_variants[-1]
del considered_traces[-1]
i = i + 1
return variants_filter.apply(df,
considered_variants,
parameters=parameters)