def addition_then_multiplication_solver(stack: deque):
while '+' in stack:
stack.rotate(-stack.index('+'))
stack.popleft()
stack.appendleft(stack.popleft() + stack.pop())
return reduce((lambda x, y: x * y), (n for n in stack if n != '*'))
def solution(a: deque):
if len(a) == 1:
return a[0]
else:
a.popleft()
a.append(a.popleft())
return solution(a)
def ambs_unam_dict(ambs: deque, unam: deque):
"""
return dictionary with unam as key, ambs as value
:param ambs:
:param unam:
:return:
******** DEPRECATED ************
(ambs_unam_split in ambiguous_split should handle this)
"""
ambs_unam_d = OrderedDict()
try:
if len(ambs) != len(unam):
raise NotSameLengthError
else:
while True:
ambs_unam_d[unam.popleft()] = ambs.popleft()
except IndexError:
pass
except NotSameLengthError:
print("The length of the AMBS and UNAM deques were different. aborting")
finally:
return ambs_unam_d
def ignore_quotation(output: Output, tokens: deque) -> None:
output.normal_out += tokens.popleft().string
token = tokens[0]
while token.val != Tok.quotation:
output.normal_out += token.string
tokens.popleft()
token = tokens[0]
def recursive_combat(first_: deque, second_: deque) -> bool:
first_states = set()
second_states = set()
while len(first_) and len(second_):
if hash_deque(first_) in first_states or hash_deque(
second_) in second_states:
return True
first_states.add(hash_deque(first_))
second_states.add(hash_deque(second_))
first_card = first_.popleft()
second_card = second_.popleft()
if len(first_) >= first_card and len(second_) >= second_card:
first_won = recursive_combat(
deque(first_[x] for x in range(first_card)),
deque(second_[x] for x in range(second_card)))
else:
first_won = first_card > second_card
if first_won:
first_.extend((first_card, second_card))
else:
second_.extend((second_card, first_card))
return len(second_) == 0
def maybe_throttle(time_queue: collections.deque, rate_per_minute: int):
now = time.time()
if time_queue:
first = time_queue[0]
last = time_queue[-1]
else:
first = last = None
# Clear out timestamps before the past minute.
start_t = now - 60 + BUFFER # secs
while time_queue:
t = time_queue.popleft()
if t > start_t:
time_queue.appendleft(t)
break
# Sleep until the next item if we have to.
if len(time_queue) >= rate_per_minute:
t = time_queue.popleft()
dt = t - start_t
logging.info(f"Throttling for {dt:.1f} secs ({start_t} {t})")
time.sleep(dt)
now = time.time()
time_queue.append(now)
def _traverse_order(G, r):
in_degree = {v: G.in_degree[v] for v in G}
should_visit = {v: in_degree[v] for v in G}
pending = Que([r])
pending_multi_in = Que()
visit_order = list()
while True:
if pending:
u = pending.popleft()
elif pending_multi_in:
u = pending_multi_in.popleft()
else:
break
visit_order.append(u)
for v in G.successors(u):
should_visit[v] -= 1
if should_visit[v] == 0:
if in_degree[v] > 1:
pending_multi_in.append(v)
else:
pending.append(v)
if len(visit_order) != len(G):
raise Exception(
"Topological order is defined only for connected graphs")
return visit_order
def game(p1: deque, p2: deque) -> Tuple[int, deque, deque]:
history = set()
while len(p1) > 0 and len(p2) > 0:
fingerprint = (tuple(p1), tuple(p2))
if fingerprint in history:
return 1, p1, p2
else:
history.add(fingerprint)
c1, c2 = p1.popleft(), p2.popleft()
if c1 <= len(p1) and c2 <= len(p2):
winner, _, _ = game(deque(list(p1)[:c1]), deque(list(p2)[:c2]))
else:
winner = 1 if c1 > c2 else 2
if winner == 1:
p1.append(c1)
p1.append(c2)
elif winner == 2:
p2.append(c2)
p2.append(c1)
else:
assert False
return 1 if len(p1) > 0 else 2, p1, p2
def parse_list(tokens: deque) -> list:
"""
Consome tokens da lista (deque) e retorna uma lista.
"""
# Exemplo de implementação...
# Consome o colchete de abertura
if tokens.popleft() != "[":
raise SyntaxError
# Verifica se corresponde à uma lista vazia
elif tokens[0] == "]":
tokens.popleft()
return []
# Consome os valores
xs = []
while True:
# Lê valor e salva na saída
x = parse_value(tokens)
xs.append(x)
# Verifica fim da lista e remove vírgula se necessário
tk = tokens.popleft()
if tk == "]":
break
elif tk != ",":
raise SyntaxError("token inesperada em lista: %r" % tk)
return xs
def get_people(people_by_event: deque,
person_count: int) -> tuple[list, int, int]:
"""Tries to obtain person_count people from people_by_event, ensuring that
their dates overlap. May return a list of less people than person_count."""
if person_count > 1:
cur_people = [people_by_event.popleft() for _ in range(person_count)]
base_person = cur_people.pop()
verified_people = [base_person]
start_year = base_person.birth_year
end_year = base_person.death_year
while len(cur_people):
cur_person = cur_people.pop()
# no duplicate people
if cur_person in verified_people:
people_by_event.append(cur_person)
# people must overlap times
elif cur_person.birth_year > end_year or cur_person.death_year < start_year:
people_by_event.append(cur_person)
# otherwise, we have an overlap, so add person and narrow our window of time
else:
start_year = max(start_year, cur_person.birth_year)
end_year = min(end_year, cur_person.death_year)
verified_people.append(cur_person)
else:
cur_person = people_by_event.popleft()
verified_people = [cur_person]
start_year = cur_person.birth_year
end_year = cur_person.death_year
return verified_people, start_year, end_year
def remove_from_left(source_deque: deque, max_remove: int) -> None:
if max_remove < 0:
raise ValueError(f'Invalid max ({max_remove}) for deque')
for _ in range(max_remove):
print(f'Removing {source_deque[0]} from left ... ', end='')
source_deque.popleft()
print(f'-> {source_deque}')
def random_move_target(queue: collections.deque, opponent_board_view: Board) -> Point:
"""
Randomly choose an empty square to shoot at when in 'hunt' mode,
if hit, change to 'target' mode and focus first on neighbor cells.
"""
# decide moving mode
if len(queue) == 0:
mode = 'hunt'
else:
mode = 'target'
# make shot
if mode == 'hunt':
empty_xs, empty_ys = np.where(opponent_board_view.shots == NO_SHOT)
choice = randint(0, len(empty_xs)-1)
shot = Point(x=empty_xs[choice], y=empty_ys[choice])
elif mode == 'target':
shot = queue.popleft()
while opponent_board_view.shots[shot.x, shot.y] != NO_SHOT:
if len(queue) > 0:
shot = queue.popleft()
else:
shot = random_move_target(queue, opponent_board_view)
# add neighbors to queue if the shot is successful
if opponent_board_view.has_ship[shot.x, shot.y]:
up = Point(x=shot.x, y=max(shot.y-1, 0))
down = Point(x=shot.x, y=min(shot.y+1, 9))
left = Point(x=max(shot.x-1, 0), y=shot.y)
right = Point(x=min(shot.x+1, 9), y=shot.y)
neighbors = [up, down, left, right]
queue.extend(neighbors)
return shot
def _balance_insertion(self, curr, last):
walk = last
path = Queue()
path.append(curr), path.append(last)
while walk is not None:
self.tree[walk].height = max(self.left_height(
self.tree[walk]), self.right_height(self.tree[walk])) + 1
if self.is_order_statistic:
self.tree[walk].size = (self.left_size(self.tree[walk]) +
self.right_size(self.tree[walk]) + 1)
last = path.popleft()
last2last = path.popleft()
if self.balance_factor(self.tree[walk]) not in (1, 0, -1):
l = self.tree[walk].left
if l is not None and l == last and self.tree[
l].left == last2last:
self._right_rotate(walk, last)
r = self.tree[walk].right
if r is not None and r == last and self.tree[
r].right == last2last:
self._left_rotate(walk, last)
if l is not None and l == last and self.tree[
l].right == last2last:
self._left_right_rotate(walk, last)
if r is not None and r == last and self.tree[
r].left == last2last:
self._right_left_rotate(walk, last)
path.append(walk), path.append(last)
walk = self.tree[walk].parent
def _consume_output(printed, spec: deque):
"""
Helper function: consume the given output from io spec.
Raises AssertionErrors when it encounter problems.
"""
if not printed:
return
elif not spec:
raise AssertionError(
'Asking to consume output, but expects no interaction')
elif _is_input(spec[0]):
raise AssertionError('Expects input, but trying to print a value')
elif printed == spec[0]:
spec.popleft()
elif callable(spec[0]):
spec.popleft()(printed, spec)
elif spec[0].startswith(printed):
spec[0] = spec[0][len(printed):]
elif printed.startswith(spec[0]):
n = len(spec.popleft())
_consume_output(printed[n:], spec)
else:
raise AssertionError(f'Printed wrong value:\n'
f' print: {printed!r}\n'
f' got: {spec[0]!r}')
def play_recursive_space_cards(deck1: collections.deque,
deck2: collections.deque) -> tuple:
"""return the winner and its deck after a recursive space cards game"""
configurations = set()
while deck1 and deck2:
current_config = (tuple(deck1), tuple(deck2))
if current_config in configurations:
return 1, deck1
configurations.add(current_config)
card1, card2 = deck1.popleft(), deck2.popleft()
assert card1 != card2
if card1 <= len(deck1) and card2 <= len(deck2):
sub_deck1 = collections.deque(itertools.islice(deck1, card1))
sub_deck2 = collections.deque(itertools.islice(deck2, card2))
winner, _ = play_recursive_space_cards(sub_deck1, sub_deck2)
else:
winner = 1 if card1 > card2 else 2
if winner == 1:
deck1.extend((card1, card2))
else:
deck2.extend((card2, card1))
return (1, deck1) if deck1 else (2, deck2)
def value(x: deque):
result = []
while True:
if len(x) > 0:
if x[0].isalpha():
return False
elif isinteger(x[0]):
result.append(x.popleft())
else:
b, a = result.pop(), result.pop()
if x[0] == "+":
result.append(sum(a, b))
elif x[0] == "-":
result.append(difference(a, b))
elif x[0] == "*":
result.append(multiply(a, b))
elif x[0] == "^":
result.append(power(a, b))
else:
result.append(divide(a, b))
x.popleft()
else:
break
if len(result) > 1:
return "Invalid Expression"
else:
if result[0] == int(result[0]):
return int(result[0])
else:
return result[0]
def play_cups(cups: deque, nb_moves):
for i in range(0, nb_moves):
#print(f'-- move {i+1} --')
current_cup = cups[0]
# print(cups)
# print(f'current: {current_cup}')
cups.rotate(-1)
pickups = [cups.popleft(), cups.popleft(), cups.popleft()]
destination_cup = get_destination(current_cup, cups)
# print(f'pick up: {pickups}')
# print(f'destination: {destination_cup}')
dest_in = cups.index(destination_cup)
# push dest to end right end of the queue
# and add pickups to the right
cups.rotate(-dest_in - 1)
cups.extend(pickups)
# rotate the queue back into initial state shifted once
cups.rotate(dest_in + 4)
# print('')
return cups
def bombs(effects: deque, casings: deque):
type_bombs = {
"Datura Bombs": [40, 0],
"Cherry Bombs": [60, 0],
"Smoke Decoy Bombs": [120, 0],
}
success = False
while effects and casings:
current_casing = casings[-1]
current_effect = effects[0]
for bomb, value in type_bombs.items():
is_found_bomb = False
if current_casing + current_effect == value[0]:
type_bombs[bomb][1] += 1
casings.pop()
effects.popleft()
is_found_bomb = True
break
if not is_found_bomb:
casings[-1] -= 5
if all([value[1] >= 3 for value in type_bombs.values()]):
success = True
break
return success, type_bombs
def _parse_single_expr_string(tokens: deque) -> str:
if not is_deque(tokens):
raise ParseError('Expected expression')
if tokens[0] == 'not':
# expression is not(e), so next, parse the expression e before prepending the ~ operator to it.
token = tokens.pop()
e = _parse_single_expr_string(token)
if '~' in e:
raise ParseError('Multiple not operators in expression.')
return '~' + e
else: # expression is a standard Op(param1, param2, etc ...) format
expr_name = tokens.popleft()
if not is_string(expr_name):
raise ParseError('Invalid expression name: {}'.format(expr_name))
expr_name = expr_name.lower()
variables = []
while tokens:
param = tokens.popleft()
if not is_string(param):
raise ParseError('Invalid parameter {} for expression "{}"'.format(param, expr_name))
if param.startswith('?'):
variables.append(param[1:].lower())
else:
if not param[0].isupper():
param = param.capitalize()
variables.append(param)
return build_expr_string(expr_name, variables)
def parse_vanilla_response(slots: deque, server: GameServer) -> None:
"""Parse the default response of the vanilla client
:type slots: deque
:type server: GameServer
:return:
"""
server.server_type = 'vanilla'
server.version = slots.popleft().decode('utf-8')
server.name = slots.popleft().decode('utf-8')
server.map_name = slots.popleft().decode('utf-8')
server.game_type = slots.popleft().decode('utf-8')
server.flags = int(slots.popleft().decode('utf-8'))
server.num_players = int(slots.popleft().decode('utf-8'))
server.max_players = int(slots.popleft().decode('utf-8'))
server.num_clients = int(slots.popleft().decode('utf-8'))
server.max_clients = int(slots.popleft().decode('utf-8'))
while len(slots) >= 5:
server.append_player(
Player(name=slots.popleft().decode('utf-8'),
clan=slots.popleft().decode('utf-8'),
country=int(slots.popleft().decode('utf-8')),
score=int(slots.popleft().decode('utf-8')),
ingame=bool(int(slots.popleft().decode('utf-8')))))
def __update_prob_recursive(self, start: GraphNode, probs: dict,
previous_words: deque):
fixed_previous_words = previous_words
for next_node in start.next:
previous_words = fixed_previous_words.copy()
pre_len = len(previous_words)
next_node: GraphNode = next_node # just for type declaration
# prior probability
prior_prob = probs[pre_len].probability(" ".join(previous_words))
# union probability
words = list(previous_words.copy())
words.append(next_node.value)
union_prob = probs[pre_len + 1].probability(" ".join(words))
local_prob = union_prob / prior_prob
accumulative_prob = local_prob * start.accumulative_prob
if next_node.best_previous is None or accumulative_prob > next_node.accumulative_prob:
next_node.accumulative_prob = accumulative_prob
next_node.best_previous = start
if start == self.end:
start.next.append(self.end)
self.end.previous.append(start)
return
# update previous words and continue recursion
previous_words.append(next_node.value)
if len(previous_words) >= self.ngram_size:
previous_words.popleft()
self.__update_prob_recursive(next_node, probs, previous_words)
def build(self):
"""
Builds the segment tree from the segments,
using iterative algorithm based on queues.
"""
if self.cache:
return None
endpoints = []
for segment in self.segments:
endpoints.extend(segment)
endpoints.sort()
elem_int = Queue()
elem_int.append(
TreeNode([False, endpoints[0] - 1, endpoints[0], False], None))
i = 0
while i < len(endpoints) - 1:
elem_int.append(
TreeNode([True, endpoints[i], endpoints[i], True], None))
elem_int.append(
TreeNode([False, endpoints[i], endpoints[i + 1], False], None))
i += 1
elem_int.append(
TreeNode([True, endpoints[i], endpoints[i], True], None))
elem_int.append(
TreeNode([False, endpoints[i], endpoints[i] + 1, False], None))
self.tree = []
while len(elem_int) > 1:
m = len(elem_int)
while m >= 2:
I1 = elem_int.popleft()
I2 = elem_int.popleft()
I = self._union(I1, I2)
I.left = len(self.tree)
I.right = len(self.tree) + 1
self.tree.append(I1), self.tree.append(I2)
elem_int.append(I)
m -= 2
if m & 1 == 1:
Il = elem_int.popleft()
elem_int.append(Il)
Ir = elem_int.popleft()
Ir.left, Ir.right = -3, -2
self.tree.append(Ir)
self.root_idx = -1
for segment in self.segments:
I = TreeNode([True, segment[0], segment[1], True], None)
calls = [self.root_idx]
while calls:
idx = calls.pop()
if self._contains(I, self.tree[idx]):
if self.tree[idx].data is None:
self.tree[idx].data = []
self.tree[idx].data.append(I)
continue
calls = self._iterate(calls, I, idx)
self.cache = True
def parse_Lcl_Scaling(self, queue: deque) -> LclScaling:
self._assert(queue, "Lcl Scaling")
self._assert(queue, "")
self._assert(queue, "A")
x = queue.popleft()
y = queue.popleft()
z = queue.popleft()
return LclScaling(x, y, z)
def parse_Vector(self, queue: deque) -> Vector3:
self._assert(queue, "Vector")
self._assert(queue, "")
self._assert(queue, "A", optional=True)
x = queue.popleft()
y = queue.popleft()
z = queue.popleft()
return Vector3(x, y, z)
def parse_KString(self, queue: deque) -> str:
self._assert(queue, "KString")
special_type = queue.popleft() # e.g. 'Url'
self._assert(queue, "")
s = queue.popleft()
if special_type:
return f"{special_type}({repr(s)})"
return repr(s)
def parse_Lcl_Rotation(self, queue: deque) -> LclRotation:
self._assert(queue, "Lcl Rotation")
self._assert(queue, "")
self._assert(queue, "A")
x = queue.popleft()
y = queue.popleft()
z = queue.popleft()
return LclRotation(x, y, z)
def day13_update_board(board: DefaultDict[Position, int],
q: collections.deque):
while q:
x = q.popleft()
y = q.popleft()
code = q.popleft()
board[(x, y)] = code
return board
def peek_chunk(buffer: deque, length: int, clear: bool = False) -> bytes:
x = bytearray()
for i in range(length):
x.append(buffer[i])
if clear:
for _ in range(length):
buffer.popleft()
return bytes(x)
def count_tiles(q: collections.deque):
bag = collections.defaultdict()
while q:
x = q.popleft()
y = q.popleft()
code = q.popleft()
bag[(x, y)] = code
return sum(1 for x in bag.values() if x == 2)
def shift_reduce_train(queue: deque, ws, wl, wr):
'''
入力:
queue = [tok1, tok2, ...]
出力: 各素性の，shift, reduce left, reduce rightに対する重み
ws, wl, wr
'''
stack = [Token(0, 'ROOT', 'ROOT', 0)]
while len(queue) > 0 or len(stack) > 1:
# stackに２つなければshift
if len(stack) < 2:
stack.append(queue.popleft())
continue
# stack, queueの単語と品詞を元に素性を計算
phi = make_feats(stack, queue)
# アクションを分類してみる
pred_action = classify_action(ws, wl, wr, phi, queue)
# 正しいアクションを求める
corr_action = calc_corr(stack, queue)
# 間違った答えを返したら重みを更新する
if pred_action != corr_action:
for name, v in phi.items():
value = copy(v)
if pred_action == ACT.S:
ws[name] -= value
elif pred_action == ACT.L:
wl[name] -= value
elif pred_action == ACT.R:
wr[name] -= value
if corr_action == ACT.S:
ws[name] += value
elif corr_action == ACT.L:
wl[name] += value
elif corr_action == ACT.R:
wr[name] += value
# action according to corr
ans_action = classify_action(ws, wl, wr, phi, queue)
if ans_action == ACT.S:
stack.append(queue.popleft())
elif ans_action == ACT.L:
stack[-1].unproc -= 1
stack.pop(-2)
elif ans_action == ACT.R:
stack[-2].unproc -= 1
stack.pop(-1)
def rdfs(strList: deque):
if strList[0] == 'None':
strList.popleft()
return None
node = TreeNode(int(strList[0]))
strList.popleft()
node.left = rdfs(strList)
node.right = rdfs(strList)
return node
def filterMsgs(self, wrappedMsgs: deque) -> deque:
"""
Filters messages by view number so that only the messages that have the
current view number are retained.
:param wrappedMsgs: the messages to filter
"""
filtered = deque()
while wrappedMsgs:
wrappedMsg = wrappedMsgs.popleft()
msg, sender = wrappedMsg
if hasattr(msg, f.VIEW_NO.nm):
reqViewNo = getattr(msg, f.VIEW_NO.nm)
if reqViewNo == self.viewNo:
filtered.append(wrappedMsg)
elif reqViewNo > self.viewNo:
logger.debug(
"{}'s elector queueing {} since it is for a later view".format(
self.name, wrappedMsg))
self.pendMsgForLaterView((msg, sender), reqViewNo)
else:
self.discard(wrappedMsg,
"its view no {} is less than the elector's {}"
.format(wrappedMsg, reqViewNo, self.viewNo),
logger.debug)
else:
filtered.append(wrappedMsg)
return filtered
def _parse_preconditions(self, tokens: deque) -> bool:
if not is_deque(tokens):
raise ParseError('Invalid precondition list for action "{}": {}'.format(self._action_name, tokens))
if len(tokens) == 0:
raise ParseError('Missing precondition list for action "{}".'.format(self._action_name))
precond_seq = tokens.popleft()
self._preconditions = _parse_formula(precond_seq)
return True
def _parse_effects(self, tokens: deque) -> bool:
if not is_deque(tokens):
raise ParseError('Invalid effects list for action "{}": {}'.format(self._action_name, tokens))
if len(tokens) == 0:
raise ParseError('Missing effects list for action "{}".'.format(self._action_name))
effects_seq = tokens.popleft()
self._effects = _parse_formula(effects_seq)
return True
def _parse_goal(self, tokens: deque) -> bool:
if not is_deque(tokens):
raise ParseError('Invalid goal list after :goal keyword')
if len(tokens) == 0:
raise ParseError('Missing goal list after :goal keyword')
goal_list = tokens.popleft()
self.goals = _parse_formula(goal_list)
return True
def transform_sexprs(tokens: deque):
"""Read an expression from a sequence of tokens."""
if len(tokens) == 0:
raise ParseError('unexpected EOF while reading {}'.format(filename))
token = tokens.popleft()
if '(' == token:
D = deque()
try:
while tokens[0] != ')':
D.append(transform_sexprs(tokens))
tokens.popleft() # pop off ')'
return D
except IndexError:
raise ParseError('unexpected EOF while reading {}'.format(filename))
elif ')' == token:
raise ParseError('unexpected ) in {}'.format(filename))
else:
return token
def _expand_all(root):
q = Queue()
q.append((root, ''))
paths = []
while q:
node, path = q.popleft()
paths.append(path)
for c in PathParser._search_graph.get(node, []):
q.append((c, path + '/' + c))
return paths
def _parse_parameters(self, tokens: deque) -> bool:
if is_deque(tokens) and len(tokens) > 0:
param_list = tokens.popleft()
if not is_deque(param_list):
raise ParseError('Expected parameter list for action "{}"'.format(self._action_name))
try:
self._parameters = _parse_variables(param_list, self._types)
except IndexError:
raise ParseError('Error parsing parameter list for action "{}"'.format(self._action_name))
return True
def _expand_gap(root, end):
q = Queue()
q.append((root, ''))
paths = []
while q:
node, path = q.popleft()
if node == end:
paths.append(path)
else:
for c in PathParser._search_graph.get(node, []):
q.append((c, path + '/' + c))
return paths
def analyze_result(self, results: deque, debounce: int, repeat_every: int):
"""Analyze result according to check definition.
:param results: deque object with last results according to debounce or
repeat_every
:param debounce: debounce value from check data
:param repeat_every: repeat_every value from check data
:return: (trigger status, event_type)
:rtype: tuple
"""
last_result = CachedResult(RESULT_UNKNOWN, RESULT_UNKNOWN, False, "")
result_length = len(results)
results_list = list(results)
if result_length < debounce:
# not enough values to proceed with analyze
return RESULT_OK, None
if result_length == debounce + 1:
last_result = results.popleft()
elif result_length == debounce:
last_result = CachedResult(RESULT_OK, RESULT_OK, False, "")
elif result_length > debounce:
last_result = results_list[-(debounce + 1)]
debounce_probes = results_list[result_length - debounce:]
all_debounce_fail = all(result.status in FAILED_STATUSES
for result in debounce_probes)
if all([all_debounce_fail, last_result.status in OK_STATUSES]):
return RESULT_FAILED, 'trigger'
try:
if all([all_debounce_fail,
results_list[-(repeat_every + 1)].alert_sent]):
return RESULT_FAILED, 'trigger'
except IndexError:
pass
latest_result = results.pop()
if all([last_result.status in FAILED_STATUSES,
all(result.status in FAILED_STATUSES for result in results),
latest_result.status == RESULT_OK]):
if latest_result.hysteresis != RESULT_OK:
return RESULT_FAILED, None
if latest_result.hysteresis == RESULT_OK:
return RESULT_OK, 'resolve'
if all([all(result.status in OK_STATUSES for result in results),
latest_result.status == RESULT_FAILED]):
return RESULT_FAILED, None
if all([all_debounce_fail, last_result.status in FAILED_STATUSES]):
return RESULT_FAILED, None
return RESULT_OK, None
def _parse_define(self, tokens: deque) -> bool:
if not is_deque(tokens):
raise ParseError('Domain list not found after define statement')
domain_seq = tokens.popleft()
if is_deque(domain_seq) and len(domain_seq) == 0:
raise ParseError('Domain list empty')
token = domain_seq.popleft()
if token != 'domain':
raise ParseError('Domain keyword not found after define statement')
if is_deque(domain_seq) and len(domain_seq) == 0:
raise ParseError('Domain name not found in domain list')
self.domain_name = domain_seq.popleft()
return True
def _parse_define(self, tokens: deque) -> bool:
if not is_deque(tokens) or len(tokens) == 0:
raise ParseError('Expected problem list after define statement')
problem_seq = tokens.popleft()
if not is_deque(problem_seq):
raise ParseError('Invalid problem list after define statement')
if len(problem_seq) == 0:
raise ParseError('Missing problem list after define statement')
token = problem_seq.popleft()
if token != 'problem':
raise ParseError('Problem keyword not found after define statement')
self.problem_name = problem_seq.popleft()
return True
async def handleAll(self, deq: deque, limit=None) -> int:
"""
Handle all items in a deque. Can call asynchronous handlers.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
"""
count = 0
while deq and (not limit or count < limit):
count += 1
item = deq.popleft()
await self.handle(item)
return count
async def handleAll(self, deq: deque, limit=None) -> int:
"""
Handle multiple messages passed as a deque.
:param deq: a deque of messages to be handled by this router
:param limit: the number of messages in the deque to the handled
:return: the number of message handled successfully
"""
count = 0
while deq and (not limit or count < limit):
count += 1
msg = deq.popleft()
await self.handle(msg)
return count
def handleAllSync(self, deq: deque, limit=None) -> int:
"""
Synchronously handle all items in a deque.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
"""
count = 0
while deq and (not limit or count < limit):
count += 1
msg = deq.popleft()
self.handleSync(msg)
return count
def match_tokens(tokens: deque):
if not is_deque(tokens):
return False
item = tokens.popleft()
if is_string(item):
item = item.lower()
for text in match_dict:
if item.startswith(text):
if match_dict[text](tokens):
break
elif is_deque(item):
match_tokens(item)
else:
raise ParseError('Unexpected token: {}'.format(item))
return True
def _parse_formula(formula: deque) -> list:
if not is_deque(formula):
raise ParseError('Invalid formula: {}'.format(formula))
if len(formula) == 0:
raise ParseError('Formula is empty')
expr_lst = []
token = formula.popleft()
if not is_string(token):
raise ParseError('Invalid token for start of formula: {}'.format(token))
if token.lower() == 'and': # preconds and effects only use 'and' keyword
exprs = _parse_expr_list(formula)
expr_lst.extend(exprs)
else: # parse single expression
formula.appendleft(token)
expr_lst.append(_parse_single_expr_string(formula))
return expr_lst
def breadth_first_search(startnode, goalnode):
queue = Queue()
queue.append(startnode)
nodesseen = set()
nodesseen.add(startnode)
while queue:
node = queue.popleft()
if node is goalnode:
return True
else:
queue.extend(node for node in node.successors if node not in nodesseen)
nodesseen.update(node.successors)
return False
def _parse_predicates(self, tokens: deque) -> bool:
while tokens:
if not is_deque(tokens):
raise ParseError('Valid list not found after :predicates keyword')
predicate = tokens.popleft()
if not is_deque(predicate):
raise ParseError('Invalid predicate: {}'.format(predicate))
pred_name = predicate.popleft()
if not is_string(pred_name):
raise ParseError('Invalid predicate name: {}'.format(pred_name))
if not is_deque(predicate):
raise ParseError('Invalid predicate variable list: {}'.format(predicate))
try:
new_predicate = [pred_name] + _parse_variables(predicate, self._types)
except IndexError:
raise ParseError('Error parsing variables for predicate {}'.format(pred_name))
self.predicates.append(new_predicate)
return True
def breadth_first_search(startnode, goalnode):
"""
Input:
startnode: A digraph node
goalnode: A digraph node
Output:
Whether goalnode is reachable from startnode
"""
queue = Queue()
queue.append(startnode)
nodesseen = set()
nodesseen.add(startnode)
while queue:
node = queue.popleft()
if node is goalnode:
return True
else:
queue.extend(node for node in node.successors if node not in nodesseen)
nodesseen.update(node.successors)
return False
def filterMsgs(self, wrappedMsgs: deque) -> deque:
"""
Filters messages by view number so that only the messages that have the
current view number are retained.
:param wrappedMsgs: the messages to filter
"""
filtered = deque()
while wrappedMsgs:
wrappedMsg = wrappedMsgs.popleft()
msg, sender = wrappedMsg
if hasattr(msg, f.VIEW_NO.nm):
reqViewNo = getattr(msg, f.VIEW_NO.nm)
if reqViewNo == self.viewNo:
filtered.append(wrappedMsg)
else:
self.discard(wrappedMsg,
"its view no {} is less than the elector's {}"
.format(reqViewNo, self.viewNo),
logger.debug)
else:
filtered.append(wrappedMsg)
return filtered
def _parse_domain(self, tokens: deque) -> bool:
if not is_deque(tokens) or len(tokens) == 0:
raise ParseError('Expected domain name after :domain keyword')
self.domain_name = tokens.popleft()
return True
