def handle_EOF(self, matches: Stream):
"""
We add as matches all the PMs for which there was a risk to be invalidated later.
Now we finished the input stream so there is no more risk !
"""
for match in self.__root.matches_to_handle_at_EOF:
matches.add_item(PatternMatch(match.events))
node = self.__root.get_first_last_negative_node()
for match in node.waiting_for_time_out:
matches.add_item(PatternMatch(match.events))
def _propagate_partial_match(self, events: List[Event]):
"""
Receives an already verified list of events for new partial match and propagates it up the tree.
"""
new_partial_match = PatternMatch(events)
if self.__can_add_partial_match(new_partial_match):
self._add_partial_match(new_partial_match)
def generate_matches_recursive(pattern: Pattern,
events: dict,
is_seq: bool,
match: list,
min_event_timestamp: datetime,
max_event_timestamp: datetime,
matches: list,
binding: dict,
loop: int = 0):
pattern_length = len(pattern.positive_structure.args)
if loop == pattern_length:
if pattern.condition.eval(binding):
if not does_match_exist(matches, match):
matches.append(PatternMatch(deepcopy(match)))
else:
primitive_event = pattern.positive_structure.args[loop]
for event in events[primitive_event.eventType]:
min_timestamp = min(min_event_timestamp, event.date)
max_timestamp = max(max_event_timestamp, event.date)
binding[primitive_event.name] = event.event
if max_timestamp - min_timestamp <= pattern.window:
if not is_seq or len(
match) == 0 or match[-1].date <= event.date:
match.append(event)
generate_matches_recursive(pattern, events, is_seq, match,
min_timestamp, max_timestamp,
matches, binding, loop + 1)
del match[-1]
del binding[primitive_event.name]
def eval(self, events: Stream, matches: Stream):
event_types_listeners = {}
# register leaf listeners for event types.
for leaf in self.__tree.get_leaves():
event_type = leaf.get_event_type()
if event_type in event_types_listeners.keys():
event_types_listeners[event_type].append(leaf)
else:
event_types_listeners[event_type] = [leaf]
# Send events to listening leaves.
for event in events:
if event.event_type in event_types_listeners.keys():
for leaf in event_types_listeners[event.event_type]:
leaf.handle_event(event)
for match in self.__tree.get_matches():
matches.add_item(PatternMatch(match))
# Now that we finished the input stream, if there were some PMs risking to be invalidated by a negative event
# at the end of the pattern, we handle them now
if (type(self.__tree.get_root()) == PostProcessingNode or type(self.__tree.get_root()) == FirstChanceNode) \
and self.__tree.get_root().is_last:
self.__tree.handle_EOF(matches)
matches.close()
def _propagate_partial_match(self,
events: List[Event],
match_probability: float = None):
"""
Receives an already verified list of events for new partial match and propagates it up the tree.
For probabilistic streams, receives the pre-calculated probability of the potential pattern match.
"""
new_partial_match = PatternMatch(events, match_probability)
if self.__can_add_partial_match(new_partial_match):
self._add_partial_match(new_partial_match)
def eval(self, events: Stream, matches: Stream):
event_types_listeners = {}
# register leaf listeners for event types.
for leaf in self.__tree.get_leaves():
event_type = leaf.get_event_type()
if event_type in event_types_listeners.keys():
event_types_listeners[event_type].append(leaf)
else:
event_types_listeners[event_type] = [leaf]
# Send events to listening leaves.
for event in events:
if event.event_type in event_types_listeners.keys():
for leaf in event_types_listeners[event.event_type]:
leaf.handle_event(event)
for match in self.__tree.get_matches():
matches.add_item(PatternMatch(match))
matches.close()
def __init__(self):
self.dt = datetime(2020, 1, 1)
self.pm_list = []
for i in range(10):
self.pm_list.append(
PatternMatch([Event(i, "type", self.dt + timedelta(i * 10))]))
def __init__(self):
self.dt = datetime(2020, 1, 1)
self.pm1 = PatternMatch([Event(1, "type", self.dt)])
self.pm2 = PatternMatch([Event(5, "type", self.dt + timedelta(4))])
self.pm3 = PatternMatch([Event(17, "type", self.dt + timedelta(16))])
self.pm4 = PatternMatch([Event(33, "type", self.dt + timedelta(32))])