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_event_stream(
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)
log = log_conv_fact.apply(event_log)
log = sorting.sort_timestamp(log)
log = sampling.sample(log)
log = index_attribute.insert_trace_index_as_event_attribute(log)
event_log_transformed = log_conv_fact.apply(
log, variant=log_conv_fact.TO_EVENT_STREAM)
csv_exporter.export(
event_log_transformed,
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
event_log_imported_after_export = csv_importer.import_event_stream(
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
log_imported_after_export = log_conv_fact.apply(
event_log_imported_after_export)
self.assertEqual(len(log), len(log_imported_after_export))
os.remove(os.path.join(OUTPUT_DATA_DIR,
"running-example-exported.csv"))
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_event_stream(
os.path.join("input_data", "running-example.csv"))
event_log_length = len(event_log)
del event_log_length
from pm4py.objects.log import transform
log = transform.transform_event_stream_to_event_log(
event_log, case_glue="case:concept:name")
del log
from pm4py.objects.log.importer.csv.versions import pandas_df_imp
dataframe = pandas_df_imp.import_dataframe_from_path(
os.path.join("input_data", "running-example.csv"))
event_log = log_conv_fact.apply(dataframe,
variant=log_conv_fact.TO_EVENT_STREAM)
log = log_conv_fact.apply(event_log)
from pm4py.objects.log.exporter.csv import factory as csv_exporter
csv_exporter.export(event_log, "outputFile1.csv")
os.remove("outputFile1.csv")
from pm4py.objects.log.exporter.csv import factory as csv_exporter
csv_exporter.export(log, "outputFile2.csv")
os.remove("outputFile2.csv")
def convert(self, filePath):
"""
function that converts csv files into event logs
:param filePath: the path to the file
:return: event log
"""
csvEventStream = csv_importer.import_event_stream(filePath)
return conversion_factory.apply(csvEventStream)
def import_log_csv(path):
return conversion_factory.apply(
import_event_stream(
path), # https://pm4py.fit.fraunhofer.de/documentation/1.2
parameters={
constants.PARAMETER_CONSTANT_CASEID_KEY:
"case:concept:name", # this tells the importer
constants.PARAMETER_CONSTANT_ACTIVITY_KEY:
"concept:name", # how to parse the csv
constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: "time:timestamp"
} # and which are the caseID
) # concept name and timestamp
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"
log = xes_importer.import_log(os.path.join(INPUT_DATA_DIR, "running-example.xes"))
event_log = log_conv_fact.apply(log, variant=log_conv_fact.TO_EVENT_STREAM)
csv_exporter.export(event_log, os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
event_log_newimport = csv_importer.import_event_stream(
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
log_imported_after_export = log_conv_fact.apply(event_log_newimport)
self.assertEqual(len(log), len(log_imported_after_export))
os.remove(os.path.join(OUTPUT_DATA_DIR, "running-example-exported.csv"))
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:
log = xes_importer.import_log(log_name)
else:
event_log = csv_importer.import_event_stream(log_name)
log = log_conv_fact.apply(event_log)
net, marking, final_marking = inductive_miner.apply(log)
soundness = check_soundness.check_petri_wfnet_and_soundness(net)
del soundness
return log, net, marking, final_marking
def import_csv(file):
'''
import csv and it adds classifiers
input file path
output log object
'''
try:
event_stream = csv_importer.import_event_stream(file)
log = conversion_factory.apply(event_stream)
log = add_classifier(log)
# handling the exceptions occuring during the import and converting
except Exception as e:
print("Error occur, please check the csv file", e)
return None
return log
def import_csv_file(filename):
filename = os.path.basename(filename)
file_path = global_util.get_full_path_input_file(filename)
event_stream = csv_importer.import_event_stream(file_path)
# dataframe = csv_import_adapter.import_dataframe_from_path(file_path, sep=",")
log = conversion_factory.apply(
event_stream,
parameters={constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: "日期和时间"})
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = visualizer.apply(net, initial_marking, final_marking)
visualizer.view(gviz)
def test_importExportCSVtoXES(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_event_stream(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)
log = log_transform.transform_event_stream_to_event_log(event_log)
log = sorting.sort_timestamp(log)
log = sampling.sample(log)
log = index_attribute.insert_trace_index_as_event_attribute(log)
xes_exporter.export_log(log, os.path.join(OUTPUT_DATA_DIR, "running-example-exported.xes"))
log_imported_after_export = xes_importer.import_log(
os.path.join(OUTPUT_DATA_DIR, "running-example-exported.xes"))
self.assertEqual(len(log), len(log_imported_after_export))
os.remove(os.path.join(OUTPUT_DATA_DIR, "running-example-exported.xes"))
def import_csv_file(filename):
filename = os.path.basename(filename)
# 修改日志文件路径
file_path = global_util.get_full_path_input_file(filename)
# 将文件按 csv 文件格式导入，得到事件流结构
event_stream = csv_importer.import_event_stream(file_path)
# dataframe = csv_import_adapter.import_dataframe_from_path(file_path, sep=",")
# 将事件流转换成 xes 结构
log = conversion_factory.apply(event_stream, parameters={constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: "日期和时间"})
# 矿工应用日志文件，这里简单的应用阿尔法矿工
net, initial_marking, final_marking = alpha_miner.apply(log)
# 可视化界面应用分析结果
gviz = visualizer.apply(net, initial_marking, final_marking)
# 显示结果
visualizer.view(gviz)
def obtainPetriNetThroughImdf(self,
log_name,
variant=inductive_miner.DEFAULT_VARIANT):
# 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:
log = xes_importer.import_log(log_name)
else:
event_log = csv_importer.import_event_stream(log_name)
log = log_conv_fact.apply(event_log)
# apply dummily the test to all the available variants
net, marking, final_marking = inductive_miner.apply(
log, variant=inductive_miner.DFG_BASED_OLD_VERSION)
net, marking, final_marking = inductive_miner.apply(
log, variant=inductive_miner.DFG_BASED)
net, marking, final_marking = inductive_miner.apply(log,
variant=variant)
soundness = check_soundness.check_petri_wfnet_and_soundness(net)
del soundness
return log, net, marking, final_marking
col_event_concept_name = pd_file.columns.get_loc('_event_concept_name_')
pd_file.columns.values[col_event_concept_name]= 'concept:name'
except:
print('Did not find _case_concept_name_')
try:
col_time_timestamp = pd_file.columns.get_loc('_event_time_timestamp_')
pd_file.columns.values[col_time_timestamp]= 'time:timestamp'
except:
print('Did not find _event_time_stamp_')
pd_file.to_csv(path + file, encoding = 'utf-8', index = False)
event_stream = csv_importer.import_event_stream(path = path + file)
log = conversion_factory.apply(event_stream)
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, initial_marking, final_marking = alpha_miner.apply(log)
from pm4py.objects.log.importer.xes import factory as xes_import_factory
xes_path = 'C:/Users/vince_000/Documents/BPI Challenge 2019/INV after GR - with SRM/01_01_01_Service/'
xes_file = '01_01_01_Invoice_after_GR_with_SRM_Service.xes'
#Topic:
#-----------------------------
#libraries
from pm4py.algo.discovery.alpha import factory as alpha_miner
from pm4py.objects.log.importer.xes import factory as importer
from pm4py.visualization.petrinet import factory as visualizer
from pm4py.objects.log.importer.csv import factory as csv_importer
event_stream = csv_importer.import_event_stream(
os.path.join("pmdata/", "running-example.csv"))
event_stream
event_stream_length = len(event_stream)
print(event_stream_length)
for event in event_stream:
print(event)
from pm4py.objects.conversion.log import factory as conversion_factory
log = conversion_factory.apply(event_stream)
from pm4py.objects.log.exporter.csv import factory as csv_exporter
csv_exporter.export(event_stream, "data/outputFile1.csv")
#log = importer.apply('pmdata/running-example.xes')
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = visualizer.apply(net, initial_marking, final_marking)
visualizer.view(gviz)
def read_as_log_csv(filepath):
event_stream = csv_importer.import_event_stream(filepath)
return conversion_factory.apply(event_stream)
21 blur-focus 0.048315
12 scroll-click-0 0.045465
16 focus-blur 0.044872
11 scroll-selection 0.039763
14 focus-scroll 0.039740
6 load-click-0 0.039533
2 load-scroll 0.034766
5 load-selection 0.033676
20 blur-scroll 0.033074
26 selection-scroll 0.032246
31 click-0-load 0.029780
'''
#-----------------
from pm4py.objects.log.importer.csv import factory as csv_importer
excellentLog1A = csv_importer.import_event_stream('Excellent1A_fixed.csv')
from pm4py.objects.conversion.log import factory as conversion_factory
log1 = conversion_factory.apply(excellentLog1A)
from pm4py.visualization.dfg import factory as dfg_vis_factory
gviz = dfg_vis_factory.apply(dfg1, log=log1, variant="frequency")
dfg_vis_factory.view(gviz)
from pm4py.objects.conversion.dfg import factory as dfg_mining_factory
net, im, fm = dfg_mining_factory.apply(dfg1)
from pm4py.visualization.petrinet import factory as pn_vis_factory
gviz = pn_vis_factory.apply(net, im, fm)
def import_data(directory,
file_name,
separator=";",
quote=None,
case_id="concept:name",
activity="activity",
time_stamp="time:timestamp",
target="label",
num_cases=None):
"""
Loads data from a file and returns an XLog/pm4py log object.
Expects xes file with standard attributes and the target variable named "event: Label".
Expects csv file with attributes "case_id", "activity", "timestamp" and "label".
:param directory: name of path [str].
:param file_name: name of file [str].
:param separator: separator for csv file [char].
:param quote: boolean flag [bool].
:param case_id: identifier for cases [str].
:param activity: identifier for activities [str].
:param time_stamp: identifier for time stamps [str].
:param target: identifier for target [str].
:param num_cases: boolean flag [bool].
:return: event log [EventLog].
"""
extension = os.path.splitext(file_name)[1]
print(os.getcwd())
if extension == '.csv':
data_dir = os.path.join(directory, file_name)
# Specify column names
CASEID_GLUE = case_id
ACTIVITY_KEY = activity
TIMEST_KEY = time_stamp
parameters = {
constants.PARAMETER_CONSTANT_CASEID_KEY: CASEID_GLUE,
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: ACTIVITY_KEY,
constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: TIMEST_KEY,
'sep': separator,
'quotechar': quote,
'timest_columns': TIMEST_KEY
}
# Load pm4py event stream
event_stream = csv_importer.import_event_stream(data_dir,
parameters=parameters)
# Transform event stream to log object
log = conversion_factory.apply(event_stream, parameters=parameters)
# Sort log by time_stamp
log = sorting.sort_timestamp(log, timestamp_key=TIMEST_KEY)
# Rename to xes standard
for trace in log:
for event in trace:
event.__setitem__("caseid", event.__getitem__(case_id))
event.__setitem__("concept:name", event.__getitem__(activity))
event.__setitem__("time:timestamp",
event.__getitem__(time_stamp))
event.__setitem__("label", event.__getitem__(target))
elif extension == '.xes':
data_dir = os.path.join(directory, file_name)
log = xes_import_factory.apply(data_dir)
print(log)
for trace in log:
for event in trace:
trace.__setitem__("label", event.__getitem__(target))
else:
raise TypeError('File type not supported.')
# Filter out cases where label is not set (i.e. is nan); limits number of cases in event log if set
# util.apply(log)
if num_cases is not None:
log = log[:num_cases]
print("Event log loaded")
return log
import os
from pm4py.objects.log.importer.csv import factory as csv_importer
from pm4py.objects.conversion.log import factory as conversion_factory
from pm4py.algo.discovery.alpha import factory as alpha_miner
from pm4py.visualization.petrinet import factory as vis_factory
from tests.translucent_event_log_new.algo.discover_petrinet.alpha_revise import trans_alpha
event_stream = csv_importer.import_event_stream(
os.path.join("input_data", "sample.csv"))
log = conversion_factory.apply(event_stream)
net, im, fm = trans_alpha(log)
nett, imm, fmm = alpha_miner.apply(log)
gviz = vis_factory.apply(net, im, fm)
gvizz = vis_factory.apply(nett, imm, fmm)
vis_factory.view(gviz)
vis_factory.view(gvizz)
def convert(self, filePath):
csvEventStream = csv_importer.import_event_stream(filePath)
return conversion_factory.apply(csvEventStream)
print('Did not find _case_concept_name_')
try:
col_time_timestamp = pd_file.columns.get_loc('_event_time_timestamp_')
pd_file.columns.values[col_time_timestamp] = 'time:timestamp'
except:
print('Did not find _event_time_stamp_')
pd_file_filtered = pd_file.filter(
items=['case:concept:name', 'concept:name', 'time:timestamp'])
pd_file_filtered.to_csv(path + file + '_2', encoding='utf-8', index=False)
event_stream = csv_importer.import_event_stream(path=path + file + '_2',
parameters={
"sort": True,
"sort_field":
"time:timestamp"
})
log = conversion_factory.apply(event_stream,
parameters={"timestamp_sort": True})
####### Filter the event log
## Start activities
from pm4py.algo.filtering.log.start_activities import start_activities_filter
log_start = start_activities_filter.get_start_activities(log)
log = start_activities_filter.apply_auto_filter(
