def test_parallel_many_events(self):
event_group = EventGroupParallel([
EventGroupParallel([Event('a'), Event('b')]),
# Event('c'), Event('d'), Event('e'), Event('f'), Event('g'),
# Event('h'),
# Event('i'),
Event('j'),
Event('k'),
Event('l'),
Event('m'),
Event('n'),
EventGroupParallel([Event('o'), Event('p'),
Event('q')])
])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
'm', 'n'
], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-10, result)
self.assertCountEqual([x for x in 'abcdefghijklmn'], char_list)
def test_nw_with_wrapper_parallel_inside_7(self):
event_group = EventGroupParallel(
[EventGroupParallel(string_to_events('tp')),
Event('q')])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['q'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-2, result)
self.assertCountEqual([x for x in ['q']], char_list)
self.assertEqual(['q'], events_to_char_list(model_result))
def test_additional3(self):
event_group = EventGroup([
EventGroupParallel([Event('c'), Event('f')]),
EventGroupParallel([Event('a'), Event('b')]),
Event('c')
])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['b', 'c', 'd'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-4, result)
self.assertCountEqual([x for x in ['b', 'c']], char_list)
self.assertEqual(['b', 'c'], events_to_char_list(model_result))
def test_nw_with_wrapper_parallel_inside(self):
event_group = EventGroupParallel(
[Event('t'),
EventGroupParallel(string_to_events('spqacezxy'))])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['z', 'x', 'a', 'b', 'c', 'd', 'e', 'z', 't'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-7, result)
self.assertCountEqual([x for x in ['z', 'x', 'a', 'c', 'e', 't']],
char_list)
self.assertEqual(['z', 'x', 'a', 'c', 'e', 't'],
events_to_char_list(model_result))
def test_92(self):
gate = SeqGate()
gate.parse('and({a}{f}opt(and({b}{e}lop({c}))){d})')
all_length_6_routes = gate.get_all_n_length_routes(6)
expected = [
EventGroupMatcher(
EventGroup([
EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
]))
]
self.assertCountEqual(expected, all_length_6_routes)
def test_all_events_in_model(self):
# when your algorithm is smarter than you
event_group = EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['a', 'b', 'c', 'd', 'e', 'f'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-2, result)
self.assertCountEqual([x for x in ['a', 'b', 'c', 'e', 'f']],
char_list)
def test_6(self):
gate = SeqGate()
gate.parse('xor(and({c}and(and({c}{b}and({d}{f})){b}{e})){e}{e})')
self.assertEqual([
EventGroup(
[EventGroupParallel(string_to_events('abcdefghijklmn'))])
], gate.get_all_n_length_routes(7))
self.assertEqual([], gate.get_all_n_length_routes(6))
def test_7(self):
gate = SeqGate()
gate.parse('lop({c})')
self.assertEqual(None, gate.get_all_n_length_routes(6))
self.assertEqual([
EventGroupMatcher(
EventGroup([EventGroupParallel(string_to_events('ccc'))]))
], gate.get_all_n_length_routes(3))
def test_9(self):
gate = SeqGate()
gate.parse('and({c}and({a}lop({e}opt({d}))seq({c}{b})))')
all_length_5_routes = gate.get_all_n_length_routes(5)
expected = [
EventGroupMatcher(
EventGroup([
EventGroupParallel([
Event('c'),
EventGroupParallel([
Event('a'),
Event('e'),
EventGroup(string_to_events('cb'))
])
])
]))
]
self.assertCountEqual(expected, all_length_5_routes)
def test_8(self):
gate = SeqGate()
gate.parse(
'xor({f}{d}and({e}xor(lop(xor({f}{d}))lop({a}))))and({b}{a})')
all_length_3_routes = gate.get_all_n_length_routes(3)
self.assertCountEqual([
EventGroupMatcher(
EventGroup(
[Event('f'),
EventGroupParallel(string_to_events('ba'))])),
EventGroupMatcher(
EventGroup(
[Event('d'),
EventGroupParallel(string_to_events('ba'))])),
EventGroupMatcher(
EventGroup(
[Event('e'),
EventGroupParallel(string_to_events('ba'))]))
], all_length_3_routes)
def test_nw_with_wrapper_parallel(self):
event_group = EventGroupParallel(string_to_events('pqacezxys'))
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['z', 'x', 'k', 'l', 'm', 'n', 'o', 'z', 'x'], dict())
print(events_to_char_list(model_result))
self.assertEqual(-14, result)
self.assertCountEqual([x for x in ['z', 'x']],
events_to_char_list(model_result))
self.assertEqual(['z', 'x'], events_to_char_list(model_result))
def test_cache(self):
event_group = [
EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
]
event_group2 = [
EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
]
log = ['a', 'b', 'c', 'd', 'e', 'f']
log2 = ['a', 'b', 'c', 'd', 'e', 'f']
cache1 = get_cache_id(event_group, log)
cache2 = get_cache_id(event_group2, log2)
self.assertEqual(cache1, cache2)
def test_2(self):
gate = SeqGate()
gate.parse('{f}xor({d}and({b}lop({c})opt({a})))')
actual = gate.get_all_n_length_routes(5)
expected_1 = EventGroupMatcher(
EventGroup([
Event('f'),
EventGroupParallel(
[Event('b'),
EventGroup(string_to_events('ccc'))])
]))
expected_2 = EventGroupMatcher(
EventGroup([
Event('f'),
EventGroupParallel([
Event('b'),
EventGroup(string_to_events('cc')),
Event('a')
])
]))
expected = [expected_1, expected_2]
self.assertCountEqual(expected, actual)
def test_1(self):
gate = SeqGate()
gate.parse('and({a}{b}{c}{d}{e}{f}{g}{h}{i}{j}{k}{l}{m}{n})')
self.assertCountEqual([
EventGroupMatcher(
EventGroup(
[EventGroupParallel(string_to_events('abcdefghijklmn'))]))
],
gate.get_all_n_length_routes(
14, ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n')))
self.assertEqual(
None,
gate.get_all_n_length_routes(13,
('a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'i', 'j', 'k', 'l', 'm', 'n')))
def get_all_n_length_routes(self, n: int, process) -> []:
if n == 0:
return []
if self.model_max_length < n or n < self.model_min_length:
return None
min_lengths = self.get_children_min_length()
max_lengths = self.get_children_max_length()
global_list = []
for elem in self.elements:
local_list = []
if isinstance(elem, Event):
local_list.append(elem)
min_lengths.pop(0)
max_lengths.pop(0)
else:
lower_limit, upper_limit = self.get_goal_length_range(
n, global_list, min_lengths, max_lengths)
for i in range(lower_limit, upper_limit + 1):
try:
child_all_n_length_routes = elem.get_all_n_length_routes(
i, process)
except ValueError:
return None
if child_all_n_length_routes is not None:
local_list.append(child_all_n_length_routes)
if local_list:
global_list.append(local_list)
result = []
if global_list:
for elem in flatten_values(global_list):
if self.check_length(n, elem):
if n == 1:
# because always 1 elem list
result.append(elem[0])
else:
self.check_valid_for_get_n_length(elem)
result.append(EventGroupParallel(elem))
if result:
return result
else:
return None
def test_legend(self):
event_group = EventGroup([
Event('a'),
EventGroupParallel([Event('c'), Event('d')]),
Event('e'),
Event('h')
])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['a', 'c', 'd', 'e', 'h'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(0, result)
self.assertCountEqual([x for x in ['a', 'c', 'd', 'e', 'h']],
char_list)
self.assertEqual(['a', 'c', 'd', 'e', 'h'],
events_to_char_list(model_result))
def to_n_length_opt(n, child_list):
min_length = min([len(x) for x in child_list])
max_length = n - min_length
global_result = []
while child_list:
child = child_list[0]
len_child = len(child)
child_list.remove(child)
if len_child <= max_length:
[
global_result.append(EventGroupParallel(x))
for x in to_n_length_inner_opt(n - len_child, max_length -
len_child, child,
copy.copy(child_list))
]
elif len_child == n:
if isinstance(child, list):
global_result.append(child[0])
# possibly should be always list
else:
global_result.append(child)
return global_result
def test_eq4(self):
e1 = EventGroup([Event('f'), EventGroupParallel([Event('b'),
EventGroup(string_to_events('ccc'))])])
e2 = EventGroupParallel([Event('f'), EventGroup([Event('b'),
EventGroupParallel(string_to_events('ccc'))])])
self.assertFalse(e1 == e2)
