def generateLineViews(self, grid):
allViews = {}
viewH = [''.join(x) for x in grid]
allViews['h'] = viewH
allViews['h-'] = [x[::-1] for x in viewH]
# print(viewH)
viewV = [''.join(x) for x in zip(*viewH)]
allViews['v'] = viewV
allViews['v-'] = [x[::-1] for x in viewV]
# print(viewV)
viewDR = defaultlist(str)
viewDL = defaultlist(str)
height = len(viewH)
width = len(viewV)
for i in range(height):
first = height - i - 1
for j in range(width):
viewDR[first + j] += viewH[i][j]
viewDL[i + j] += viewH[i][j]
# print(viewDR)
# print(viewDL)
allViews['dr'] = viewDR
allViews['dr-'] = [x[::-1] for x in viewDR]
allViews['dl'] = viewDL
allViews['dl-'] = [x[::-1] for x in viewDL]
self.allViews = allViews
if self.requestViews:
self.views = {key: allViews[key] for key in self.requestViews}
else:
self.views = allViews
def __init__(self, scope, stream_uuid):
self.scope = scope
self.uuid = stream_uuid
self.clocks = defaultlist.defaultlist(lambda: Clock(self))
self.activities = defaultlist.defaultlist(lambda: Activity(self))
self.activities[0].verb = '<root>'
self.activities[0].idx = scope.make_idx()
self.activities[0].clock = self.clocks[0]
def cleanup(self) -> None:
if not ArgumentParser.args.cleanup:
log.error('Cleanup called but --cleanup flag not provided at startup - ignoring call')
return
log.info('Notifying plugins to plan cleanup')
dispatch_event(Event(EventType.CLEANUP_PLAN, self.graph), blocking=True)
log.info('Running cleanup')
dispatch_event(Event(EventType.CLEANUP_BEGIN, self.graph), blocking=True)
with self.graph.lock.read_access:
cleanup_nodes = [node for node in self.graph.nodes() if node.clean]
cleanup_plan = defaultlist(lambda: [])
for node in cleanup_nodes:
log.debug(f'Adding {node.resource_type} {node.dname} to cleanup plan with priority {node.max_graph_depth}')
cleanup_plan[node.max_graph_depth].append(node)
with ThreadPoolExecutor(max_workers=ArgumentParser.args.cleanup_pool_size, thread_name_prefix='pre_cleaner') as executor:
executor.map(self.pre_clean, cleanup_nodes)
for nodes in reversed(cleanup_plan):
with ThreadPoolExecutor(max_workers=ArgumentParser.args.cleanup_pool_size, thread_name_prefix='cleaner') as executor:
executor.map(self.clean, nodes)
dispatch_event(Event(EventType.CLEANUP_FINISH, self.graph))
def __init__(self, program):
self.program = defaultlist(lambda: 0) + program
self.cursor = 0
self.relative_base = 0
self.output_count = 0
self.outputs = []
def format_lists():
"""Transforms ordered and unordered lists into markdown-syntax."""
ordered_list_history = defaultlist.defaultlist(lambda: 1)
sequential_empty_lines = 0
line = ''
while True:
line = yield line
list_item_match = re.match(r'^\s*([-|\+])\s', line)
if list_item_match:
i = list_item_match.start(1)
if line[i] == '-':
# Un-ordered lists have the same format in markdown.
pass
else:
# Ordered lists must change to the actual number.
line = f'{line[:i]}{ordered_list_history[i]}.{line[i + 1:]}'
ordered_list_history[i] += 1
# Reset numbering of sub-items.
del ordered_list_history[i + 1:]
elif line.strip():
sequential_empty_lines = 0
ordered_list_history.clear()
else:
sequential_empty_lines += 1
if sequential_empty_lines >= 2:
ordered_list_history.clear()
def __init__(self, intcode: list):
self.ic = defaultlist(lambda: 0)
self.ic.extend(intcode)
self.pos = 0
self.rb = 0
self.running = True
self.q = Queue()
def __init__(self, client, data):
self.client = client
self.program = client.program
data = str(data)
self.opcode = OpCode(int(data[-2:]))
self.modes = defaultlist(lambda: Mode(0)) + [
Mode(int(x)) for x in reversed(data[:-2])
]
def __init__(self):
self._program = defaultlist(lambda: 0)
self._program[0] = 99
self._status = IntCodeStatus.UNINITIALIZED
self._input = deque()
self._output_buffer = list()
self._program_counter = 0
self._relative_base_offset = 0
def __init__(self, program, id_):
self.program = defaultlist(lambda: 0) + program
self.id = id_
self.cursor = 0
self.relative_base = 0
self.input_count = 0
self.start_count = 0
self.running = True
def test_len():
"""Length."""
l = defaultlist()
eq_(len(l), 0)
l[2] = "C"
eq_(len(l), 3)
l[4]
eq_(len(l), 5)
def test_simple():
"""Simple scenario."""
l = defaultlist()
eq_(l, [])
l[2] = "C"
eq_(l, [None, None, 'C'])
l[4]
eq_(l, [None, None, 'C', None, None])
def add_event_list(
self, e: "List[EventType]", dashed_links: Optional[List[bool]] = None
):
dash = defaultlist(lambda: self.dash_by_default)
if dashed_links:
for i, b in enumerate(dashed_links):
dash[i] = b
for j in range(len(e)):
self.add_event(e[j], dash[j - 1], dash[j])
def exp3():
tuf_table_file_name = 'all_maxs.csv'
all_alarms = tuf_table_csv_to_df(
os.path.join(PROJECT_ROOT, "csvs", tuf_table_file_name))
australia_alarms = tuf_table_csv_to_df(
os.path.join(PROJECT_ROOT, "csvs", "australia.csv"))
m1, s1 = torch.serialization.load(os.path.join(PROJECT_ROOT, 'means.pt')), \
torch.serialization.load(os.path.join(PROJECT_ROOT, 'stds.pt'))
australia_ad = AlarmDataset(australia_alarms,
DATA_ROOT,
transform=transforms.Compose(
[Normalize(m1, s1)]))
australia_adl = DataLoader(australia_ad,
BATCH_SIZE,
shuffle=False,
num_workers=4)
f = open(os.path.join(LOGS_PATH, "loss.csv"), "w+")
nets = defaultlist(lambda: torch.nn.DataParallel(GPR_15_300()))
for overtrain in range(100):
for i, (strat_splits, _rgn_train, rgn_holdout) in enumerate(
region_and_stratified(all_alarms,
n_splits_stratified=N_STRAT_SPLITS)):
net = nets[i]
# main training loop
for j, (alarm_strat_train,
alarm_strat_holdout) in enumerate(strat_splits):
# train
strat_train_ad = AlarmDataset(alarm_strat_train,
DATA_ROOT,
transform=transforms.Compose(
[Normalize(m1, s1)]))
strat_train_adl = DataLoader(strat_train_ad,
BATCH_SIZE,
SHUFFLE_DL,
num_workers=4)
optim = OPTIMIZER(net)
sched = SCHEDULER(optim, strat_train_adl)
for k, _ in enumerate(
train(net,
strat_train_adl,
criterion=CRITERION,
optimizer=optim,
scheduler=sched,
epochs=EPOCHS)):
_roc, auc, _all_labels, _confs, loss = test(
net, australia_adl, CRITERION)
f.write(f"{i}, {j}, {k}, {auc}, {loss}\n")
f.flush()
print(f"done with {i} {j} {k} auc: {auc} loss: {loss}")
def test_op():
"""default operations."""
l = defaultlist()
l[2] = "C"
l[4]
eq_(l, [None, None, 'C', None, None])
l.insert(3, 'D')
eq_(l, [None, None, 'C', 'D', None, None])
l.remove(None)
eq_(l, [None, 'C', 'D', None, None])
def __init__(self, memory):
self.memory = defaultlist(lambda: 0)
for i, entry in enumerate(memory):
self.memory[i] = entry
self.pointer = 0
self.relative_base = 0
self.inputs = None
self.outputs = []
self.complete = False
def test_slice():
"""Slice selection."""
l = defaultlist()
l += list(range(5))
eq_(l, [0, 1, 2, 3, 4])
c = l[1:]
eq_(c, [1, 2, 3, 4])
c = l[1:-1]
eq_(c, [1, 2, 3])
c[5] = 'c0fe'
eq_(c, [1, 2, 3, None, None, 'c0fe'])
def test_copy():
"""copy()."""
l = defaultlist()
l[2] = "C"
l[4]
eq_(l, [None, None, 'C', None, None])
c = l.copy()
eq_(c, [None, None, 'C', None, None])
assert isinstance(c, defaultlist)
c[6] = 'c0fe'
eq_(c, [None, None, 'C', None, None, None, 'c0fe'])
def parse_table(table):
grid = defaultlist(defaultlist)
row_class = defaultlist()
cur_row = 0
cur_col = 0
seen_cols = False
for line in table:
xline = line.rstrip()
if xline.startswith('|}'):
break
if xline.startswith('|-'):
cur_col = 0
if seen_cols:
cur_row += 1
seen_cols = False
m = re_attribs.search(line)
if m:
assert m.group(1) == 'class'
row_class[cur_row] = m.group(2)
elif xline.startswith('|') or xline.startswith('!'):
seen_cols = True
if '||' in line or '!!' in line:
cols = re_col.split(xline[1:])
# if len(grid) <= cur_row:
# grid += [None] * ((cur_row - len(grid)) + 1)
for num, i in enumerate(cols):
set_grid(grid, cur_row, cur_col + num, i)
cur_col += num
else:
# if len(grid) <= cur_row:
# grid += [None] * ((cur_row - len(grid)))
set_grid(grid, cur_row, cur_col, line[1:])
cur_col += 1
return (row_class, grid)
for i, row in enumerate(grid):
print(len(row))
print('grid:', i, row)
def update_rating(source_file, output_file, is_pair):
"""
Update rating using information from results table in csv format
"""
row_count = 0
results = defaultlist(list)
with open(source_file, 'r') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
for row in reader:
results[row_count] = row
row_count += 1
start_column = 3
if is_pair:
start_column += 3
curr_rating_column = 1
is_first_line = True
for row in results:
if is_first_line:
is_first_line = False
row.append("New rating")
continue
curr_rating = float(row[curr_rating_column])
new_rating = curr_rating
curr_name = row[curr_rating_column + 1]
if is_pair:
curr_name += '+' + row[curr_rating_column + 3]
for i in range(start_column, row_count - 1 + start_column):
if ':' not in row[i]:
continue
score = row[i]
curr_opp_rating = float(results[i - start_column +
1][curr_rating_column])
opp_name = results[i - start_column + 1][curr_rating_column + 1]
if is_pair:
opp_name += '+' + results[i - start_column +
1][curr_rating_column + 3]
if '+' in row[i]:
first, _, score = row[i].partition("+")
delta = delta_calculation(curr_rating, curr_opp_rating, first)
new_rating += delta
print(curr_name + ',' + opp_name + ',' + first + ',' +
str(delta))
delta = delta_calculation(curr_rating, curr_opp_rating, score)
new_rating += delta
print(curr_name + ',' + opp_name + ',' + score + ',' + str(delta))
row.append("{:.1f}".format(new_rating))
with open(output_file, 'w') as outfile:
wr = csv.writer(outfile, delimiter=',')
for row in results:
wr.writerow(row)
def test_slice_ref():
"""Slice reference implementation."""
r = list(range(10))
l = defaultlist()
l += r
eq_(l[-4:9], r[-4:9])
eq_(l[0:9], r[0:9])
eq_(l[:9], r[:9])
eq_(l[-4:8], r[-4:8])
eq_(l[0:], r[0:])
eq_(l[:-2], r[:-2])
eq_(list(l), r)
def test_iadd():
"""iadd operator."""
a = defaultlist()
b = [1, 2]
a += a
eq_(a, [])
a += b
eq_(a, [1, 2])
a[5] = 7
eq_(b, [1, 2])
eq_(a, [1, 2, None, None, None, 7])
with assert_raises(TypeError, "'int' object is not iterable"):
a += 4
def table_to_items(table):
row_class, grid = parse_table(table)
rooms = defaultlist()
start_cell = cell_text(grid[0][0])
if not start_cell or 'Building' not in start_cell:
return None, None
room_row = next(row for row in range(len(row_class))
if row_class[row] == 'room')
for i in range(1, len(grid[room_row]) - 1):
text = tidy_room_name(cell_text(grid[room_row][i]))
rooms[i] = text
seen = set()
if False:
for row in range(0, len(grid)):
cls = row_class[row]
print(cls)
items = []
for row in range(2, len(grid)):
cls = row_class[row]
if cls != 'items':
continue
row_time = cell_text(grid[row][0])
assert len(row_time) == 5
for col in range(1, len(grid[row])):
cell = grid[row][col]
text = cell_text(cell)
if text is None:
continue
if not is_program_item(text) or text in seen:
continue
seen.add(text)
item = parse_program_item(text)
if '/' not in item['title']:
continue
assert item['title'].startswith('2019:')
if row != cell['row']:
assert cell_text(grid[cell['row']][col]) == text
item['start'] = row_time
item['duration'] = rowspan_to_duration(cell['rowspan'])
item['room'] = rooms[col]
items.append(item)
return rooms, items
def test_add():
a = defaultlist()
b = [1, 2]
a_a = a + a
eq_(a_a, [])
a_b = a + b
eq_(a_b, [1, 2])
a_b[5] = 7
eq_(a, [])
eq_(b, [1, 2])
eq_(a_b, [1, 2, None, None, None, 7])
with assert_raises(TypeError,
'can only concatenate list (not "int") to list'):
a + 4
def test_inc():
"""Count the number of func invocations."""
def inc():
inc.counter += 1
return inc.counter
inc.counter = -1
l = defaultlist(inc)
eq_(l, [])
l[2] = "C"
eq_(l, [0, 1, 'C'])
eq_(l[4], 4)
eq_(l, [0, 1, 'C', 3, 4])
eq_(l[1], 1)
eq_(l, [0, 1, 'C', 3, 4])
def test_copy_inc():
"""copy() using inc."""
def inc():
inc.counter += 1
return inc.counter
inc.counter = -1
l = defaultlist(inc)
l[2] = "C"
l[4]
eq_(l, [0, 1, 'C', 3, 4])
c = l.copy()
eq_(c, [0, 1, 'C', 3, 4])
assert isinstance(c, defaultlist)
c[6] = 'c0fe'
eq_(c, [0, 1, 'C', 3, 4, 5, 'c0fe'])
l[6]
eq_(l, [0, 1, 'C', 3, 4, 7, 8])
class Day14(AOCDay):
test_input = "abc"
THREE_SAME = re.compile(r"(.)\1\1")
hash_cache = defaultlist()
def has_triplet(self, s):
return self.THREE_SAME.search(s)
def stretch_hash(self, hash):
for _ in range(2016):
hash = md5(hash.encode("utf-8")).hexdigest()
return hash
def common(self, input_data):
if isinstance(self.input_data, str):
self.input_data = self.input_data.encode("utf-8")
self.hash_cache = defaultlist()
def part1(self, input_data):
index = 0
found_keys = []
while len(found_keys) < 64:
if self.hash_cache[index] is None:
self.hash_cache[index] = md5(
self.input_data + str(index).encode("utf-8")).hexdigest()
hash = self.hash_cache[index]
if c := self.has_triplet(hash):
for i in range(1, 1001):
if self.hash_cache[index + i] is None:
self.hash_cache[index + i] = md5(
self.input_data +
str(index + i).encode("utf-8")).hexdigest()
hash2 = self.hash_cache[index + i]
if f"{c.group(1)}{c.group(1)}{c.group(1)}{c.group(1)}{c.group(1)}" in hash2:
self.debug(f"#{len(found_keys)+1}")
self.debug(f"3 -- {index}: {hash}")
self.debug(f"5 -- {index+i}: {hash2}")
found_keys.append((index, index + i, hash))
break # Break from for loop
index += 1
yield found_keys[-1][0]
def create_users(_input: List) -> List:
""" Create multiple users
"""
_output = defaultlist(dict)
for _index, add_user in enumerate(_input):
_output[_index] = create_user(add_user)
return _output
# def check_userinfo(_input: dict, _check_keys:list) -> list:
# """
# _input = { "name": "admin","password": "******"}
# _check_keys = ["name", "password"]
# """
# pass
# # model_user = model_user_tool.get_by_name(name=_input.get("name"))
# # isTrue, keys = check_value(_input, _demo: dict, _keys: list)
def intcode(input_str, input=None, output=None):
ints = defaultlist(lambda: 0)
for _int in map(lambda x: int(x), input_str.split(",")):
ints.append(_int)
if not input:
input = Queue()
if not output:
output = input
int_pointer = 0
relative_base = 0
while int_pointer < len(ints):
opcode = Opcode(ints[int_pointer])
if opcode.operation == Operation.Term:
return list(output.queue)[-1] if output.queue else ints[0]
int_pointer, relative_base = opcode.execute(int_pointer, ints, input,
output, relative_base)
def test_slice_step():
"""Slice Selection with step."""
l = defaultlist()
l[0] = 'a'
l[1] = 'b'
l[2] = 'c'
l[3] = 'd'
l[4] = 'e'
l[5] = 'f'
d = l[1:6:2]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None])
eq_(d, ['b', 'd', 'f'])
d = l[:6:2]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None])
eq_(d, ['a', 'c', 'e'])
d = l[1:6:2]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None])
eq_(d, ['b', 'd', 'f'])
d = l[:7:2]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None, None])
eq_(d, ['a', 'c', 'e', None])
d = l[1:7:2]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None, None])
eq_(d, ['b', 'd', 'f'])
d = l[::2]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None, None])
eq_(d, ['a', 'c', 'e', None])
d = l[1::2]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None, None])
eq_(d, ['b', 'd', 'f', None])
d = l[1::]
eq_(l, ['a', 'b', 'c', 'd', 'e', 'f', None, None])
eq_(d, ['b', 'c', 'd', 'e', 'f', None, None])
def __init__(self, c_input, input_id):
self.current_index = 0
self.memory = defaultlist()
self.memory.extend(c_input)
self.input_value = input_id
self.outputs = []
result = "START"
while self.current_index < len(self.memory) and result != "HALT":
(
instruction,
mode_param_1,
mode_param_2,
mode_param_3,
) = self.parse_instruction_and_modes(self.memory[self.current_index])
result = self.run_instruction(
opcode=instruction,
mode_param_1=mode_param_1,
mode_param_2=mode_param_2,
mode_param_3=mode_param_3,
)
