def gen_trace(trace, deviant):
startTime = datetime.datetime.now(datetime.timezone.utc)
currentTime = startTime
t = xes.Trace()
for i, event in enumerate(trace):
if (i == len(trace) - 1):
if deviant:
currentTime = startTime + datetime.timedelta(minutes=150)
else:
currentTime = startTime + datetime.timedelta(minutes=10)
e = xes.Event()
e.attributes = [
xes.Attribute(type="date",
key="time:timestamp",
value=currentTime.astimezone().isoformat()),
xes.Attribute(type="string",
key="concept:name",
value=event["concept:name"]),
xes.Attribute(type="string",
key="org:resource",
value=event["org:resource"]),
xes.Attribute(type="string",
key="lifecycle:transition",
value=event["lifecycle:transition"])
]
t.add_event(e)
return t
def create_xes_trace(trace_dict):
xes_trace = xes.Trace()
## Add trace metadata
trace_name = trace_dict["name"]
deviant = trace_dict["deviant"]
xes_trace.add_attribute(xes.Attribute(type="string", key="concept:name", value=trace_name))
xes_trace.add_attribute(xes.Attribute(type="int", key="Label", value=str(1) if deviant else str(0)))
## Add events
events = trace_dict["events"]
for event in events:
event_timestamp = event["timestamp"]
event_name = event["concept:name"]
event_resource = event["org:resource"]
event_lifecycle = event["lifecycle:transition"]
xes_event = xes.Event()
xes_event.attributes = [
xes.Attribute(type="date", key="time:timestamp", value=event_timestamp),
xes.Attribute(type="string", key="concept:name", value=event_name),
xes.Attribute(type="string", key="org:resource", value=event_resource),
xes.Attribute(type="string", key="lifecycle:transition", value=event_lifecycle)
]
xes_trace.add_event(xes_event)
return xes_trace
def __init__(self, vk, news_feed, ontology, event_log, community):
threading.Thread.__init__(self)
self.community = community
self.vk = vk
self.news_feed = news_feed
self.ontology = ontology
self.event_log = event_log
self.owner_id = "-" + str(self.community.g_id)
self.trace = xes.Trace()
def __init__(self, vk, news_feed, ontology, event_log, person):
threading.Thread.__init__(self)
self.vk = vk
self.news_feed = news_feed
self.event_log = event_log
self.ontology = ontology
self.person = person
self.owner_id = person.u_id
self.user_online = False
self.trace = xes.Trace()
def run(self):
print("start mining events for user %s" % self.person.u_id)
time_now = 0
post_idx = 0
posts = []
while True:
# Check user likes and reposts
if self.user_online and time_now % time_to_check_likes == 0:
liked_posts = self.vk.get_liked_posts(self.person)
for liked_post in liked_posts:
self.trace.add_event(self.event_log.event_post_liked(self.person.u_id, liked_post))
self.person.posts_liked.append(liked_post)
self.ontology.post_liked(self.person.u_id, liked_post)
# Check user status
if time_now % time_to_check_online == 0:
is_online = self.vk.is_user_online(self.person)
if not self.user_online and is_online:
print("user %s online" % self.person.u_id)
self.trace = xes.Trace()
self.trace.add_event(self.event_log.event_online(self.person.u_id))
self.user_online = True
elif self.user_online and not is_online:
print("user %s offline" % self.person.u_id)
self.trace.add_event(self.event_log.event_offline(self.person.u_id))
self.event_log.add_trace(self.trace)
self.user_online = False
time_now = 0
# Load user news feed
if self.user_online and time_now % time_to_update_user_news == 0:
time.sleep(10)
posts = self.news_feed.get_user_news(self.person)
post_idx = 0
# Check user see new post
if self.user_online and time_now % time_to_see_post == 0:
if post_idx < len(posts):
self.trace.add_event(self.event_log.event_post_seen(self.person.u_id, posts[post_idx]))
self.person.posts_seen.append(posts[post_idx])
self.ontology.post_viewed(self.person.u_id, posts[post_idx])
post_idx += 1
# Load or update news from person
if self.user_online and time_now % time_to_update_news == 0:
self.load_news_feed()
# time tick
time_now += time_tick
time.sleep(time_tick)
def main():
for arg in sys.argv:
print(arg)
if len(sys.argv) < 6:
print("Incorrect number of arguments: " + str(len(sys.argv)))
usage()
return 0
try:
inputPath = sys.argv[1]
resourceLabel = sys.argv[2].split("=")[1].strip()
activityLabel = sys.argv[3].split("=")[1].strip()
traceLabel = sys.argv[4].split("=")[1].strip()
outputPath = sys.argv[5]
#print(resourceLabel,inputPath,activityLabel,traceLabel,outputPath)
open(inputPath, "r").close()
traces = BuildTraces(inputPath, resourceLabel, activityLabel,
traceLabel)
log = xes.Log()
#add the trace to the xes log, just like in the xes developer's github example
for traceId in traces.keys():
t = xes.Trace()
t.attributes = [
xes.Attribute(type="string", key="concept:name", value=traceId)
]
#add the events to the trace
for event in traces[traceId]:
e = xes.Event()
e.attributes = [
xes.Attribute(type="string",
key="concept:name",
value=event[1]),
xes.Attribute(type="string",
key="Activity",
value=event[1]),
xes.Attribute(type="string",
key="org:resource",
value=event[0]),
xes.Attribute(type="string", key="Actor", value=event[0])
]
t.add_event(e)
#add the trace
log.add_trace(t)
log.classifiers = [
xes.Classifier(name="org:resource", keys="org:resource"),
xes.Classifier(name="concept:name", keys="concept:name")
]
#write the log
open(outputPath, "w+").write(str(log))
except IOError:
print("Input file not found: " + sys.argv[1])
def generate_XES(events=None, log_path='log.xes'):
# Borrow from the XES example at https://github.com/maxsumrall/xes
log = xes.Log()
global action_log
if events is None:
events = copy(action_log)
def makeEvent(logged_event):
event = xes.Event()
event.attributes = [
xes.Attribute(type="string",
key="concept:name",
value=logged_event[1]),
xes.Attribute(type="string",
key="org:resource",
value=logged_event[0])
]
if len(logged_event) == 4:
event.attributes.append(
xes.Attribute(type="string",
key="concept:required_privileges_for_action",
value=logged_event[2]))
event.attributes.append(
xes.Attribute(type="string",
key="concept:actor_class",
value=logged_event[3]))
return event
for ev_index in range(len(events)):
event_set = events[ev_index]
trace = xes.Trace()
trace.add_attribute(
xes.Attribute(type="int", key="trace_id", value=str(ev_index + 1)))
[
trace.add_event(makeEvent(logged_event))
for logged_event in event_set
]
log.add_trace(trace)
log.classifiers = [
xes.Classifier(name="org:resource", keys="org:resource"),
xes.Classifier(name="concept:name", keys="concept:name")
]
with open(log_path, 'w') as log_file:
log_file.write(str(log))
def BuildXesLog(traces):
log = xes.Log()
i = 0
for trace in traces:
#the name of the trace is just the trace number
traceName = str(trace[0])
#add the anomaly status of the trace; this likely won't be used by any ProM or process-discovery tools, but is worth preserving
isAnomalous = str(trace[1])
#build the trace info
t = xes.Trace()
traceNameAttr = xes.Attribute(type="string",
key="concept:name",
value=traceName)
traceIsAnomalousAttr = xes.Attribute(type="string",
key="concept:isAnomalous",
value=isAnomalous)
#store both the trace name and the anomaly-status in the trace attributes
t.attributes = [traceNameAttr, traceIsAnomalousAttr]
#add the events to the trace; the event sequence is just an ordered sequence of characters with no other info
for eventName in trace[2]:
e = xes.Event()
e.attributes = [
xes.Attribute(type="string",
key="concept:name",
value=eventName),
xes.Attribute(type="string", key="Activity", value=eventName)
#xes.Attribute(type="string", key="Activity", value=eventName)
]
t.add_event(e)
#add the trace
log.add_trace(t)
#print("here: "+str(i)+" of "+str(len(traces)))
i += 1
#add the classifiers
log.classifiers = [
#xes.Classifier(name="org:resource",keys="org:resource"),
#xes.Classifier(name="concept:name",keys="concept:name")
#xes.Classifier(name="concept:traceName",keys="concept:traceName"),
#xes.Classifier(name="concept:isAnomalous",keys="concept:isAnomalous")
xes.Classifier(name="Activity", keys="Activity"),
xes.Classifier(name="concept:name", keys="concept:name")
]
return log
def run(self):
print("start mining events for community %s" % self.community.g_id)
time_now = 0
post_idx = 0
posts = []
posts_seen = {}
while True:
# Load or update news from community
if time_now % time_to_update_news == 0:
self.load_news_feed()
# Update group event trace
if time_now % time_to_update_group_trace == 0:
self.event_log.add_trace(self.trace)
self.trace = xes.Trace()
time_now = 0
# time tick
time_now += time_tick
time.sleep(time_tick)
def WriteXes(traces, outputPath):
log = xes.Log()
#print("TRACES: "+str(traces))
#add the trace to the xes log, just like in the xes developer's github example
for trace in traces:
t = xes.Trace()
t.attributes = [
xes.Attribute(type="string", key="concept:name", value=trace[1])
]
#add the events to the trace
for event in trace[2]:
e = xes.Event()
e.attributes = [
xes.Attribute(type="string",
key="concept:name",
value=event["concept:name"]),
xes.Attribute(type="string",
key="Activity",
value=event["concept:name"]),
xes.Attribute(type="string",
key="org:resource",
value=event["org:resource"]),
xes.Attribute(type="string",
key="Actor",
value=event["org:resource"])
]
t.add_event(e)
#add the trace
log.add_trace(t)
log.classifiers = [
xes.Classifier(name="org:resource", keys="org:resource"),
xes.Classifier(name="concept:name", keys="concept:name")
]
#write the log
of = open(outputPath, "w+")
of.write(str(log))
of.close()
def gen_xes_log(events_lists, deviant):
traces = [[{
"concept:name": e,
"org:resource": "actor"
} for e in events_list] for events_list, _ in events_lists]
startTime = datetime.datetime.now()
log = xes.Log()
for trace in traces:
currentTime = startTime
t = xes.Trace()
for i, event in enumerate(trace):
if event["concept:name"] == deviant:
currentTime += datetime.timedelta(minutes=60)
else:
currentTime += datetime.timedelta(minutes=5)
e = xes.Event()
e.attributes = [
xes.Attribute(type="date",
key="time:timestamp",
value=currentTime.isoformat()),
xes.Attribute(type="string",
key="concept:name",
value=event["concept:name"]),
xes.Attribute(type="string",
key="org:resource",
value=event["org:resource"]),
xes.Attribute(type="string",
key="lifecycle:transition",
value=event["lifecycle:transition"])
]
t.add_event(e)
log.add_trace(t)
open("example.xes", "w").write(str(log))
