def check_recall(self): c = self._cursor() print("Loading questions and guesses") raw_questions = seq(qdb.QuestionDatabase(QB_QUESTION_DB).all_questions().values()) guesses = seq(list( c.execute('SELECT * FROM guesses WHERE guesser="deep" AND fold = "devtest"'))) \ .map(lambda g: Guess(*g)).cache() positions = guesses.map(lambda g: (g.question, g.sentence)) \ .reduce_by_key(max).to_dict() guess_lookup = guesses.filter(lambda g: g.sentence == positions[g.question]) \ .group_by(lambda x: x.question) \ .map(lambda g: (g[0], seq(g[1]).map(lambda x: x.page).set())).to_dict() questions = raw_questions. \ filter(lambda q: q.qnum in guess_lookup and q.fold != 'train').cache() correct = 0 total = 0 wrong = [] print("Computing DAN recall") for q in questions: if q.page in guess_lookup[q.qnum]: correct += 1 else: wrong.append(q) total += 1 return correct / total, total, wrong
def submit(self): print("Buzzed questions") print(self.buzzed_questions) print("Non-buzzed questions (should be empty)") print(self.questions) print("Submitting answers") for q in self.buzzed_questions: url = 'http://{domain}/qb-api/v1/answer/{q_id}'.format( domain=self.domain, q_id=q.id) response = requests.post(url, data={ 'user_id': self.user_id, 'api_key': self.api_key, 'guess': q.guess }) if response.status_code == 200: print("Question submitted") else: print("Error on question submission") print("Printing statistics") guess_set = set() saved_guesses = [] for q in self.buzzed_questions: for g in q.all_guesses: guess_set.add(g[1]) saved_guesses.append((q.id, q.guess, q.all_guesses)) print('qid: {0} guess: {1} position: {2} text: {3} all_guesses: {4}'.format( q.id, q.guess, q.position, q.text, q.all_guesses)) print("All guesses") print(len(guess_set)) print(guess_set) seq(saved_guesses).to_json('/tmp/stream_results.json')
def test_for_each(self): l = [1, 2, 3, "abc", {1: 2}, {1, 2, 3}] result = [] def f(e): result.append(e) seq(l).for_each(f) self.assertEqual(result, l)
def test_to_sqlite3_namedtuple(self): elements = [(1, 'Tom'), (2, 'Jack'), (3, 'Jane'), (4, 'Stephan')] # test namedtuple with the same order as column with sqlite3.connect(':memory:') as conn: user = collections.namedtuple('user', ['id', 'name']) conn.execute('CREATE TABLE user (id INT, name TEXT);') conn.commit() table_name = 'user' seq(elements).map(lambda u: user(u[0], u[1])).to_sqlite3(conn, table_name) result = seq.sqlite3(conn, 'SELECT id, name FROM user;').to_list() self.assertListEqual(elements, result) # test namedtuple with different order with sqlite3.connect(':memory:') as conn: user = collections.namedtuple('user', ['name', 'id']) conn.execute('CREATE TABLE user (id INT, name TEXT);') conn.commit() table_name = 'user' seq(elements).map(lambda u: user(u[1], u[0])).to_sqlite3(conn, table_name) result = seq.sqlite3(conn, 'SELECT id, name FROM user;').to_list() self.assertListEqual(elements, result)
def test_add(self): l0 = seq([1, 2, 3]).map(lambda x: x) l1 = seq([4, 5, 6]) l2 = [4, 5, 6] expect = [1, 2, 3, 4, 5, 6] self.assertEqual(l0 + l1, expect) self.assertEqual(l0 + l2, expect)
def test_list(self): l = [1, 2, 3, "abc", {1: 2}, {1, 2, 3}] result = seq(l).list() self.assertEqual(result, l) self.assertTrue(isinstance(result, list)) result = seq(iter([0, 1, 2])).to_list() self.assertIsInstance(result, list)
def test_join(self): A = [('a', 11), ('b', 12), ('c', 13)] B = [('b', 22), ('c', 23), ('d', 24)] seq(A).inner_join(B).sorted() assert seq(A).join(B, 'inner').sorted() == seq(A).inner_join(B).sorted() assert seq(A).join(B, 'left').sorted() == seq(A).left_join(B).sorted() assert seq(A).join(B, 'outer').sorted() == seq(A).outer_join(B).sorted() assert seq(A).join(B, 'right').sorted() == seq(A).right_join(B).sorted()
def compute_statistics(questions: Dict[int, Answer]) -> Sequence: n_questions = len(questions) empty_set = [(a, 0) for a in Answer] results = seq(questions.values())\ .map(lambda x: (x, 1)) results = (results + seq(empty_set)).reduce_by_key(lambda x, y: x + y)\ .map(lambda kv: (str(kv[0]), kv[1] / n_questions if kv[1] > 0 else 0)) return results
def test_accumulate(self): f = lambda x, y: x + y l_char = ["a", "b", "c"] expect_char = ["a", "ab", "abc"] l_num = [1, 2, 3] expect_num = [1, 3, 6] self.assertEqual(seq(l_char).accumulate(), expect_char) self.assertEqual(seq(l_num).accumulate(), expect_num)
def test_to_file_without_delim(self): path = 'test-wo-delim.txt' seq(('a', 'b', 'c'), (11, 12, 13), (21, 22, 23)).to_file(path) exp = _normalize(''' [('a', 'b', 'c'), (11, 12, 13), (21, 22, 23)] ''') act = _normalize(_read_file(path)) assert exp == act
def test_to_json_array(self): path = 'test-array.json' seq(('a', 1), ('b', 2), ('c', 3)).to_json(path, root_array=True) exp = _normalize(''' [["a", 1], ["b", 2], ["c", 3]] ''') act = _normalize(_read_file(path)) assert exp == act
def _log_msg(cls, f, elapsed_time, *args, **kwargs): arg_string = (seq(args).map(repr) + seq(kwargs.items()).map( lambda kv: '{!r}={!r}'.format(kv[0], kv[1])) ).make_string(', ') log_msg = "{}({}) - execution time: {:.2f} ".format(f.__name__, arg_string, elapsed_time) return log_msg
def test_to_dict(self): res = seq([('a', 1), ('b', 2)]).to_dict() assert res == {'a': 1, 'b': 2} assert res.get(10) is None res = seq([('a', 1), ('b', 2)]).to_dict(5) assert res == {'a': 1, 'b': 2} assert res[10] == 5
def test_take(self): s = seq([1, 2, 3, 4, 5, 6]) expect = [1, 2, 3, 4] result = s.take(4) self.assertIteratorEqual(result, expect) self.assert_type(result) self.assertIteratorEqual(s.take(0), seq([])) self.assertIteratorEqual(s.take(-1), seq([]))
def test_last_option(self): l = seq([1, 2, 3]).map(lambda x: x) self.assertEqual(l.last_option(), 3) l = seq([1, 2, [3, 4]]).map(lambda x: x) self.assertEqual(l.last_option(), [3, 4]) self.assert_type(l.last_option()) l = seq([]) self.assertIsNone(l.last_option())
def test_head_option(self): l = seq([1, 2, 3]).map(lambda x: x) self.assertEqual(l.head_option(), 1) l = seq([[1, 2], 3, 4]).map(lambda x: x) self.assertEqual(l.head_option(), [1, 2]) self.assert_type(l.head_option()) l = seq([]) self.assertIsNone(l.head_option())
def test_sliding(self): l = seq([1, 2, 3, 4, 5, 6, 7]) expect = [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]] self.assertIteratorEqual(l.sliding(2), expect) l = seq([1, 2, 3]) expect = [[1, 2], [3]] self.assertIteratorEqual(l.sliding(2, 2), expect) expect = [[1, 2]] self.assertIteratorEqual(l.sliding(2, 3), expect)
def test_first(self): l = seq([1, 2, 3]).map(lambda x: x) self.assertEqual(l.first(), 1) l = seq([[1, 2], 3, 4]).map(lambda x: x) self.assertEqual(l.first(), [1, 2]) self.assert_type(l.first()) l = seq([]) with self.assertRaises(IndexError): l.head()
def consume_all(fileName): def foldHelp(acum,v): acum[v['title']] = v['text'] return acum with open("datafiles/fmeasure.json","w+") as out: out.write(jjson.dumps(seq(feedparser.parse(fileName).entries).map(process_text).fold_left({},foldHelp),indent=1)) with open("datafiles/inorder.txt","w+") as out: seq(feedparser.parse(fileName).entries).map(lambda e: out.write("%s\n"%e.title)).to_list()
def test_to_sqlite3_typerror(self): elements = [1, 2, 3] with sqlite3.connect(':memory:') as conn: conn.execute('CREATE TABLE user (id INT, name TEXT);') conn.commit() table_name = 'user' with self.assertRaises(TypeError): seq(elements).to_sqlite3(conn, table_name)
def remove_children_of(trie: Trie, keys): def delete_key(key): del trie[key] seq(keys) \ .filter(lambda key: key in trie) \ .flat_map(lambda key: trie.keys(prefix=key)) \ .filter(lambda key: key not in keys) \ .for_each(delete_key)
def test_zip(self): res = seq(1, 2, 3).zip([4, 5, 6]) assert res == [(1, 4), (2, 5), (3, 6)] res = seq(1, 2, 3).zip([4, 5]) assert res == [(1, 4), (2, 5)] res = seq(1, 2).zip([4, 5, 6]) assert res == [(1, 4), (2, 5)]
def test_product(self): l = [2, 2, 3] self.assertEqual(12, seq(l).product()) self.assertEqual(96, seq(l).product(lambda x: x * 2)) s = seq([]) self.assertEqual(1, s.product()) self.assertEqual(2, s.product(lambda x: x * 2)) s = seq([5]) self.assertEqual(5, s.product()) self.assertEqual(10, s.product(lambda x: x * 2))
def test_make_string(self): l = [1, 2, 3] expect1 = "123" expect2 = "1:2:3" s = seq(l) self.assertEqual(expect1, s.make_string("")) self.assertEqual(expect2, s.make_string(":")) s = seq([]) self.assertEqual("", s.make_string("")) self.assertEqual("", s.make_string(":"))
def test_to_jsonl(self): path = 'test.jsonl' seq(('a', 1), ('b', 2), ('c', 3)).to_jsonl(path) exp = _normalize(''' ["a", 1] ["b", 2] ["c", 3] ''') act = _normalize(_read_file(path)) assert exp == act
def test_to_sqlite3_tuples(self): conn = sqlite3.connect(':memory:') c = conn.cursor() c.execute('''CREATE TABLE demo (color TEXT, value REAL)''') conn.commit() seq(('red', 1), ('green', 2), ('blue', 3)).to_sqlite3(conn, 'INSERT INTO demo (color, value) VALUES (?, ?)') res = seq.sqlite3(conn, 'SELECT * FROM demo') assert res == [('red', 1), ('green', 2), ('blue', 3)]
def test_to_file_with_delim(self): path = 'test-w-delim.txt' seq(('a', 'b', 'c'), (11, 12, 13), (21, 22, 23)).to_file(path, delimiter='\n') exp = _normalize(''' ('a', 'b', 'c') (11, 12, 13) (21, 22, 23) ''') act = _normalize(_read_file(path)) assert exp == act
def test_cache(self): calls = [] func = lambda x: calls.append(x) result = seq(1, 2, 3).map(func).cache().map(lambda x: x).to_list() self.assertEqual(len(calls), 3) self.assertEqual(result, [None, None, None]) result = seq(1, 2, 3).map(lambda x: x).cache() self.assertEqual(repr(result._lineage), 'Lineage: sequence -> map(<lambda>) -> cache') result = seq(1, 2, 3).map(lambda x: x).cache(delete_lineage=True) self.assertEqual(repr(result._lineage), 'Lineage: sequence')
def test_to_csv(self): path = 'test.csv' seq(('a', 'b', 'c'), (11, 12, 13), (21, 22, 23)).to_csv(path) exp = _normalize(''' a,b,c 11,12,13 21,22,23 ''') act = _normalize(_read_file(path)) assert exp == act
def test_zip_with_index(self): l = [2, 3, 4] e = [(2, 0), (3, 1), (4, 2)] result = seq(l).zip_with_index() self.assertIteratorEqual(result, e) self.assert_type(result) e = [(2, 5), (3, 6), (4, 7)] result = seq(l).zip_with_index(5) self.assertIteratorEqual(result, e) self.assert_type(result)
def get_best(self, fit_too=False): fit, op = seq(self.pop.values()).map(lambda op: (op.best_fitness, op)).max_by(lambda tp: tp[0]) return (fit, op) if fit_too else op
(65, 17, 82), (66, 74, 67), (67, 10, 68), (68, 48, 19), (69, 83, 86), (70, 84, 94), ] clusters = seq(""" 1 1 15 29 43 57 -1 2 2 16 30 44 58 -1 3 3 17 31 45 59 -1 4 4 18 32 46 60 -1 5 5 19 33 47 61 -1 6 6 20 34 48 62 -1 7 7 21 35 49 63 -1 8 8 22 36 50 64 -1 9 9 23 37 51 65 -1 10 10 24 38 52 66 -1 11 11 25 39 53 67 -1 12 12 26 40 54 68 -1 13 13 27 41 55 69 -1 14 14 28 42 56 70 -1 """.strip().split('\n')).map(lambda row: seq(row.split()[1:-1]).map(int).map( lambda n: n - 1).to_set()).to_list() G = nx.Graph() G.add_nodes_from(range(len(node_cords)), weight=1) for u in range(len(node_cords)): for v in range(len(node_cords)): if u >= v: continue
def get_frame_with_lines(im: np.ndarray) -> Frame: scale = min(MAX_SIDE / im.shape[0], MAX_SIDE / im.shape[1]) resized = cv2.resize(im, (0, 0), fx=scale, fy=scale) if SHOW_OUTPUT: plt.imshow(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)) plt.show() gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) if SHOW_OUTPUT: plt.imshow(gray, 'gray') plt.show() gray = cv2.GaussianBlur(gray, ksize=(5, 5), sigmaX=0) # uses the above two partial derivatives sobelx = cv2.Sobel(gray, cv2.CV_16S, 1, 0, ksize=3) sobely = cv2.Sobel(gray, cv2.CV_16S, 0, 1, ksize=3) abs_gradientx = cv2.convertScaleAbs(sobelx) abs_gradienty = cv2.convertScaleAbs(sobely) # combine the two in equal proportions gray = cv2.addWeighted(abs_gradientx, 0.5, abs_gradienty, 0.5, 0) gray = cv2.GaussianBlur(gray, ksize=(5, 5), sigmaX=0) gray = cv2.Canny(gray, threshold1=0, threshold2=50, apertureSize=3) if SHOW_OUTPUT: plt.imshow(gray, 'gray') plt.show() lines = cv2.HoughLinesP(gray, rho=1, theta=np.pi / 180, threshold=80, minLineLength=100, maxLineGap=10) imres = None if SHOW_OUTPUT: im2 = resized.copy() for line in lines: cv2.line(im2, (line[0][0], line[0][1]), (line[0][2], line[0][3]), (0, 0, 255), 3) plt.imshow(cv2.cvtColor(im2, cv2.COLOR_BGR2RGB)) plt.show() imres = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB) intersections = get_intersections(lines) if SHOW_OUTPUT: im2 = resized.copy() for p in intersections: cv2.circle(im2, (int(p[0]), int(p[1])), 3, (0, 0, 255), -1) plt.imshow(cv2.cvtColor(im2, cv2.COLOR_BGR2RGB)) plt.show() intersections = simplify_intersections(intersections) if SHOW_OUTPUT: im2 = resized.copy() for p in intersections: cv2.circle(im2, (int(p[0]), int(p[1])), 3, (0, 0, 255), -1) plt.imshow(cv2.cvtColor(im2, cv2.COLOR_BGR2RGB)) plt.show() points = [(0., 0.), (0., 0.), (0., 0.), (0., 0.)] angle = 0 if len(intersections) > 4: points, angle = magic(intersections, im.shape[0] * scale, im.shape[1] * scale) if SHOW_OUTPUT: for p in points: cv2.circle(imres, (int(p[0]), int(p[1])), 3, (255, 0, 0), thickness=-1) if SHOW_OUTPUT: plt.imshow(imres) plt.show() # Undo scale points = (seq(points) .map(lambda point: (int(point[0] / scale), int(point[1] / scale))) .to_list()) return Frame(points, angle)
if j == 0: y = max(y, 0) elif j == current_m.shape[1] - 1: y = min(y, 0) if current_m[i + x, j + y] == -1: if next_m[i + x, j + y] == -1: next_m[i + x, j + y] = current_m[i, j] elif next_m[i + x, j + y] != current_m[i, j]: next_m[i + x, j + y] = -2 coords = [] with open('input.txt', 'r') as f: for line in f: coords.append(seq(line.strip().split(',')).map(int).to_list()) tlx = seq(coords).map(lambda c: c[0]).min() tly = seq(coords).map(lambda c: c[1]).min() brx = seq(coords).map(lambda c: c[0]).max() bry = seq(coords).map(lambda c: c[1]).max() width = brx - tlx + 1 height = bry - tly + 1 matrix = np.full((width, height), -1) for pos, coord in enumerate(coords): matrix[coord[0] - tlx, coord[1] - tly] = pos sol = grow_loop(matrix)
def get_fitlessness(self): """ Метод возвращает список всех хромосом (решений) в поколении, у которых нету фитнесс-функций :return: """ return seq(self.pop.values()).flat_map(lambda op: op.get_fitlessness()).to_list()
def showDataset(dataset, title, cols=10, figsize=(15, 15), y=0.6): showImages( seq(dataset).select(lambda data: data.image).to_list(), title, cols, figsize, y)
def has_pos(self, obj): return (seq(self.fields).map(partial(getattr, obj)).filter(self.has_pos_filter))
def total_tx_in_values(transaction, a_unspent_tx_outs): return seq(transaction['tx_ins'])\ .map(lambda tx_in : get_tx_in_amount(tx_in, a_unspent_tx_outs))\ .reduce(lambda a, b : (a + b), 0)
def has_valid_tx_ins(transaction, a_unspent_tx_outs): return seq(transaction['tx_ins'])\ .map(lambda tx_in : validate_tx_in(tx_in, transaction, a_unspent_tx_outs))\ .reduce(lambda a, b : a and b, True)
def get_consumed_tx_outs(new_transactions): return seq(new_transactions)\ .map(lambda t : t['tx_ins'])\ .reduce(lambda a, b : a + b, [])\ .map(lambda tx_in : new_unspent_tx_out(tx_in['tx_out_id'], tx_in['tx_out_index'], '',0))
def solve_cds_christofides(G, cds_fn, start=None, all_paths=None): cds = cds_fn(G) if not nx.is_dominating_set(G, cds) or \ not g_utils.is_connected_subset(G, cds): raise Exception('CDS fn did not return a valid CDS') # christofides # all pairs shortest dist graph (of original) if all_paths: pred, dist, path = all_paths else: pred, dist, path = g_utils.floyd_warshall_all(G) # construct CDS tree G_tree = g_utils.minimum_connected_subset_spanning_tree(G, cds) # get odd degree nodes in trees odd = seq(G_tree.nodes()) \ .filter(lambda n: G_tree.degree(n) % 2 == 1) \ .to_list() G_matching = nx.Graph() G_matching.add_nodes_from(odd) max_dist = 0 for a in odd: for b in odd: max_dist = max(max_dist, dist[a][b]) for a in odd: for b in odd: # invert weights to find *minimal* matching (+1 for nonzero) G_matching.add_edge(a, b, weight=1 + max_dist - dist[a][b]) match_edges = nx.max_weight_matching(G_matching) # eulerian multigraph G_euler = nx.MultiGraph(G_tree) for a, b in match_edges: G_euler.add_edge(a, b, weight=dist[a][b]) if not nx.is_eulerian(G_euler): raise Exception('New G_euler not eulerian') # All vertices now have even degree. We construct a eulerian tour. # This doesn't contain all the "bridge" vertices we need for the # added "indices". Hence it is called "stops" as in "tour stops" # rather than "tour". if len(cds) > 1: stops = seq(nx.eulerian_circuit(G_euler)) \ .map(lambda e: e[0]) \ .to_list() else: stops = list(cds) # singleton or empty # Add the starting point if it is not added already stops = g_utils.insert_start_into_stops(stops, dist, path, start) # TODO smart cutting short stops = g_utils.remove_dupes(stops) #print(stops) ### # remove extra from cds (connected dominating set) to make ds (dominating set) ds = set(cds) while True: can_remove = seq(ds) \ .filter(lambda n: n != start and nx.is_dominating_set(G, ds - set([ n ]))) \ .to_list() if not can_remove: break to_remove = seq(can_remove) \ .max_by(lambda n: G.nodes[n]['weight'] \ + dist[stops[stops.index(n) - 1]][n] + dist[n][stops[(stops.index(n) + 1) % len(stops)]] \ - dist[stops[stops.index(n) - 1]][stops[(stops.index(n) + 1) % len(stops)]]) # ) # print('removing ' + str(to_remove)) ds.remove(to_remove) stops.remove(to_remove) if len(stops) > 1: tour = seq(pairwise(stops + [ stops[0] ])) \ .flat_map(lambda e: path(e[0], e[1])) \ .to_list() else: tour = stops[:] return tour, ds
def cache_enum_type(self, enum_class): items = enum_class.__members__.items() self.cached_types[enum_class] = seq(items) \ .map(lambda t0: (t0[1], seq(items).map(lambda t1: 1 if t1[1] == t0[1] else 0).to_list())) \ .to_dict()
def _get_hash(cls, tokens, n): return HashFactory.get_hash( seq(tokens).take(n).order_by(lambda token: token.index).map( lambda token: token.token))
def run(self, obj): if not self.has_pos(obj): return print(obj.question_id) seq(self.fields).for_each(self.setfields(obj)) obj.save()
def assign_scaleset_role(onefuzz_instance_name: str, scaleset_name: str): """ Allows the nodes in the scaleset to access the service by assigning their managed identity to the ManagedNode Role """ onefuzz_service_appId = query_microsoft_graph( method="GET", resource="applications", params={ "$filter": "displayName eq '%s'" % onefuzz_instance_name, "$select": "appId", }, ) if len(onefuzz_service_appId["value"]) == 0: raise Exception("onefuzz app registration not found") appId = onefuzz_service_appId["value"][0]["appId"] onefuzz_service_principals = query_microsoft_graph( method="GET", resource="servicePrincipals", params={"$filter": "appId eq '%s'" % appId}, ) if len(onefuzz_service_principals["value"]) == 0: raise Exception("onefuzz app service principal not found") onefuzz_service_principal = onefuzz_service_principals["value"][0] scaleset_service_principals = query_microsoft_graph( method="GET", resource="servicePrincipals", params={"$filter": "displayName eq '%s'" % scaleset_name}, ) if len(scaleset_service_principals["value"]) == 0: raise Exception("scaleset service principal not found") scaleset_service_principal = scaleset_service_principals["value"][0] managed_node_role = (seq( onefuzz_service_principal["appRoles"]).filter(lambda x: x[ "value"] == OnefuzzAppRole.ManagedNode.value).head_option()) if not managed_node_role: raise Exception( "ManagedNode role not found int the onefuzz application registration. Please redeploy the instance" ) assignments = query_microsoft_graph( method="GET", resource="servicePrincipals/%s/appRoleAssignments" % scaleset_service_principal["id"], ) # check if the role is already assigned role_assigned = seq(assignments["value"]).find( lambda assignment: assignment["appRoleId"] == managed_node_role["id"]) if not role_assigned: query_microsoft_graph( method="POST", resource="servicePrincipals/%s/appRoleAssignedTo" % scaleset_service_principal["id"], body={ "principalId": scaleset_service_principal["id"], "resourceId": onefuzz_service_principal["id"], "appRoleId": managed_node_role["id"], }, )
def groupDataset(dataset): groups = seq(dataset).group_by(lambda data: data.label) return groups
def __init__(self, video_path: str): self.video_path = video_path self.files = (seq( os.listdir(video_path)).filter(lambda f: f.endswith('.jpg')).map( lambda p: os.path.join(video_path, p)).sorted().to_list())
alone.remove(claimId) else: innerMap[row] = {claim.claimId} def appendClaimToClaimMap(claimMap, alone, claim): for c in range(0, claim.colLen): for r in range(0, claim.rowLen): appendPositionToClaimMap(claimMap, alone, claim, claim.col + c, claim.row + r) claims = ( seq(sys.stdin).map( lambda line: line.rstrip()) # remove the newline that readlines keeps .filter(lambda line: claimRegex.match(line) ) # remove the newline that readlines keeps .map(lambda line: claimFromEncodedStr(line)).list( ) # save to a list, because multiple iterations of sys.stdin is not possible ) claimMap = {} alone = set() for claim in claims: alone.add(claim.claimId) for claim in claims: appendClaimToClaimMap(claimMap, alone, claim) numContestedClaims = 0 for c in claimMap: innerMap = claimMap[c]
def fed_forward(input_val: Sequence, network: Network) -> Sequence: init_feed = seq([(input_val, network.head())]) return network \ .tail() \ .fold_left(init_feed, lambda acc, x: fed_forward_acc_f(acc, x))
def tag_positions(tag_count: int): """Generates tag positions in QUIC message buffer.""" return seq(range(0, tag_count)).map(lambda tag_nr: 8 + tag_nr * 8)
def test_tabulate_namedtuple(self): sequence_tabulated = seq([Data(1, 2), Data(6, 7)]).tabulate() self.assertEqual(sequence_tabulated, ' x y\n--- ---\n 1 2\n 6 7')
def process_ocr_receipts(ocr_receipts): return seq(ocr_receipts) \ .map(lambda ocr_receipt: process_single_text_receipt(ocr_receipt)) \ .filter(None) \ .to_list()
# Customs questions from common import INPUT_DIR from functional import seq data = [] with open(f"{INPUT_DIR}\\6.txt") as f: data = f.read().strip() n = len(data) res = 0 for l in data.split("\n\n"): res += len( seq(l.split("\n")).map(lambda x: set(x)).reduce( lambda x, y: x.union(y))) print(res)
def deserialized(network_serialized: NetworkSerialized) -> Network: return seq(network_serialized).map(lambda x: layer.deserialized(x))
def total_tx_out_values(transaction): return seq(transaction['tx_outs'])\ .map(lambda tx_out : tx_out['amount'])\ .reduce(lambda a, b : (a + b), 0)
'1_shift_22050_-20', '1_shift_22050_40', '2', '2_noise_4', '2_noise_0.25', '2_shift_22050_-20', '2_shift_22050_40', '3', '3_noise_4', '3_noise_0.25', '3_shift_22050_-20', '3_shift_22050_40', ] data = { 'mfcc': seq(filenames).map(load_file).map(get_mfcc), 'denoised_mfcc': seq(filenames).map(load_file).map(denoise).map(get_mfcc), 'recording': seq(filenames).map(get_recording) 'denoised_recording': seq(filenames).map(denoise_dejavu).map(get_recording) } print('3') for input_type, inputs in data.items(): pairs = get_combinations(inputs) # NB! only select metrics compatible with the data result_lists = { f'{input_type}_cosine': seq(pairs).map(partial(apply_metric, cosine_dist)), f'{input_type}_dtw': seq(pairs).map(partial(apply_metric, dtw_dist)), f'{input_type}_split_dtw': seq(pairs).map(partial(apply_metric, split_dtw_dist)), f'{input_type}_dejavu': seq(pairs).map(partial(apply_metric, dejavu_similarity))
def _get_idf_values(movies_containing_word: Dict[str, int]) -> Dict[str, float]: print('_get_idf_values') movies = len(movies_containing_word) return seq(movies_containing_word.items()) \ .map(lambda item: (item[0], _get_idf_value(item[1], movies)))
def _load_words_by_movies(movies_loader) -> List[Set[str]]: print('_load_words_by_movies') return seq(movies_loader).map(_get_words_from_lines)
def run(self): ardProducts = {} with self.input().open('r') as CheckArdProductsFile: ardProducts = json.load(CheckArdProductsFile) # filesToConvert = list(filter(lambda x: os.path.splitext(x)[1] == '.kea', processRawToArdInfo['files'])) cogTasks = [] for p in ardProducts["products"]: cogTasks.append(CreateCOG(paths=self.paths, product=p, maxCogProcesses=self.maxCogProcesses, testProcessing=self.testProcessing)) yield cogTasks cogProducts = [] for task in cogTasks: with task.output().open('r') as cogInfo: cogProducts.append(json.load(cogInfo)) numFilesToConvert = seq(ardProducts["products"]) \ .map(lambda x: x["files"]) \ .flatten() \ .count(lambda x: os.path.splitext(x)[1] == '.kea') numCogProducts = seq(cogProducts) \ .map(lambda x: x["files"]) \ .flatten() \ .count(lambda x: os.path.splitext(x)[1] == '.tif') if not numFilesToConvert == numCogProducts: log.error("""The length of known files to convert to tif is not the same as the number of converted files, expected conversions for the files; Expected: {} Found: {} Missing: {}""".format(numFilesToConvert, numCogProducts, (numFilesToConvert - numCogProducts) ) ) raise RuntimeError("Not all files were converted from kea to tif files") if self.validateCogs: validateCogTasks = [] for p in cogProducts: validateCogTasks.append(ValidateCOG(paths=self.paths, product=p, maxCogProcesses=self.maxCogProcesses, validateCogScriptDir=self.validateCogScriptDir, testProcessing=self.testProcessing)) yield validateCogTasks output = { "outputDir": ardProducts["outputDir"], "products": cogProducts } with self.output().open('w') as o: json.dump(output, o, indent=4)
def sum_binaries(binaries: str): return (seq(iter(binaries)) .filter(lambda e: e == '1') .len()) # yapf: disable