sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:greedy_max_inden_setcover; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:candidate_sets_dict; 5, identifier:items; 6, default_parameter; 6, 7; 6, 8; 7, identifier:max_covers; 8, None; 9, block; 9, 10; 9, 17; 9, 23; 9, 29; 9, 33; 9, 152; 9, 159; 9, 166; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:uncovered_set; 13, call; 13, 14; 13, 15; 14, identifier:set; 15, argument_list; 15, 16; 16, identifier:items; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:rejected_keys; 20, call; 20, 21; 20, 22; 21, identifier:set; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:accepted_keys; 26, call; 26, 27; 26, 28; 27, identifier:set; 28, argument_list; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:covered_items_list; 32, list:[]; 33, while_statement; 33, 34; 33, 35; 34, True; 35, block; 35, 36; 35, 49; 35, 53; 35, 58; 35, 116; 35, 122; 35, 128; 35, 135; 35, 145; 36, if_statement; 36, 37; 36, 47; 37, boolean_operator:and; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:max_covers; 40, None; 41, comparison_operator:>=; 41, 42; 41, 46; 42, call; 42, 43; 42, 44; 43, identifier:len; 44, argument_list; 44, 45; 45, identifier:covered_items_list; 46, identifier:max_covers; 47, block; 47, 48; 48, break_statement; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:maxkey; 52, None; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:maxlen; 56, unary_operator:-; 56, 57; 57, integer:1; 58, for_statement; 58, 59; 58, 62; 58, 68; 59, pattern_list; 59, 60; 59, 61; 60, identifier:key; 61, identifier:candidate_items; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:six; 65, identifier:iteritems; 66, argument_list; 66, 67; 67, identifier:candidate_sets_dict; 68, block; 68, 69; 68, 79; 68, 86; 69, if_statement; 69, 70; 69, 77; 70, boolean_operator:or; 70, 71; 70, 74; 71, comparison_operator:in; 71, 72; 71, 73; 72, identifier:key; 73, identifier:rejected_keys; 74, comparison_operator:in; 74, 75; 74, 76; 75, identifier:key; 76, identifier:accepted_keys; 77, block; 77, 78; 78, continue_statement; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:lenval; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:candidate_items; 86, if_statement; 86, 87; 86, 93; 86, 107; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:uncovered_set; 90, identifier:issuperset; 91, argument_list; 91, 92; 92, identifier:candidate_items; 93, block; 93, 94; 94, if_statement; 94, 95; 94, 98; 95, comparison_operator:>; 95, 96; 95, 97; 96, identifier:lenval; 97, identifier:maxlen; 98, block; 98, 99; 98, 103; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:maxkey; 102, identifier:key; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:maxlen; 106, identifier:lenval; 107, else_clause; 107, 108; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:rejected_keys; 113, identifier:add; 114, argument_list; 114, 115; 115, identifier:key; 116, if_statement; 116, 117; 116, 120; 117, comparison_operator:is; 117, 118; 117, 119; 118, identifier:maxkey; 119, None; 120, block; 120, 121; 121, break_statement; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:maxval; 125, subscript; 125, 126; 125, 127; 126, identifier:candidate_sets_dict; 127, identifier:maxkey; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:accepted_keys; 132, identifier:add; 133, argument_list; 133, 134; 134, identifier:maxkey; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:covered_items_list; 139, identifier:append; 140, argument_list; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:list; 143, argument_list; 143, 144; 144, identifier:maxval; 145, expression_statement; 145, 146; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:uncovered_set; 149, identifier:difference_update; 150, argument_list; 150, 151; 151, identifier:maxval; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:uncovered_items; 155, call; 155, 156; 155, 157; 156, identifier:list; 157, argument_list; 157, 158; 158, identifier:uncovered_set; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:covertup; 162, expression_list; 162, 163; 162, 164; 162, 165; 163, identifier:uncovered_items; 164, identifier:covered_items_list; 165, identifier:accepted_keys; 166, return_statement; 166, 167; 167, identifier:covertup | def greedy_max_inden_setcover(candidate_sets_dict, items, max_covers=None):
uncovered_set = set(items)
rejected_keys = set()
accepted_keys = set()
covered_items_list = []
while True:
if max_covers is not None and len(covered_items_list) >= max_covers:
break
maxkey = None
maxlen = -1
for key, candidate_items in six.iteritems(candidate_sets_dict):
if key in rejected_keys or key in accepted_keys:
continue
lenval = len(candidate_items)
if uncovered_set.issuperset(candidate_items):
if lenval > maxlen:
maxkey = key
maxlen = lenval
else:
rejected_keys.add(key)
if maxkey is None:
break
maxval = candidate_sets_dict[maxkey]
accepted_keys.add(maxkey)
covered_items_list.append(list(maxval))
uncovered_set.difference_update(maxval)
uncovered_items = list(uncovered_set)
covertup = uncovered_items, covered_items_list, accepted_keys
return covertup |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:setcover_greedy; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:candidate_sets_dict; 5, default_parameter; 5, 6; 5, 7; 6, identifier:items; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:set_weights; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:item_values; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:max_weight; 16, None; 17, block; 17, 18; 17, 20; 17, 25; 17, 29; 17, 47; 17, 78; 17, 105; 17, 117; 17, 136; 17, 235; 18, expression_statement; 18, 19; 19, identifier:r; 20, import_statement; 20, 21; 21, aliased_import; 21, 22; 21, 24; 22, dotted_name; 22, 23; 23, identifier:utool; 24, identifier:ut; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:solution_cover; 28, dictionary; 29, if_statement; 29, 30; 29, 33; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:items; 32, None; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:items; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:ut; 40, identifier:flatten; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:candidate_sets_dict; 45, identifier:values; 46, argument_list; 47, if_statement; 47, 48; 47, 51; 47, 56; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:set_weights; 50, None; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:get_weight; 55, identifier:len; 56, else_clause; 56, 57; 57, block; 57, 58; 58, function_definition; 58, 59; 58, 60; 58, 62; 59, function_name:get_weight; 60, parameters; 60, 61; 61, identifier:solution_cover; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:sum; 66, argument_list; 66, 67; 67, list_comprehension; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:set_weights; 70, identifier:key; 71, for_in_clause; 71, 72; 71, 73; 72, identifier:key; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:solution_cover; 76, identifier:keys; 77, argument_list; 78, if_statement; 78, 79; 78, 82; 78, 87; 79, comparison_operator:is; 79, 80; 79, 81; 80, identifier:item_values; 81, None; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:get_value; 86, identifier:len; 87, else_clause; 87, 88; 88, block; 88, 89; 89, function_definition; 89, 90; 89, 91; 89, 93; 90, function_name:get_value; 91, parameters; 91, 92; 92, identifier:vals; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:sum; 97, argument_list; 97, 98; 98, list_comprehension; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:item_values; 101, identifier:v; 102, for_in_clause; 102, 103; 102, 104; 103, identifier:v; 104, identifier:vals; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:max_weight; 108, None; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:max_weight; 113, call; 113, 114; 113, 115; 114, identifier:get_weight; 115, argument_list; 115, 116; 116, identifier:candidate_sets_dict; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:avail_covers; 120, dictionary_comprehension; 120, 121; 120, 127; 121, pair; 121, 122; 121, 123; 122, identifier:key; 123, call; 123, 124; 123, 125; 124, identifier:set; 125, argument_list; 125, 126; 126, identifier:val; 127, for_in_clause; 127, 128; 127, 131; 128, pattern_list; 128, 129; 128, 130; 129, identifier:key; 130, identifier:val; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:candidate_sets_dict; 134, identifier:items; 135, argument_list; 136, while_statement; 136, 137; 136, 150; 137, boolean_operator:and; 137, 138; 137, 144; 138, comparison_operator:<; 138, 139; 138, 143; 139, call; 139, 140; 139, 141; 140, identifier:get_weight; 141, argument_list; 141, 142; 142, identifier:solution_cover; 143, identifier:max_weight; 144, comparison_operator:>; 144, 145; 144, 149; 145, call; 145, 146; 145, 147; 146, identifier:len; 147, argument_list; 147, 148; 148, identifier:avail_covers; 149, integer:0; 150, block; 150, 151; 150, 157; 150, 172; 150, 181; 150, 189; 150, 202; 150, 208; 150, 216; 150, 220; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:avail_covers; 155, identifier:values; 156, argument_list; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:uncovered_values; 160, call; 160, 161; 160, 162; 161, identifier:list; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 165; 164, identifier:map; 165, argument_list; 165, 166; 165, 167; 166, identifier:get_value; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:avail_covers; 170, identifier:values; 171, argument_list; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:chosen_idx; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:ut; 178, identifier:argmax; 179, argument_list; 179, 180; 180, identifier:uncovered_values; 181, if_statement; 181, 182; 181, 187; 182, comparison_operator:<=; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:uncovered_values; 185, identifier:chosen_idx; 186, integer:0; 187, block; 187, 188; 188, break_statement; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:chosen_key; 192, subscript; 192, 193; 192, 201; 193, call; 193, 194; 193, 195; 194, identifier:list; 195, argument_list; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:avail_covers; 199, identifier:keys; 200, argument_list; 201, identifier:chosen_idx; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:chosen_set; 205, subscript; 205, 206; 205, 207; 206, identifier:avail_covers; 207, identifier:chosen_key; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:solution_cover; 212, identifier:chosen_key; 213, subscript; 213, 214; 213, 215; 214, identifier:candidate_sets_dict; 215, identifier:chosen_key; 216, delete_statement; 216, 217; 217, subscript; 217, 218; 217, 219; 218, identifier:avail_covers; 219, identifier:chosen_key; 220, for_statement; 220, 221; 220, 222; 220, 227; 221, identifier:vals; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:avail_covers; 225, identifier:values; 226, argument_list; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:vals; 232, identifier:difference_update; 233, argument_list; 233, 234; 234, identifier:chosen_set; 235, return_statement; 235, 236; 236, identifier:solution_cover | def setcover_greedy(candidate_sets_dict, items=None, set_weights=None, item_values=None, max_weight=None):
r
import utool as ut
solution_cover = {}
if items is None:
items = ut.flatten(candidate_sets_dict.values())
if set_weights is None:
get_weight = len
else:
def get_weight(solution_cover):
sum([set_weights[key] for key in solution_cover.keys()])
if item_values is None:
get_value = len
else:
def get_value(vals):
sum([item_values[v] for v in vals])
if max_weight is None:
max_weight = get_weight(candidate_sets_dict)
avail_covers = {key: set(val) for key, val in candidate_sets_dict.items()}
while get_weight(solution_cover) < max_weight and len(avail_covers) > 0:
avail_covers.values()
uncovered_values = list(map(get_value, avail_covers.values()))
chosen_idx = ut.argmax(uncovered_values)
if uncovered_values[chosen_idx] <= 0:
break
chosen_key = list(avail_covers.keys())[chosen_idx]
chosen_set = avail_covers[chosen_key]
solution_cover[chosen_key] = candidate_sets_dict[chosen_key]
del avail_covers[chosen_key]
for vals in avail_covers.values():
vals.difference_update(chosen_set)
return solution_cover |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:get_nth_prime; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:n; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_prime; 7, integer:4100; 8, default_parameter; 8, 9; 8, 10; 9, identifier:safe; 10, True; 11, block; 11, 12; 11, 166; 12, if_statement; 12, 13; 12, 16; 12, 129; 13, comparison_operator:<=; 13, 14; 13, 15; 14, identifier:n; 15, integer:100; 16, block; 16, 17; 16, 121; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:first_100_primes; 20, tuple; 20, 21; 20, 22; 20, 23; 20, 24; 20, 25; 20, 26; 20, 27; 20, 28; 20, 29; 20, 30; 20, 31; 20, 32; 20, 33; 20, 34; 20, 35; 20, 36; 20, 37; 20, 38; 20, 39; 20, 40; 20, 41; 20, 42; 20, 43; 20, 44; 20, 45; 20, 46; 20, 47; 20, 48; 20, 49; 20, 50; 20, 51; 20, 52; 20, 53; 20, 54; 20, 55; 20, 56; 20, 57; 20, 58; 20, 59; 20, 60; 20, 61; 20, 62; 20, 63; 20, 64; 20, 65; 20, 66; 20, 67; 20, 68; 20, 69; 20, 70; 20, 71; 20, 72; 20, 73; 20, 74; 20, 75; 20, 76; 20, 77; 20, 78; 20, 79; 20, 80; 20, 81; 20, 82; 20, 83; 20, 84; 20, 85; 20, 86; 20, 87; 20, 88; 20, 89; 20, 90; 20, 91; 20, 92; 20, 93; 20, 94; 20, 95; 20, 96; 20, 97; 20, 98; 20, 99; 20, 100; 20, 101; 20, 102; 20, 103; 20, 104; 20, 105; 20, 106; 20, 107; 20, 108; 20, 109; 20, 110; 20, 111; 20, 112; 20, 113; 20, 114; 20, 115; 20, 116; 20, 117; 20, 118; 20, 119; 20, 120; 21, integer:2; 22, integer:3; 23, integer:5; 24, integer:7; 25, integer:11; 26, integer:13; 27, integer:17; 28, integer:19; 29, integer:23; 30, integer:29; 31, integer:31; 32, integer:37; 33, integer:41; 34, integer:43; 35, integer:47; 36, integer:53; 37, integer:59; 38, integer:61; 39, integer:67; 40, integer:71; 41, integer:73; 42, integer:79; 43, integer:83; 44, integer:89; 45, integer:97; 46, integer:101; 47, integer:103; 48, integer:107; 49, integer:109; 50, integer:113; 51, integer:127; 52, integer:131; 53, integer:137; 54, integer:139; 55, integer:149; 56, integer:151; 57, integer:157; 58, integer:163; 59, integer:167; 60, integer:173; 61, integer:179; 62, integer:181; 63, integer:191; 64, integer:193; 65, integer:197; 66, integer:199; 67, integer:211; 68, integer:223; 69, integer:227; 70, integer:229; 71, integer:233; 72, integer:239; 73, integer:241; 74, integer:251; 75, integer:257; 76, integer:263; 77, integer:269; 78, integer:271; 79, integer:277; 80, integer:281; 81, integer:283; 82, integer:293; 83, integer:307; 84, integer:311; 85, integer:313; 86, integer:317; 87, integer:331; 88, integer:337; 89, integer:347; 90, integer:349; 91, integer:353; 92, integer:359; 93, integer:367; 94, integer:373; 95, integer:379; 96, integer:383; 97, integer:389; 98, integer:397; 99, integer:401; 100, integer:409; 101, integer:419; 102, integer:421; 103, integer:431; 104, integer:433; 105, integer:439; 106, integer:443; 107, integer:449; 108, integer:457; 109, integer:461; 110, integer:463; 111, integer:467; 112, integer:479; 113, integer:487; 114, integer:491; 115, integer:499; 116, integer:503; 117, integer:509; 118, integer:521; 119, integer:523; 120, integer:541; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:nth_prime; 124, subscript; 124, 125; 124, 126; 125, identifier:first_100_primes; 126, binary_operator:-; 126, 127; 126, 128; 127, identifier:n; 128, integer:1; 129, else_clause; 129, 130; 130, block; 130, 131; 131, if_statement; 131, 132; 131, 133; 131, 157; 132, identifier:safe; 133, block; 133, 134; 133, 151; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:primes; 137, list_comprehension; 137, 138; 137, 139; 137, 146; 138, identifier:num; 139, for_in_clause; 139, 140; 139, 141; 140, identifier:num; 141, call; 141, 142; 141, 143; 142, identifier:range; 143, argument_list; 143, 144; 143, 145; 144, integer:2; 145, identifier:max_prime; 146, if_clause; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:is_prime; 149, argument_list; 149, 150; 150, identifier:num; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:nth_prime; 154, subscript; 154, 155; 154, 156; 155, identifier:primes; 156, identifier:n; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:nth_prime; 162, call; 162, 163; 162, 164; 163, identifier:get_nth_prime_bruteforce; 164, argument_list; 164, 165; 165, identifier:n; 166, return_statement; 166, 167; 167, identifier:nth_prime | def get_nth_prime(n, max_prime=4100, safe=True):
if n <= 100:
first_100_primes = (
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137,
139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277,
281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439,
443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521,
523, 541, )
nth_prime = first_100_primes[n - 1]
else:
if safe:
primes = [num for num in range(2, max_prime) if is_prime(num)]
nth_prime = primes[n]
else:
nth_prime = get_nth_prime_bruteforce(n)
return nth_prime |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:knapsack_ilp; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:items; 5, identifier:maxweight; 6, default_parameter; 6, 7; 6, 8; 7, identifier:verbose; 8, False; 9, block; 9, 10; 9, 13; 9, 23; 9, 33; 9, 43; 9, 55; 9, 82; 9, 104; 9, 129; 9, 140; 9, 152; 9, 171; 9, 187; 9, 234; 10, import_statement; 10, 11; 11, dotted_name; 11, 12; 12, identifier:pulp; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:values; 16, list_comprehension; 16, 17; 16, 20; 17, subscript; 17, 18; 17, 19; 18, identifier:t; 19, integer:0; 20, for_in_clause; 20, 21; 20, 22; 21, identifier:t; 22, identifier:items; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:weights; 26, list_comprehension; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:t; 29, integer:1; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:t; 32, identifier:items; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:indices; 36, list_comprehension; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:t; 39, integer:2; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:t; 42, identifier:items; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:prob; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:pulp; 49, identifier:LpProblem; 50, argument_list; 50, 51; 50, 52; 51, string:"Knapsack"; 52, attribute; 52, 53; 52, 54; 53, identifier:pulp; 54, identifier:LpMaximize; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:x; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:pulp; 62, identifier:LpVariable; 63, identifier:dicts; 64, argument_list; 64, 65; 64, 68; 64, 71; 64, 74; 64, 77; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:name; 67, string:'x'; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:indexs; 70, identifier:indices; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:lowBound; 73, integer:0; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:upBound; 76, integer:1; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:cat; 79, attribute; 79, 80; 79, 81; 80, identifier:pulp; 81, identifier:LpInteger; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:prob; 86, identifier:objective; 87, call; 87, 88; 87, 89; 88, identifier:sum; 89, generator_expression; 89, 90; 89, 95; 90, binary_operator:*; 90, 91; 90, 92; 91, identifier:v; 92, subscript; 92, 93; 92, 94; 93, identifier:x; 94, identifier:i; 95, for_in_clause; 95, 96; 95, 99; 96, pattern_list; 96, 97; 96, 98; 97, identifier:v; 98, identifier:i; 99, call; 99, 100; 99, 101; 100, identifier:zip; 101, argument_list; 101, 102; 101, 103; 102, identifier:values; 103, identifier:indices; 104, expression_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:prob; 108, identifier:add; 109, argument_list; 109, 110; 110, comparison_operator:<=; 110, 111; 110, 128; 111, call; 111, 112; 111, 113; 112, identifier:sum; 113, generator_expression; 113, 114; 113, 119; 114, binary_operator:*; 114, 115; 114, 116; 115, identifier:w; 116, subscript; 116, 117; 116, 118; 117, identifier:x; 118, identifier:i; 119, for_in_clause; 119, 120; 119, 123; 120, pattern_list; 120, 121; 120, 122; 121, identifier:w; 122, identifier:i; 123, call; 123, 124; 123, 125; 124, identifier:zip; 125, argument_list; 125, 126; 125, 127; 126, identifier:weights; 127, identifier:indices; 128, identifier:maxweight; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 138; 131, attribute; 131, 132; 131, 137; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:pulp; 135, identifier:PULP_CBC_CMD; 136, argument_list; 137, identifier:solve; 138, argument_list; 138, 139; 139, identifier:prob; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:flags; 143, list_comprehension; 143, 144; 143, 149; 144, attribute; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:x; 147, identifier:i; 148, identifier:varValue; 149, for_in_clause; 149, 150; 149, 151; 150, identifier:i; 151, identifier:indices; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:total_value; 155, call; 155, 156; 155, 157; 156, identifier:sum; 157, argument_list; 157, 158; 158, list_comprehension; 158, 159; 158, 160; 158, 169; 159, identifier:val; 160, for_in_clause; 160, 161; 160, 164; 161, pattern_list; 161, 162; 161, 163; 162, identifier:val; 163, identifier:flag; 164, call; 164, 165; 164, 166; 165, identifier:zip; 166, argument_list; 166, 167; 166, 168; 167, identifier:values; 168, identifier:flags; 169, if_clause; 169, 170; 170, identifier:flag; 171, expression_statement; 171, 172; 172, assignment; 172, 173; 172, 174; 173, identifier:items_subset; 174, list_comprehension; 174, 175; 174, 176; 174, 185; 175, identifier:item; 176, for_in_clause; 176, 177; 176, 180; 177, pattern_list; 177, 178; 177, 179; 178, identifier:item; 179, identifier:flag; 180, call; 180, 181; 180, 182; 181, identifier:zip; 182, argument_list; 182, 183; 182, 184; 183, identifier:items; 184, identifier:flags; 185, if_clause; 185, 186; 186, identifier:flag; 187, if_statement; 187, 188; 187, 189; 188, identifier:verbose; 189, block; 189, 190; 189, 195; 189, 200; 189, 226; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:print; 193, argument_list; 193, 194; 194, identifier:prob; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:print; 198, argument_list; 198, 199; 199, string:'OPT:'; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:print; 203, argument_list; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, string:'\n'; 207, identifier:join; 208, argument_list; 208, 209; 209, list_comprehension; 209, 210; 209, 223; 210, binary_operator:%; 210, 211; 210, 212; 211, string:' %s = %s'; 212, tuple; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:x; 216, identifier:i; 217, identifier:name; 218, attribute; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:x; 221, identifier:i; 222, identifier:varValue; 223, for_in_clause; 223, 224; 223, 225; 224, identifier:i; 225, identifier:indices; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 229; 228, identifier:print; 229, argument_list; 229, 230; 230, binary_operator:%; 230, 231; 230, 232; 231, string:'total_value = %r'; 232, tuple; 232, 233; 233, identifier:total_value; 234, return_statement; 234, 235; 235, expression_list; 235, 236; 235, 237; 236, identifier:total_value; 237, identifier:items_subset | def knapsack_ilp(items, maxweight, verbose=False):
import pulp
values = [t[0] for t in items]
weights = [t[1] for t in items]
indices = [t[2] for t in items]
prob = pulp.LpProblem("Knapsack", pulp.LpMaximize)
x = pulp.LpVariable.dicts(name='x', indexs=indices,
lowBound=0, upBound=1, cat=pulp.LpInteger)
prob.objective = sum(v * x[i] for v, i in zip(values, indices))
prob.add(sum(w * x[i] for w, i in zip(weights, indices)) <= maxweight)
pulp.PULP_CBC_CMD().solve(prob)
flags = [x[i].varValue for i in indices]
total_value = sum([val for val, flag in zip(values, flags) if flag])
items_subset = [item for item, flag in zip(items, flags) if flag]
if verbose:
print(prob)
print('OPT:')
print('\n'.join([' %s = %s' % (x[i].name, x[i].varValue) for i in indices]))
print('total_value = %r' % (total_value,))
return total_value, items_subset |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:knapsack_iterative_int; 3, parameters; 3, 4; 3, 5; 4, identifier:items; 5, identifier:maxweight; 6, block; 6, 7; 6, 9; 6, 19; 6, 29; 6, 35; 6, 49; 6, 61; 6, 65; 6, 80; 6, 203; 6, 207; 6, 242; 6, 249; 6, 259; 6, 272; 7, expression_statement; 7, 8; 8, identifier:r; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:values; 12, list_comprehension; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:t; 15, integer:0; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:t; 18, identifier:items; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:weights; 22, list_comprehension; 22, 23; 22, 26; 23, subscript; 23, 24; 23, 25; 24, identifier:t; 25, integer:1; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:t; 28, identifier:items; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:maxsize; 32, binary_operator:+; 32, 33; 32, 34; 33, identifier:maxweight; 34, integer:1; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:dpmat; 38, call; 38, 39; 38, 40; 39, identifier:defaultdict; 40, argument_list; 40, 41; 41, lambda; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:defaultdict; 44, argument_list; 44, 45; 45, lambda; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:np; 48, identifier:inf; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:kmat; 52, call; 52, 53; 52, 54; 53, identifier:defaultdict; 54, argument_list; 54, 55; 55, lambda; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:defaultdict; 58, argument_list; 58, 59; 59, lambda; 59, 60; 60, False; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:idx_subset; 64, list:[]; 65, for_statement; 65, 66; 65, 67; 65, 71; 66, identifier:w; 67, call; 67, 68; 67, 69; 68, identifier:range; 69, argument_list; 69, 70; 70, identifier:maxsize; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 79; 74, subscript; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:dpmat; 77, integer:0; 78, identifier:w; 79, integer:0; 80, for_statement; 80, 81; 80, 82; 80, 89; 81, identifier:idx; 82, call; 82, 83; 82, 84; 83, identifier:range; 84, argument_list; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:len; 87, argument_list; 87, 88; 88, identifier:items; 89, block; 89, 90; 89, 96; 89, 102; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:item_val; 93, subscript; 93, 94; 93, 95; 94, identifier:values; 95, identifier:idx; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:item_weight; 99, subscript; 99, 100; 99, 101; 100, identifier:weights; 101, identifier:idx; 102, for_statement; 102, 103; 102, 104; 102, 108; 103, identifier:w; 104, call; 104, 105; 104, 106; 105, identifier:range; 106, argument_list; 106, 107; 107, identifier:maxsize; 108, block; 108, 109; 108, 115; 108, 152; 108, 158; 108, 164; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:valid_item; 112, comparison_operator:<=; 112, 113; 112, 114; 113, identifier:item_weight; 114, identifier:w; 115, if_statement; 115, 116; 115, 119; 115, 142; 116, comparison_operator:>; 116, 117; 116, 118; 117, identifier:idx; 118, integer:0; 119, block; 119, 120; 119, 130; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:prev_val; 123, subscript; 123, 124; 123, 129; 124, subscript; 124, 125; 124, 126; 125, identifier:dpmat; 126, binary_operator:-; 126, 127; 126, 128; 127, identifier:idx; 128, integer:1; 129, identifier:w; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:prev_noitem_val; 133, subscript; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 136; 135, identifier:dpmat; 136, binary_operator:-; 136, 137; 136, 138; 137, identifier:idx; 138, integer:1; 139, binary_operator:-; 139, 140; 139, 141; 140, identifier:w; 141, identifier:item_weight; 142, else_clause; 142, 143; 143, block; 143, 144; 143, 148; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:prev_val; 147, integer:0; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:prev_noitem_val; 151, integer:0; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:withitem_val; 155, binary_operator:+; 155, 156; 155, 157; 156, identifier:item_val; 157, identifier:prev_noitem_val; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:more_valuable; 161, comparison_operator:>; 161, 162; 161, 163; 162, identifier:withitem_val; 163, identifier:prev_val; 164, if_statement; 164, 165; 164, 168; 164, 185; 165, boolean_operator:and; 165, 166; 165, 167; 166, identifier:valid_item; 167, identifier:more_valuable; 168, block; 168, 169; 168, 177; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 176; 171, subscript; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:dpmat; 174, identifier:idx; 175, identifier:w; 176, identifier:withitem_val; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 184; 179, subscript; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:kmat; 182, identifier:idx; 183, identifier:w; 184, True; 185, else_clause; 185, 186; 186, block; 186, 187; 186, 195; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 194; 189, subscript; 189, 190; 189, 193; 190, subscript; 190, 191; 190, 192; 191, identifier:dpmat; 192, identifier:idx; 193, identifier:w; 194, identifier:prev_val; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 202; 197, subscript; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:kmat; 200, identifier:idx; 201, identifier:w; 202, False; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:K; 206, identifier:maxweight; 207, for_statement; 207, 208; 207, 209; 207, 219; 208, identifier:idx; 209, call; 209, 210; 209, 211; 210, identifier:reversed; 211, argument_list; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:range; 214, argument_list; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:len; 217, argument_list; 217, 218; 218, identifier:items; 219, block; 219, 220; 220, if_statement; 220, 221; 220, 226; 221, subscript; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:kmat; 224, identifier:idx; 225, identifier:K; 226, block; 226, 227; 226, 234; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:idx_subset; 231, identifier:append; 232, argument_list; 232, 233; 233, identifier:idx; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 237; 236, identifier:K; 237, binary_operator:-; 237, 238; 237, 239; 238, identifier:K; 239, subscript; 239, 240; 239, 241; 240, identifier:weights; 241, identifier:idx; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:idx_subset; 245, call; 245, 246; 245, 247; 246, identifier:sorted; 247, argument_list; 247, 248; 248, identifier:idx_subset; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:items_subset; 252, list_comprehension; 252, 253; 252, 256; 253, subscript; 253, 254; 253, 255; 254, identifier:items; 255, identifier:i; 256, for_in_clause; 256, 257; 256, 258; 257, identifier:i; 258, identifier:idx_subset; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:total_value; 262, subscript; 262, 263; 262, 271; 263, subscript; 263, 264; 263, 265; 264, identifier:dpmat; 265, binary_operator:-; 265, 266; 265, 270; 266, call; 266, 267; 266, 268; 267, identifier:len; 268, argument_list; 268, 269; 269, identifier:items; 270, integer:1; 271, identifier:maxweight; 272, return_statement; 272, 273; 273, expression_list; 273, 274; 273, 275; 274, identifier:total_value; 275, identifier:items_subset | def knapsack_iterative_int(items, maxweight):
r
values = [t[0] for t in items]
weights = [t[1] for t in items]
maxsize = maxweight + 1
dpmat = defaultdict(lambda: defaultdict(lambda: np.inf))
kmat = defaultdict(lambda: defaultdict(lambda: False))
idx_subset = []
for w in range(maxsize):
dpmat[0][w] = 0
for idx in range(len(items)):
item_val = values[idx]
item_weight = weights[idx]
for w in range(maxsize):
valid_item = item_weight <= w
if idx > 0:
prev_val = dpmat[idx - 1][w]
prev_noitem_val = dpmat[idx - 1][w - item_weight]
else:
prev_val = 0
prev_noitem_val = 0
withitem_val = item_val + prev_noitem_val
more_valuable = withitem_val > prev_val
if valid_item and more_valuable:
dpmat[idx][w] = withitem_val
kmat[idx][w] = True
else:
dpmat[idx][w] = prev_val
kmat[idx][w] = False
K = maxweight
for idx in reversed(range(len(items))):
if kmat[idx][K]:
idx_subset.append(idx)
K = K - weights[idx]
idx_subset = sorted(idx_subset)
items_subset = [items[i] for i in idx_subset]
total_value = dpmat[len(items) - 1][maxweight]
return total_value, items_subset |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:knapsack_iterative_numpy; 3, parameters; 3, 4; 3, 5; 4, identifier:items; 5, identifier:maxweight; 6, block; 6, 7; 6, 16; 6, 24; 6, 38; 6, 44; 6, 58; 6, 66; 6, 75; 6, 81; 6, 98; 6, 118; 6, 122; 6, 137; 6, 235; 6, 239; 6, 274; 6, 281; 6, 291; 6, 304; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:items; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:np; 13, identifier:array; 14, argument_list; 14, 15; 15, identifier:items; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:weights; 19, subscript; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:items; 22, identifier:T; 23, integer:1; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:max_exp; 27, call; 27, 28; 27, 29; 28, identifier:max; 29, argument_list; 29, 30; 30, list_comprehension; 30, 31; 30, 35; 31, call; 31, 32; 31, 33; 32, identifier:number_of_decimals; 33, argument_list; 33, 34; 34, identifier:w_; 35, for_in_clause; 35, 36; 35, 37; 36, identifier:w_; 37, identifier:weights; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:coeff; 41, binary_operator:**; 41, 42; 41, 43; 42, integer:10; 43, identifier:max_exp; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:weights; 47, call; 47, 48; 47, 54; 48, attribute; 48, 49; 48, 53; 49, parenthesized_expression; 49, 50; 50, binary_operator:*; 50, 51; 50, 52; 51, identifier:weights; 52, identifier:coeff; 53, identifier:astype; 54, argument_list; 54, 55; 55, attribute; 55, 56; 55, 57; 56, identifier:np; 57, identifier:int; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:values; 61, subscript; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:items; 64, identifier:T; 65, integer:0; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:MAXWEIGHT; 69, call; 69, 70; 69, 71; 70, identifier:int; 71, argument_list; 71, 72; 72, binary_operator:*; 72, 73; 72, 74; 73, identifier:maxweight; 74, identifier:coeff; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:W_SIZE; 78, binary_operator:+; 78, 79; 78, 80; 79, identifier:MAXWEIGHT; 80, integer:1; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:dpmat; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:np; 87, identifier:full; 88, argument_list; 88, 89; 88, 95; 89, tuple; 89, 90; 89, 94; 90, call; 90, 91; 90, 92; 91, identifier:len; 92, argument_list; 92, 93; 93, identifier:items; 94, identifier:W_SIZE; 95, attribute; 95, 96; 95, 97; 96, identifier:np; 97, identifier:inf; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:kmat; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:np; 104, identifier:full; 105, argument_list; 105, 106; 105, 112; 105, 113; 106, tuple; 106, 107; 106, 111; 107, call; 107, 108; 107, 109; 108, identifier:len; 109, argument_list; 109, 110; 110, identifier:items; 111, identifier:W_SIZE; 112, integer:0; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:dtype; 115, attribute; 115, 116; 115, 117; 116, identifier:np; 117, identifier:bool; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:idx_subset; 121, list:[]; 122, for_statement; 122, 123; 122, 124; 122, 128; 123, identifier:w; 124, call; 124, 125; 124, 126; 125, identifier:range; 126, argument_list; 126, 127; 127, identifier:W_SIZE; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 136; 131, subscript; 131, 132; 131, 135; 132, subscript; 132, 133; 132, 134; 133, identifier:dpmat; 134, integer:0; 135, identifier:w; 136, integer:0; 137, for_statement; 137, 138; 137, 139; 137, 147; 138, identifier:idx; 139, call; 139, 140; 139, 141; 140, identifier:range; 141, argument_list; 141, 142; 141, 143; 142, integer:1; 143, call; 143, 144; 143, 145; 144, identifier:len; 145, argument_list; 145, 146; 146, identifier:items; 147, block; 147, 148; 147, 154; 147, 160; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:item_val; 151, subscript; 151, 152; 151, 153; 152, identifier:values; 153, identifier:idx; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:item_weight; 157, subscript; 157, 158; 157, 159; 158, identifier:weights; 159, identifier:idx; 160, for_statement; 160, 161; 160, 162; 160, 166; 161, identifier:w; 162, call; 162, 163; 162, 164; 163, identifier:range; 164, argument_list; 164, 165; 165, identifier:W_SIZE; 166, block; 166, 167; 166, 173; 166, 183; 166, 216; 166, 227; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:valid_item; 170, comparison_operator:<=; 170, 171; 170, 172; 171, identifier:item_weight; 172, identifier:w; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:prev_val; 176, subscript; 176, 177; 176, 182; 177, subscript; 177, 178; 177, 179; 178, identifier:dpmat; 179, binary_operator:-; 179, 180; 179, 181; 180, identifier:idx; 181, integer:1; 182, identifier:w; 183, if_statement; 183, 184; 183, 185; 183, 210; 184, identifier:valid_item; 185, block; 185, 186; 185, 198; 185, 204; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:prev_noitem_val; 189, subscript; 189, 190; 189, 195; 190, subscript; 190, 191; 190, 192; 191, identifier:dpmat; 192, binary_operator:-; 192, 193; 192, 194; 193, identifier:idx; 194, integer:1; 195, binary_operator:-; 195, 196; 195, 197; 196, identifier:w; 197, identifier:item_weight; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:withitem_val; 201, binary_operator:+; 201, 202; 201, 203; 202, identifier:item_val; 203, identifier:prev_noitem_val; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:more_valuable; 207, comparison_operator:>; 207, 208; 207, 209; 208, identifier:withitem_val; 209, identifier:prev_val; 210, else_clause; 210, 211; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:more_valuable; 215, False; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 223; 218, subscript; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:dpmat; 221, identifier:idx; 222, identifier:w; 223, conditional_expression:if; 223, 224; 223, 225; 223, 226; 224, identifier:withitem_val; 225, identifier:more_valuable; 226, identifier:prev_val; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 234; 229, subscript; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:kmat; 232, identifier:idx; 233, identifier:w; 234, identifier:more_valuable; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:K; 238, identifier:MAXWEIGHT; 239, for_statement; 239, 240; 239, 241; 239, 252; 240, identifier:idx; 241, call; 241, 242; 241, 243; 242, identifier:reversed; 243, argument_list; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:range; 246, argument_list; 246, 247; 246, 248; 247, integer:1; 248, call; 248, 249; 248, 250; 249, identifier:len; 250, argument_list; 250, 251; 251, identifier:items; 252, block; 252, 253; 253, if_statement; 253, 254; 253, 258; 254, subscript; 254, 255; 254, 256; 254, 257; 255, identifier:kmat; 256, identifier:idx; 257, identifier:K; 258, block; 258, 259; 258, 266; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:idx_subset; 263, identifier:append; 264, argument_list; 264, 265; 265, identifier:idx; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:K; 269, binary_operator:-; 269, 270; 269, 271; 270, identifier:K; 271, subscript; 271, 272; 271, 273; 272, identifier:weights; 273, identifier:idx; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:idx_subset; 277, call; 277, 278; 277, 279; 278, identifier:sorted; 279, argument_list; 279, 280; 280, identifier:idx_subset; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:items_subset; 284, list_comprehension; 284, 285; 284, 288; 285, subscript; 285, 286; 285, 287; 286, identifier:items; 287, identifier:i; 288, for_in_clause; 288, 289; 288, 290; 289, identifier:i; 290, identifier:idx_subset; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:total_value; 294, subscript; 294, 295; 294, 303; 295, subscript; 295, 296; 295, 297; 296, identifier:dpmat; 297, binary_operator:-; 297, 298; 297, 302; 298, call; 298, 299; 298, 300; 299, identifier:len; 300, argument_list; 300, 301; 301, identifier:items; 302, integer:1; 303, identifier:MAXWEIGHT; 304, return_statement; 304, 305; 305, expression_list; 305, 306; 305, 307; 306, identifier:total_value; 307, identifier:items_subset | def knapsack_iterative_numpy(items, maxweight):
items = np.array(items)
weights = items.T[1]
max_exp = max([number_of_decimals(w_) for w_ in weights])
coeff = 10 ** max_exp
weights = (weights * coeff).astype(np.int)
values = items.T[0]
MAXWEIGHT = int(maxweight * coeff)
W_SIZE = MAXWEIGHT + 1
dpmat = np.full((len(items), W_SIZE), np.inf)
kmat = np.full((len(items), W_SIZE), 0, dtype=np.bool)
idx_subset = []
for w in range(W_SIZE):
dpmat[0][w] = 0
for idx in range(1, len(items)):
item_val = values[idx]
item_weight = weights[idx]
for w in range(W_SIZE):
valid_item = item_weight <= w
prev_val = dpmat[idx - 1][w]
if valid_item:
prev_noitem_val = dpmat[idx - 1][w - item_weight]
withitem_val = item_val + prev_noitem_val
more_valuable = withitem_val > prev_val
else:
more_valuable = False
dpmat[idx][w] = withitem_val if more_valuable else prev_val
kmat[idx][w] = more_valuable
K = MAXWEIGHT
for idx in reversed(range(1, len(items))):
if kmat[idx, K]:
idx_subset.append(idx)
K = K - weights[idx]
idx_subset = sorted(idx_subset)
items_subset = [items[i] for i in idx_subset]
total_value = dpmat[len(items) - 1][MAXWEIGHT]
return total_value, items_subset |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:knapsack_greedy; 3, parameters; 3, 4; 3, 5; 4, identifier:items; 5, identifier:maxweight; 6, block; 6, 7; 6, 9; 6, 13; 6, 17; 6, 21; 6, 61; 7, expression_statement; 7, 8; 8, identifier:r; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:items_subset; 12, list:[]; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:total_weight; 16, integer:0; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:total_value; 20, integer:0; 21, for_statement; 21, 22; 21, 23; 21, 24; 22, identifier:item; 23, identifier:items; 24, block; 24, 25; 24, 36; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, pattern_list; 27, 28; 27, 29; 28, identifier:value; 29, identifier:weight; 30, subscript; 30, 31; 30, 32; 31, identifier:item; 32, slice; 32, 33; 32, 34; 32, 35; 33, integer:0; 34, colon; 35, integer:2; 36, if_statement; 36, 37; 36, 42; 36, 44; 37, comparison_operator:>; 37, 38; 37, 41; 38, binary_operator:+; 38, 39; 38, 40; 39, identifier:total_weight; 40, identifier:weight; 41, identifier:maxweight; 42, block; 42, 43; 43, continue_statement; 44, else_clause; 44, 45; 45, block; 45, 46; 45, 53; 45, 57; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:items_subset; 50, identifier:append; 51, argument_list; 51, 52; 52, identifier:item; 53, expression_statement; 53, 54; 54, augmented_assignment:+=; 54, 55; 54, 56; 55, identifier:total_weight; 56, identifier:weight; 57, expression_statement; 57, 58; 58, augmented_assignment:+=; 58, 59; 58, 60; 59, identifier:total_value; 60, identifier:value; 61, return_statement; 61, 62; 62, expression_list; 62, 63; 62, 64; 63, identifier:total_value; 64, identifier:items_subset | def knapsack_greedy(items, maxweight):
r
items_subset = []
total_weight = 0
total_value = 0
for item in items:
value, weight = item[0:2]
if total_weight + weight > maxweight:
continue
else:
items_subset.append(item)
total_weight += weight
total_value += value
return total_value, items_subset |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:ungroup_gen; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:grouped_items; 5, identifier:groupxs; 6, default_parameter; 6, 7; 6, 8; 7, identifier:fill; 8, None; 9, block; 9, 10; 9, 15; 9, 32; 9, 45; 9, 54; 9, 63; 9, 73; 9, 82; 9, 86; 9, 90; 9, 94; 9, 116; 9, 122; 9, 141; 10, import_statement; 10, 11; 11, aliased_import; 11, 12; 11, 14; 12, dotted_name; 12, 13; 13, identifier:utool; 14, identifier:ut; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:minpergroup; 18, list_comprehension; 18, 19; 18, 29; 19, conditional_expression:if; 19, 20; 19, 24; 19, 28; 20, call; 20, 21; 20, 22; 21, identifier:min; 22, argument_list; 22, 23; 23, identifier:xs; 24, call; 24, 25; 24, 26; 25, identifier:len; 26, argument_list; 26, 27; 27, identifier:xs; 28, integer:0; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:xs; 31, identifier:groupxs; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:minval; 35, conditional_expression:if; 35, 36; 35, 40; 35, 44; 36, call; 36, 37; 36, 38; 37, identifier:min; 38, argument_list; 38, 39; 39, identifier:minpergroup; 40, call; 40, 41; 40, 42; 41, identifier:len; 42, argument_list; 42, 43; 43, identifier:minpergroup; 44, integer:0; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:flat_groupx; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:ut; 51, identifier:flatten; 52, argument_list; 52, 53; 53, identifier:groupxs; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:sortx; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:ut; 60, identifier:argsort; 61, argument_list; 61, 62; 62, identifier:flat_groupx; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:groupx_sorted; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:ut; 69, identifier:take; 70, argument_list; 70, 71; 70, 72; 71, identifier:flat_groupx; 72, identifier:sortx; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:flat_items; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:ut; 79, identifier:iflatten; 80, argument_list; 80, 81; 81, identifier:grouped_items; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:toyeild; 85, dictionary; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:items_yeilded; 89, integer:0; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:current_index; 93, integer:0; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:num_fills_before; 97, binary_operator:+; 97, 98; 97, 114; 98, binary_operator:+; 98, 99; 98, 101; 99, list:[minval]; 99, 100; 100, identifier:minval; 101, call; 101, 102; 101, 113; 102, attribute; 102, 103; 102, 112; 103, parenthesized_expression; 103, 104; 104, binary_operator:-; 104, 105; 104, 111; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:np; 108, identifier:diff; 109, argument_list; 109, 110; 110, identifier:groupx_sorted; 111, integer:1; 112, identifier:tolist; 113, argument_list; 114, list:[0]; 114, 115; 115, integer:0; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:fills; 119, subscript; 119, 120; 119, 121; 120, identifier:num_fills_before; 121, identifier:items_yeilded; 122, if_statement; 122, 123; 122, 126; 123, comparison_operator:>; 123, 124; 123, 125; 124, identifier:fills; 125, integer:0; 126, block; 126, 127; 127, for_statement; 127, 128; 127, 129; 127, 133; 128, identifier:_; 129, call; 129, 130; 129, 131; 130, identifier:range; 131, argument_list; 131, 132; 132, identifier:fills; 133, block; 133, 134; 133, 137; 134, expression_statement; 134, 135; 135, yield; 135, 136; 136, None; 137, expression_statement; 137, 138; 138, augmented_assignment:+=; 138, 139; 138, 140; 139, identifier:current_index; 140, integer:1; 141, for_statement; 141, 142; 141, 145; 141, 150; 142, pattern_list; 142, 143; 142, 144; 143, identifier:yeild_at; 144, identifier:item; 145, call; 145, 146; 145, 147; 146, identifier:zip; 147, argument_list; 147, 148; 147, 149; 148, identifier:flat_groupx; 149, identifier:flat_items; 150, block; 150, 151; 151, if_statement; 151, 152; 151, 155; 151, 162; 152, comparison_operator:>; 152, 153; 152, 154; 153, identifier:yeild_at; 154, identifier:current_index; 155, block; 155, 156; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, subscript; 158, 159; 158, 160; 159, identifier:toyeild; 160, identifier:yeild_at; 161, identifier:item; 162, elif_clause; 162, 163; 162, 166; 163, comparison_operator:==; 163, 164; 163, 165; 164, identifier:yeild_at; 165, identifier:current_index; 166, block; 166, 167; 166, 170; 166, 174; 166, 178; 166, 184; 166, 203; 167, expression_statement; 167, 168; 168, yield; 168, 169; 169, identifier:item; 170, expression_statement; 170, 171; 171, augmented_assignment:+=; 171, 172; 171, 173; 172, identifier:current_index; 173, integer:1; 174, expression_statement; 174, 175; 175, augmented_assignment:+=; 175, 176; 175, 177; 176, identifier:items_yeilded; 177, integer:1; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:fills; 181, subscript; 181, 182; 181, 183; 182, identifier:num_fills_before; 183, identifier:items_yeilded; 184, if_statement; 184, 185; 184, 188; 185, comparison_operator:>; 185, 186; 185, 187; 186, identifier:fills; 187, integer:0; 188, block; 188, 189; 189, for_statement; 189, 190; 189, 191; 189, 195; 190, identifier:_; 191, call; 191, 192; 191, 193; 192, identifier:range; 193, argument_list; 193, 194; 194, identifier:fills; 195, block; 195, 196; 195, 199; 196, expression_statement; 196, 197; 197, yield; 197, 198; 198, None; 199, expression_statement; 199, 200; 200, augmented_assignment:+=; 200, 201; 200, 202; 201, identifier:current_index; 202, integer:1; 203, while_statement; 203, 204; 203, 207; 204, comparison_operator:in; 204, 205; 204, 206; 205, identifier:current_index; 206, identifier:toyeild; 207, block; 207, 208; 207, 217; 207, 220; 207, 224; 207, 228; 207, 234; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:item; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:toyeild; 214, identifier:pop; 215, argument_list; 215, 216; 216, identifier:current_index; 217, expression_statement; 217, 218; 218, yield; 218, 219; 219, identifier:item; 220, expression_statement; 220, 221; 221, augmented_assignment:+=; 221, 222; 221, 223; 222, identifier:current_index; 223, integer:1; 224, expression_statement; 224, 225; 225, augmented_assignment:+=; 225, 226; 225, 227; 226, identifier:items_yeilded; 227, integer:1; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:fills; 231, subscript; 231, 232; 231, 233; 232, identifier:num_fills_before; 233, identifier:items_yeilded; 234, if_statement; 234, 235; 234, 238; 235, comparison_operator:>; 235, 236; 235, 237; 236, identifier:fills; 237, integer:0; 238, block; 238, 239; 239, for_statement; 239, 240; 239, 241; 239, 245; 240, identifier:_; 241, call; 241, 242; 241, 243; 242, identifier:range; 243, argument_list; 243, 244; 244, identifier:fills; 245, block; 245, 246; 245, 249; 246, expression_statement; 246, 247; 247, yield; 247, 248; 248, None; 249, expression_statement; 249, 250; 250, augmented_assignment:+=; 250, 251; 250, 252; 251, identifier:current_index; 252, integer:1 | def ungroup_gen(grouped_items, groupxs, fill=None):
import utool as ut
minpergroup = [min(xs) if len(xs) else 0 for xs in groupxs]
minval = min(minpergroup) if len(minpergroup) else 0
flat_groupx = ut.flatten(groupxs)
sortx = ut.argsort(flat_groupx)
groupx_sorted = ut.take(flat_groupx, sortx)
flat_items = ut.iflatten(grouped_items)
toyeild = {}
items_yeilded = 0
current_index = 0
num_fills_before = [minval] + (np.diff(groupx_sorted) - 1).tolist() + [0]
fills = num_fills_before[items_yeilded]
if fills > 0:
for _ in range(fills):
yield None
current_index += 1
for yeild_at, item in zip(flat_groupx, flat_items):
if yeild_at > current_index:
toyeild[yeild_at] = item
elif yeild_at == current_index:
yield item
current_index += 1
items_yeilded += 1
fills = num_fills_before[items_yeilded]
if fills > 0:
for _ in range(fills):
yield None
current_index += 1
while current_index in toyeild:
item = toyeild.pop(current_index)
yield item
current_index += 1
items_yeilded += 1
fills = num_fills_before[items_yeilded]
if fills > 0:
for _ in range(fills):
yield None
current_index += 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:standardize_boolexpr; 3, parameters; 3, 4; 3, 5; 4, identifier:boolexpr_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:parens; 7, False; 8, block; 8, 9; 8, 11; 8, 16; 8, 19; 8, 23; 8, 34; 8, 45; 8, 56; 8, 67; 8, 78; 8, 96; 8, 108; 8, 117; 8, 138; 8, 148; 8, 158; 8, 184; 8, 196; 8, 202; 8, 208; 8, 225; 8, 242; 8, 283; 8, 396; 8, 410; 8, 428; 8, 437; 9, expression_statement; 9, 10; 10, identifier:r; 11, import_statement; 11, 12; 12, aliased_import; 12, 13; 12, 15; 13, dotted_name; 13, 14; 14, identifier:utool; 15, identifier:ut; 16, import_statement; 16, 17; 17, dotted_name; 17, 18; 18, identifier:re; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:onlyvars; 22, identifier:boolexpr_; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:onlyvars; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:re; 29, identifier:sub; 30, argument_list; 30, 31; 30, 32; 30, 33; 31, string:'\\bnot\\b'; 32, string:''; 33, identifier:onlyvars; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:onlyvars; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:re; 40, identifier:sub; 41, argument_list; 41, 42; 41, 43; 41, 44; 42, string:'\\band\\b'; 43, string:''; 44, identifier:onlyvars; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:onlyvars; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:re; 51, identifier:sub; 52, argument_list; 52, 53; 52, 54; 52, 55; 53, string:'\\bor\\b'; 54, string:''; 55, identifier:onlyvars; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:onlyvars; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:re; 62, identifier:sub; 63, argument_list; 63, 64; 63, 65; 63, 66; 64, string:'\\('; 65, string:''; 66, identifier:onlyvars; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:onlyvars; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:re; 73, identifier:sub; 74, argument_list; 74, 75; 74, 76; 74, 77; 75, string:'\\)'; 76, string:''; 77, identifier:onlyvars; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:varnames; 81, call; 81, 82; 81, 94; 82, attribute; 82, 83; 82, 93; 83, call; 83, 84; 83, 92; 84, attribute; 84, 85; 84, 91; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:ut; 88, identifier:remove_doublspaces; 89, argument_list; 89, 90; 90, identifier:onlyvars; 91, identifier:strip; 92, argument_list; 93, identifier:split; 94, argument_list; 94, 95; 95, string:' '; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:varied_dict; 99, dictionary_comprehension; 99, 100; 99, 105; 100, pair; 100, 101; 100, 102; 101, identifier:var; 102, list:[True, False]; 102, 103; 102, 104; 103, True; 104, False; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:var; 107, identifier:varnames; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:bool_states; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:ut; 114, identifier:all_dict_combinations; 115, argument_list; 115, 116; 116, identifier:varied_dict; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:outputs; 120, list_comprehension; 120, 121; 120, 135; 121, call; 121, 122; 121, 123; 122, identifier:eval; 123, argument_list; 123, 124; 123, 125; 123, 130; 124, identifier:boolexpr_; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:state; 128, identifier:copy; 129, argument_list; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:state; 133, identifier:copy; 134, argument_list; 135, for_in_clause; 135, 136; 135, 137; 136, identifier:state; 137, identifier:bool_states; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:true_states; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:ut; 144, identifier:compress; 145, argument_list; 145, 146; 145, 147; 146, identifier:bool_states; 147, identifier:outputs; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:true_tuples; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:ut; 154, identifier:take_column; 155, argument_list; 155, 156; 155, 157; 156, identifier:true_states; 157, identifier:varnames; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:true_cases; 161, list_comprehension; 161, 162; 161, 181; 162, call; 162, 163; 162, 164; 163, identifier:str; 164, argument_list; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, string:''; 168, identifier:join; 169, argument_list; 169, 170; 170, list_comprehension; 170, 171; 170, 178; 171, call; 171, 172; 171, 173; 172, identifier:str; 173, argument_list; 173, 174; 174, call; 174, 175; 174, 176; 175, identifier:int; 176, argument_list; 176, 177; 177, identifier:t; 178, for_in_clause; 178, 179; 178, 180; 179, identifier:t; 180, identifier:tup; 181, for_in_clause; 181, 182; 181, 183; 182, identifier:tup; 183, identifier:true_tuples; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:ones_bin; 187, list_comprehension; 187, 188; 187, 193; 188, call; 188, 189; 188, 190; 189, identifier:int; 190, argument_list; 190, 191; 190, 192; 191, identifier:x; 192, integer:2; 193, for_in_clause; 193, 194; 193, 195; 194, identifier:x; 195, identifier:true_cases; 196, import_from_statement; 196, 197; 196, 200; 197, dotted_name; 197, 198; 197, 199; 198, identifier:quine_mccluskey; 199, identifier:qm; 200, dotted_name; 200, 201; 201, identifier:QuineMcCluskey; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:qm; 205, call; 205, 206; 205, 207; 206, identifier:QuineMcCluskey; 207, argument_list; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:result; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:qm; 214, identifier:simplify; 215, argument_list; 215, 216; 215, 219; 216, keyword_argument; 216, 217; 216, 218; 217, identifier:ones; 218, identifier:ones_bin; 219, keyword_argument; 219, 220; 219, 221; 220, identifier:num_bits; 221, call; 221, 222; 221, 223; 222, identifier:len; 223, argument_list; 223, 224; 224, identifier:varnames; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:grouped_terms; 228, list_comprehension; 228, 229; 228, 239; 229, call; 229, 230; 229, 231; 230, identifier:dict; 231, argument_list; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:ut; 235, identifier:group_items; 236, argument_list; 236, 237; 236, 238; 237, identifier:varnames; 238, identifier:rs; 239, for_in_clause; 239, 240; 239, 241; 240, identifier:rs; 241, identifier:result; 242, function_definition; 242, 243; 242, 244; 242, 247; 243, function_name:parenjoin; 244, parameters; 244, 245; 244, 246; 245, identifier:char; 246, identifier:list_; 247, block; 247, 248; 248, if_statement; 248, 249; 248, 255; 248, 258; 249, comparison_operator:==; 249, 250; 249, 254; 250, call; 250, 251; 250, 252; 251, identifier:len; 252, argument_list; 252, 253; 253, identifier:list_; 254, integer:0; 255, block; 255, 256; 256, return_statement; 256, 257; 257, string:''; 258, else_clause; 258, 259; 259, block; 259, 260; 260, if_statement; 260, 261; 260, 262; 260, 274; 261, identifier:parens; 262, block; 262, 263; 263, return_statement; 263, 264; 264, binary_operator:+; 264, 265; 264, 273; 265, binary_operator:+; 265, 266; 265, 267; 266, string:'('; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:char; 270, identifier:join; 271, argument_list; 271, 272; 272, identifier:list_; 273, string:')'; 274, else_clause; 274, 275; 275, block; 275, 276; 276, return_statement; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:char; 280, identifier:join; 281, argument_list; 281, 282; 282, identifier:list_; 283, if_statement; 283, 284; 283, 285; 283, 341; 284, identifier:parens; 285, block; 285, 286; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:expanded_terms; 289, list_comprehension; 289, 290; 289, 338; 290, parenthesized_expression; 290, 291; 291, binary_operator:+; 291, 292; 291, 315; 292, binary_operator:+; 292, 293; 292, 300; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:term; 296, identifier:get; 297, argument_list; 297, 298; 297, 299; 298, string:'1'; 299, list:[]; 300, list_comprehension; 300, 301; 300, 306; 301, binary_operator:+; 301, 302; 301, 305; 302, binary_operator:+; 302, 303; 302, 304; 303, string:'(not '; 304, identifier:b; 305, string:')'; 306, for_in_clause; 306, 307; 306, 308; 307, identifier:b; 308, call; 308, 309; 308, 312; 309, attribute; 309, 310; 309, 311; 310, identifier:term; 311, identifier:get; 312, argument_list; 312, 313; 312, 314; 313, string:'0'; 314, list:[]; 315, list:[
parenjoin(' ^ ', term.get('^', [])),
parenjoin(' ~ ', term.get('~', [])),
]; 315, 316; 315, 327; 316, call; 316, 317; 316, 318; 317, identifier:parenjoin; 318, argument_list; 318, 319; 318, 320; 319, string:' ^ '; 320, call; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:term; 323, identifier:get; 324, argument_list; 324, 325; 324, 326; 325, string:'^'; 326, list:[]; 327, call; 327, 328; 327, 329; 328, identifier:parenjoin; 329, argument_list; 329, 330; 329, 331; 330, string:' ~ '; 331, call; 331, 332; 331, 335; 332, attribute; 332, 333; 332, 334; 333, identifier:term; 334, identifier:get; 335, argument_list; 335, 336; 335, 337; 336, string:'~'; 337, list:[]; 338, for_in_clause; 338, 339; 338, 340; 339, identifier:term; 340, identifier:grouped_terms; 341, else_clause; 341, 342; 342, block; 342, 343; 343, expression_statement; 343, 344; 344, assignment; 344, 345; 344, 346; 345, identifier:expanded_terms; 346, list_comprehension; 346, 347; 346, 393; 347, parenthesized_expression; 347, 348; 348, binary_operator:+; 348, 349; 348, 370; 349, binary_operator:+; 349, 350; 349, 357; 350, call; 350, 351; 350, 354; 351, attribute; 351, 352; 351, 353; 352, identifier:term; 353, identifier:get; 354, argument_list; 354, 355; 354, 356; 355, string:'1'; 356, list:[]; 357, list_comprehension; 357, 358; 357, 361; 358, binary_operator:+; 358, 359; 358, 360; 359, string:'not '; 360, identifier:b; 361, for_in_clause; 361, 362; 361, 363; 362, identifier:b; 363, call; 363, 364; 363, 367; 364, attribute; 364, 365; 364, 366; 365, identifier:term; 366, identifier:get; 367, argument_list; 367, 368; 367, 369; 368, string:'0'; 369, list:[]; 370, list:[
parenjoin(' ^ ', term.get('^', [])),
parenjoin(' ~ ', term.get('~', [])),
]; 370, 371; 370, 382; 371, call; 371, 372; 371, 373; 372, identifier:parenjoin; 373, argument_list; 373, 374; 373, 375; 374, string:' ^ '; 375, call; 375, 376; 375, 379; 376, attribute; 376, 377; 376, 378; 377, identifier:term; 378, identifier:get; 379, argument_list; 379, 380; 379, 381; 380, string:'^'; 381, list:[]; 382, call; 382, 383; 382, 384; 383, identifier:parenjoin; 384, argument_list; 384, 385; 384, 386; 385, string:' ~ '; 386, call; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, identifier:term; 389, identifier:get; 390, argument_list; 390, 391; 390, 392; 391, string:'~'; 392, list:[]; 393, for_in_clause; 393, 394; 393, 395; 394, identifier:term; 395, identifier:grouped_terms; 396, expression_statement; 396, 397; 397, assignment; 397, 398; 397, 399; 398, identifier:final_terms; 399, list_comprehension; 399, 400; 399, 407; 400, list_comprehension; 400, 401; 400, 402; 400, 405; 401, identifier:t; 402, for_in_clause; 402, 403; 402, 404; 403, identifier:t; 404, identifier:term; 405, if_clause; 405, 406; 406, identifier:t; 407, for_in_clause; 407, 408; 407, 409; 408, identifier:term; 409, identifier:expanded_terms; 410, expression_statement; 410, 411; 411, assignment; 411, 412; 411, 413; 412, identifier:products; 413, list_comprehension; 413, 414; 413, 425; 414, call; 414, 415; 414, 416; 415, identifier:parenjoin; 416, argument_list; 416, 417; 416, 418; 417, string:' and '; 418, list_comprehension; 418, 419; 418, 420; 418, 423; 419, identifier:f; 420, for_in_clause; 420, 421; 420, 422; 421, identifier:f; 422, identifier:form; 423, if_clause; 423, 424; 424, identifier:f; 425, for_in_clause; 425, 426; 425, 427; 426, identifier:form; 427, identifier:final_terms; 428, expression_statement; 428, 429; 429, assignment; 429, 430; 429, 431; 430, identifier:final_expr; 431, call; 431, 432; 431, 435; 432, attribute; 432, 433; 432, 434; 433, string:' or '; 434, identifier:join; 435, argument_list; 435, 436; 436, identifier:products; 437, return_statement; 437, 438; 438, identifier:final_expr | def standardize_boolexpr(boolexpr_, parens=False):
r
import utool as ut
import re
onlyvars = boolexpr_
onlyvars = re.sub('\\bnot\\b', '', onlyvars)
onlyvars = re.sub('\\band\\b', '', onlyvars)
onlyvars = re.sub('\\bor\\b', '', onlyvars)
onlyvars = re.sub('\\(', '', onlyvars)
onlyvars = re.sub('\\)', '', onlyvars)
varnames = ut.remove_doublspaces(onlyvars).strip().split(' ')
varied_dict = {var: [True, False] for var in varnames}
bool_states = ut.all_dict_combinations(varied_dict)
outputs = [eval(boolexpr_, state.copy(), state.copy()) for state in bool_states]
true_states = ut.compress(bool_states, outputs)
true_tuples = ut.take_column(true_states, varnames)
true_cases = [str(''.join([str(int(t)) for t in tup])) for tup in true_tuples]
ones_bin = [int(x, 2) for x in true_cases]
from quine_mccluskey.qm import QuineMcCluskey
qm = QuineMcCluskey()
result = qm.simplify(ones=ones_bin, num_bits=len(varnames))
grouped_terms = [dict(ut.group_items(varnames, rs)) for rs in result]
def parenjoin(char, list_):
if len(list_) == 0:
return ''
else:
if parens:
return '(' + char.join(list_) + ')'
else:
return char.join(list_)
if parens:
expanded_terms = [
(
term.get('1', []) +
['(not ' + b + ')' for b in term.get('0', [])] +
[
parenjoin(' ^ ', term.get('^', [])),
parenjoin(' ~ ', term.get('~', [])),
]
) for term in grouped_terms
]
else:
expanded_terms = [
(
term.get('1', []) +
['not ' + b for b in term.get('0', [])] +
[
parenjoin(' ^ ', term.get('^', [])),
parenjoin(' ~ ', term.get('~', [])),
]
) for term in grouped_terms
]
final_terms = [[t for t in term if t] for term in expanded_terms]
products = [parenjoin(' and ', [f for f in form if f]) for form in final_terms]
final_expr = ' or '.join(products)
return final_expr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:factors; 3, parameters; 3, 4; 4, identifier:n; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:set; 9, argument_list; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:reduce; 12, argument_list; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:list; 15, identifier:__add__; 16, generator_expression; 16, 17; 16, 22; 16, 36; 17, list:[i, n // i]; 17, 18; 17, 19; 18, identifier:i; 19, binary_operator://; 19, 20; 19, 21; 20, identifier:n; 21, identifier:i; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:i; 24, call; 24, 25; 24, 26; 25, identifier:range; 26, argument_list; 26, 27; 26, 28; 27, integer:1; 28, binary_operator:+; 28, 29; 28, 35; 29, call; 29, 30; 29, 31; 30, identifier:int; 31, argument_list; 31, 32; 32, binary_operator:**; 32, 33; 32, 34; 33, identifier:n; 34, float:0.5; 35, integer:1; 36, if_clause; 36, 37; 37, comparison_operator:==; 37, 38; 37, 41; 38, binary_operator:%; 38, 39; 38, 40; 39, identifier:n; 40, identifier:i; 41, integer:0 | def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:dict_stack; 3, parameters; 3, 4; 3, 5; 4, identifier:dict_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key_prefix; 7, string:''; 8, block; 8, 9; 8, 11; 8, 18; 8, 44; 8, 51; 9, expression_statement; 9, 10; 10, identifier:r; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:dict_stacked_; 14, call; 14, 15; 14, 16; 15, identifier:defaultdict; 16, argument_list; 16, 17; 17, identifier:list; 18, for_statement; 18, 19; 18, 20; 18, 21; 19, identifier:dict_; 20, identifier:dict_list; 21, block; 21, 22; 22, for_statement; 22, 23; 22, 26; 22, 32; 23, pattern_list; 23, 24; 23, 25; 24, identifier:key; 25, identifier:val; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:six; 29, identifier:iteritems; 30, argument_list; 30, 31; 31, identifier:dict_; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 42; 35, attribute; 35, 36; 35, 41; 36, subscript; 36, 37; 36, 38; 37, identifier:dict_stacked_; 38, binary_operator:+; 38, 39; 38, 40; 39, identifier:key_prefix; 40, identifier:key; 41, identifier:append; 42, argument_list; 42, 43; 43, identifier:val; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:dict_stacked; 47, call; 47, 48; 47, 49; 48, identifier:dict; 49, argument_list; 49, 50; 50, identifier:dict_stacked_; 51, return_statement; 51, 52; 52, identifier:dict_stacked | def dict_stack(dict_list, key_prefix=''):
r
dict_stacked_ = defaultdict(list)
for dict_ in dict_list:
for key, val in six.iteritems(dict_):
dict_stacked_[key_prefix + key].append(val)
dict_stacked = dict(dict_stacked_)
return dict_stacked |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:invert_dict; 3, parameters; 3, 4; 3, 5; 4, identifier:dict_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:unique_vals; 7, True; 8, block; 8, 9; 8, 57; 9, if_statement; 9, 10; 9, 11; 9, 39; 10, identifier:unique_vals; 11, block; 11, 12; 11, 29; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:inverted_items; 15, list_comprehension; 15, 16; 15, 19; 16, tuple; 16, 17; 16, 18; 17, identifier:val; 18, identifier:key; 19, for_in_clause; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:key; 22, identifier:val; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:six; 26, identifier:iteritems; 27, argument_list; 27, 28; 28, identifier:dict_; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:inverted_dict; 32, call; 32, 33; 32, 37; 33, call; 33, 34; 33, 35; 34, identifier:type; 35, argument_list; 35, 36; 36, identifier:dict_; 37, argument_list; 37, 38; 38, identifier:inverted_items; 39, else_clause; 39, 40; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:inverted_dict; 44, call; 44, 45; 44, 46; 45, identifier:group_items; 46, argument_list; 46, 47; 46, 52; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:dict_; 50, identifier:keys; 51, argument_list; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:dict_; 55, identifier:values; 56, argument_list; 57, return_statement; 57, 58; 58, identifier:inverted_dict | def invert_dict(dict_, unique_vals=True):
if unique_vals:
inverted_items = [(val, key) for key, val in six.iteritems(dict_)]
inverted_dict = type(dict_)(inverted_items)
else:
inverted_dict = group_items(dict_.keys(), dict_.values())
return inverted_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:all_dict_combinations_lbls; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:varied_dict; 5, default_parameter; 5, 6; 5, 7; 6, identifier:remove_singles; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:allow_lone_singles; 10, False; 11, block; 11, 12; 11, 41; 11, 105; 11, 118; 11, 148; 11, 171; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:is_lone_single; 15, call; 15, 16; 15, 17; 16, identifier:all; 17, argument_list; 17, 18; 18, list_comprehension; 18, 19; 18, 33; 19, boolean_operator:and; 19, 20; 19, 27; 20, call; 20, 21; 20, 22; 21, identifier:isinstance; 22, argument_list; 22, 23; 22, 24; 23, identifier:val_list; 24, tuple; 24, 25; 24, 26; 25, identifier:list; 26, identifier:tuple; 27, comparison_operator:==; 27, 28; 27, 32; 28, call; 28, 29; 28, 30; 29, identifier:len; 30, argument_list; 30, 31; 31, identifier:val_list; 32, integer:1; 33, for_in_clause; 33, 34; 33, 37; 34, pattern_list; 34, 35; 34, 36; 35, identifier:key; 36, identifier:val_list; 37, call; 37, 38; 37, 39; 38, identifier:iteritems_sorted; 39, argument_list; 39, 40; 40, identifier:varied_dict; 41, if_statement; 41, 42; 41, 49; 41, 69; 42, boolean_operator:or; 42, 43; 42, 45; 43, not_operator; 43, 44; 44, identifier:remove_singles; 45, parenthesized_expression; 45, 46; 46, boolean_operator:and; 46, 47; 46, 48; 47, identifier:allow_lone_singles; 48, identifier:is_lone_single; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:multitups_list; 53, list_comprehension; 53, 54; 53, 61; 54, list_comprehension; 54, 55; 54, 58; 55, tuple; 55, 56; 55, 57; 56, identifier:key; 57, identifier:val; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:val; 60, identifier:val_list; 61, for_in_clause; 61, 62; 61, 65; 62, pattern_list; 62, 63; 62, 64; 63, identifier:key; 64, identifier:val_list; 65, call; 65, 66; 65, 67; 66, identifier:iteritems_sorted; 67, argument_list; 67, 68; 68, identifier:varied_dict; 69, else_clause; 69, 70; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:multitups_list; 74, list_comprehension; 74, 75; 74, 82; 74, 90; 75, list_comprehension; 75, 76; 75, 79; 76, tuple; 76, 77; 76, 78; 77, identifier:key; 78, identifier:val; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:val; 81, identifier:val_list; 82, for_in_clause; 82, 83; 82, 86; 83, pattern_list; 83, 84; 83, 85; 84, identifier:key; 85, identifier:val_list; 86, call; 86, 87; 86, 88; 87, identifier:iteritems_sorted; 88, argument_list; 88, 89; 89, identifier:varied_dict; 90, if_clause; 90, 91; 91, boolean_operator:and; 91, 92; 91, 99; 92, call; 92, 93; 92, 94; 93, identifier:isinstance; 94, argument_list; 94, 95; 94, 96; 95, identifier:val_list; 96, tuple; 96, 97; 96, 98; 97, identifier:list; 98, identifier:tuple; 99, comparison_operator:>; 99, 100; 99, 104; 100, call; 100, 101; 100, 102; 101, identifier:len; 102, argument_list; 102, 103; 103, identifier:val_list; 104, integer:1; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:combtup_list; 108, call; 108, 109; 108, 110; 109, identifier:list; 110, argument_list; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:it; 114, identifier:product; 115, argument_list; 115, 116; 116, list_splat; 116, 117; 117, identifier:multitups_list; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:combtup_list2; 121, list_comprehension; 121, 122; 121, 145; 122, list_comprehension; 122, 123; 122, 140; 123, conditional_expression:if; 123, 124; 123, 127; 123, 134; 124, tuple; 124, 125; 124, 126; 125, identifier:key; 126, identifier:val; 127, call; 127, 128; 127, 129; 128, identifier:isinstance; 129, argument_list; 129, 130; 129, 131; 130, identifier:val; 131, attribute; 131, 132; 131, 133; 132, identifier:six; 133, identifier:string_types; 134, tuple; 134, 135; 134, 136; 135, identifier:key; 136, call; 136, 137; 136, 138; 137, identifier:repr; 138, argument_list; 138, 139; 139, identifier:val; 140, for_in_clause; 140, 141; 140, 144; 141, tuple_pattern; 141, 142; 141, 143; 142, identifier:key; 143, identifier:val; 144, identifier:combtup; 145, for_in_clause; 145, 146; 145, 147; 146, identifier:combtup; 147, identifier:combtup_list; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:comb_lbls; 151, list_comprehension; 151, 152; 151, 168; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, string:','; 155, identifier:join; 156, argument_list; 156, 157; 157, list_comprehension; 157, 158; 157, 163; 158, binary_operator:%; 158, 159; 158, 160; 159, string:'%s=%s'; 160, tuple; 160, 161; 160, 162; 161, identifier:key; 162, identifier:val; 163, for_in_clause; 163, 164; 163, 167; 164, tuple_pattern; 164, 165; 164, 166; 165, identifier:key; 166, identifier:val; 167, identifier:combtup; 168, for_in_clause; 168, 169; 168, 170; 169, identifier:combtup; 170, identifier:combtup_list2; 171, return_statement; 171, 172; 172, identifier:comb_lbls | def all_dict_combinations_lbls(varied_dict, remove_singles=True, allow_lone_singles=False):
is_lone_single = all([
isinstance(val_list, (list, tuple)) and len(val_list) == 1
for key, val_list in iteritems_sorted(varied_dict)
])
if not remove_singles or (allow_lone_singles and is_lone_single):
multitups_list = [
[(key, val) for val in val_list]
for key, val_list in iteritems_sorted(varied_dict)
]
else:
multitups_list = [
[(key, val) for val in val_list]
for key, val_list in iteritems_sorted(varied_dict)
if isinstance(val_list, (list, tuple)) and len(val_list) > 1]
combtup_list = list(it.product(*multitups_list))
combtup_list2 = [
[(key, val) if isinstance(val, six.string_types) else (key, repr(val))
for (key, val) in combtup]
for combtup in combtup_list]
comb_lbls = [','.join(['%s=%s' % (key, val) for (key, val) in combtup])
for combtup in combtup_list2]
return comb_lbls |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:update_existing; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:dict1; 5, identifier:dict2; 6, default_parameter; 6, 7; 6, 8; 7, identifier:copy; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:assert_exists; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:iswarning; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:alias_dict; 17, None; 18, block; 18, 19; 18, 21; 18, 61; 18, 71; 18, 80; 18, 112; 19, expression_statement; 19, 20; 20, identifier:r; 21, if_statement; 21, 22; 21, 23; 22, identifier:assert_exists; 23, block; 23, 24; 24, try_statement; 24, 25; 24, 32; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:assert_keys_are_subset; 29, argument_list; 29, 30; 29, 31; 30, identifier:dict1; 31, identifier:dict2; 32, except_clause; 32, 33; 32, 37; 33, as_pattern; 33, 34; 33, 35; 34, identifier:AssertionError; 35, as_pattern_target; 35, 36; 36, identifier:ex; 37, block; 37, 38; 37, 43; 37, 56; 38, import_from_statement; 38, 39; 38, 41; 39, dotted_name; 39, 40; 40, identifier:utool; 41, dotted_name; 41, 42; 42, identifier:util_dbg; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:util_dbg; 47, identifier:printex; 48, argument_list; 48, 49; 48, 50; 48, 53; 49, identifier:ex; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:iswarning; 52, identifier:iswarning; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:N; 55, integer:1; 56, if_statement; 56, 57; 56, 59; 57, not_operator; 57, 58; 58, identifier:iswarning; 59, block; 59, 60; 60, raise_statement; 61, if_statement; 61, 62; 61, 63; 62, identifier:copy; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:dict1; 67, call; 67, 68; 67, 69; 68, identifier:dict; 69, argument_list; 69, 70; 70, identifier:dict1; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:alias_dict; 74, None; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:alias_dict; 79, dictionary; 80, for_statement; 80, 81; 80, 84; 80, 90; 81, pattern_list; 81, 82; 81, 83; 82, identifier:key; 83, identifier:val; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:six; 87, identifier:iteritems; 88, argument_list; 88, 89; 89, identifier:dict2; 90, block; 90, 91; 90, 101; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:key; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:alias_dict; 97, identifier:get; 98, argument_list; 98, 99; 98, 100; 99, identifier:key; 100, identifier:key; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:in; 102, 103; 102, 104; 103, identifier:key; 104, identifier:dict1; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:dict1; 110, identifier:key; 111, identifier:val; 112, return_statement; 112, 113; 113, identifier:dict1 | def update_existing(dict1, dict2, copy=False, assert_exists=False,
iswarning=False, alias_dict=None):
r
if assert_exists:
try:
assert_keys_are_subset(dict1, dict2)
except AssertionError as ex:
from utool import util_dbg
util_dbg.printex(ex, iswarning=iswarning, N=1)
if not iswarning:
raise
if copy:
dict1 = dict(dict1)
if alias_dict is None:
alias_dict = {}
for key, val in six.iteritems(dict2):
key = alias_dict.get(key, key)
if key in dict1:
dict1[key] = val
return dict1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:groupby_tags; 3, parameters; 3, 4; 3, 5; 4, identifier:item_list; 5, identifier:tags_list; 6, block; 6, 7; 6, 9; 6, 16; 6, 39; 7, expression_statement; 7, 8; 8, identifier:r; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:groupid_to_items; 12, call; 12, 13; 12, 14; 13, identifier:defaultdict; 14, argument_list; 14, 15; 15, identifier:list; 16, for_statement; 16, 17; 16, 20; 16, 25; 17, pattern_list; 17, 18; 17, 19; 18, identifier:tags; 19, identifier:item; 20, call; 20, 21; 20, 22; 21, identifier:zip; 22, argument_list; 22, 23; 22, 24; 23, identifier:tags_list; 24, identifier:item_list; 25, block; 25, 26; 26, for_statement; 26, 27; 26, 28; 26, 29; 27, identifier:tag; 28, identifier:tags; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, subscript; 33, 34; 33, 35; 34, identifier:groupid_to_items; 35, identifier:tag; 36, identifier:append; 37, argument_list; 37, 38; 38, identifier:item; 39, return_statement; 39, 40; 40, identifier:groupid_to_items | def groupby_tags(item_list, tags_list):
r
groupid_to_items = defaultdict(list)
for tags, item in zip(tags_list, item_list):
for tag in tags:
groupid_to_items[tag].append(item)
return groupid_to_items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:group_items; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:items; 5, default_parameter; 5, 6; 5, 7; 6, identifier:by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sorted_; 10, True; 11, block; 11, 12; 11, 75; 11, 82; 11, 97; 12, if_statement; 12, 13; 12, 16; 12, 69; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:by; 15, None; 16, block; 16, 17; 16, 28; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:pairs; 20, call; 20, 21; 20, 22; 21, identifier:list; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:zip; 25, argument_list; 25, 26; 25, 27; 26, identifier:by; 27, identifier:items; 28, if_statement; 28, 29; 28, 30; 29, identifier:sorted_; 30, block; 30, 31; 31, try_statement; 31, 32; 31, 48; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:pairs; 36, call; 36, 37; 36, 38; 37, identifier:sorted; 38, argument_list; 38, 39; 38, 40; 39, identifier:pairs; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:key; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:op; 45, identifier:itemgetter; 46, argument_list; 46, 47; 47, integer:0; 48, except_clause; 48, 49; 48, 50; 49, identifier:TypeError; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:pairs; 54, call; 54, 55; 54, 56; 55, identifier:sorted; 56, argument_list; 56, 57; 56, 58; 57, identifier:pairs; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:key; 60, lambda; 60, 61; 60, 63; 61, lambda_parameters; 61, 62; 62, identifier:tup; 63, call; 63, 64; 63, 65; 64, identifier:str; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:tup; 68, integer:0; 69, else_clause; 69, 70; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:pairs; 74, identifier:items; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:groupid_to_items; 78, call; 78, 79; 78, 80; 79, identifier:defaultdict; 80, argument_list; 80, 81; 81, identifier:list; 82, for_statement; 82, 83; 82, 86; 82, 87; 83, pattern_list; 83, 84; 83, 85; 84, identifier:groupid; 85, identifier:item; 86, identifier:pairs; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 95; 90, attribute; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:groupid_to_items; 93, identifier:groupid; 94, identifier:append; 95, argument_list; 95, 96; 96, identifier:item; 97, return_statement; 97, 98; 98, identifier:groupid_to_items | def group_items(items, by=None, sorted_=True):
if by is not None:
pairs = list(zip(by, items))
if sorted_:
try:
pairs = sorted(pairs, key=op.itemgetter(0))
except TypeError:
pairs = sorted(pairs, key=lambda tup: str(tup[0]))
else:
pairs = items
groupid_to_items = defaultdict(list)
for groupid, item in pairs:
groupid_to_items[groupid].append(item)
return groupid_to_items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:hierarchical_map_vals; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:func; 5, identifier:node; 6, default_parameter; 6, 7; 6, 8; 7, identifier:max_depth; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:depth; 11, integer:0; 12, block; 12, 13; 13, if_statement; 13, 14; 13, 20; 13, 26; 13, 41; 14, not_operator; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:hasattr; 17, argument_list; 17, 18; 17, 19; 18, identifier:node; 19, string:'items'; 20, block; 20, 21; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:func; 24, argument_list; 24, 25; 25, identifier:node; 26, elif_clause; 26, 27; 26, 34; 27, boolean_operator:and; 27, 28; 27, 31; 28, comparison_operator:is; 28, 29; 28, 30; 29, identifier:max_depth; 30, None; 31, comparison_operator:>=; 31, 32; 31, 33; 32, identifier:depth; 33, identifier:max_depth; 34, block; 34, 35; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:map_dict_vals; 38, argument_list; 38, 39; 38, 40; 39, identifier:func; 40, identifier:node; 41, else_clause; 41, 42; 42, block; 42, 43; 42, 67; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:keyval_list; 46, list_comprehension; 46, 47; 46, 58; 47, tuple; 47, 48; 47, 49; 48, identifier:key; 49, call; 49, 50; 49, 51; 50, identifier:hierarchical_map_vals; 51, argument_list; 51, 52; 51, 53; 51, 54; 51, 55; 52, identifier:func; 53, identifier:val; 54, identifier:max_depth; 55, binary_operator:+; 55, 56; 55, 57; 56, identifier:depth; 57, integer:1; 58, for_in_clause; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:key; 61, identifier:val; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:node; 65, identifier:items; 66, argument_list; 67, if_statement; 67, 68; 67, 73; 67, 79; 68, call; 68, 69; 68, 70; 69, identifier:isinstance; 70, argument_list; 70, 71; 70, 72; 71, identifier:node; 72, identifier:OrderedDict; 73, block; 73, 74; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:OrderedDict; 77, argument_list; 77, 78; 78, identifier:keyval_list; 79, else_clause; 79, 80; 80, block; 80, 81; 81, return_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:dict; 84, argument_list; 84, 85; 85, identifier:keyval_list | def hierarchical_map_vals(func, node, max_depth=None, depth=0):
if not hasattr(node, 'items'):
return func(node)
elif max_depth is not None and depth >= max_depth:
return map_dict_vals(func, node)
else:
keyval_list = [(key, hierarchical_map_vals(func, val, max_depth, depth + 1)) for key, val in node.items()]
if isinstance(node, OrderedDict):
return OrderedDict(keyval_list)
else:
return dict(keyval_list) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sort_dict; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:dict_; 5, default_parameter; 5, 6; 5, 7; 6, identifier:part; 7, string:'keys'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:key; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:reverse; 13, False; 14, block; 14, 15; 14, 45; 14, 73; 14, 91; 14, 98; 15, if_statement; 15, 16; 15, 19; 15, 24; 15, 35; 16, comparison_operator:==; 16, 17; 16, 18; 17, identifier:part; 18, string:'keys'; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:index; 23, integer:0; 24, elif_clause; 24, 25; 24, 30; 25, comparison_operator:in; 25, 26; 25, 27; 26, identifier:part; 27, set; 27, 28; 27, 29; 28, string:'vals'; 29, string:'values'; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:index; 34, integer:1; 35, else_clause; 35, 36; 36, block; 36, 37; 37, raise_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:ValueError; 40, argument_list; 40, 41; 41, binary_operator:%; 41, 42; 41, 43; 42, string:'Unknown method part=%r'; 43, tuple; 43, 44; 44, identifier:part; 45, if_statement; 45, 46; 45, 49; 45, 59; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:key; 48, None; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:_key; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:op; 56, identifier:itemgetter; 57, argument_list; 57, 58; 58, identifier:index; 59, else_clause; 59, 60; 60, block; 60, 61; 61, function_definition; 61, 62; 61, 63; 61, 65; 62, function_name:_key; 63, parameters; 63, 64; 64, identifier:item; 65, block; 65, 66; 66, return_statement; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:key; 69, argument_list; 69, 70; 70, subscript; 70, 71; 70, 72; 71, identifier:item; 72, identifier:index; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:sorted_items; 76, call; 76, 77; 76, 78; 77, identifier:sorted; 78, argument_list; 78, 79; 78, 85; 78, 88; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:six; 82, identifier:iteritems; 83, argument_list; 83, 84; 84, identifier:dict_; 85, keyword_argument; 85, 86; 85, 87; 86, identifier:key; 87, identifier:_key; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:reverse; 90, identifier:reverse; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:sorted_dict; 94, call; 94, 95; 94, 96; 95, identifier:OrderedDict; 96, argument_list; 96, 97; 97, identifier:sorted_items; 98, return_statement; 98, 99; 99, identifier:sorted_dict | def sort_dict(dict_, part='keys', key=None, reverse=False):
if part == 'keys':
index = 0
elif part in {'vals', 'values'}:
index = 1
else:
raise ValueError('Unknown method part=%r' % (part,))
if key is None:
_key = op.itemgetter(index)
else:
def _key(item):
return key(item[index])
sorted_items = sorted(six.iteritems(dict_), key=_key, reverse=reverse)
sorted_dict = OrderedDict(sorted_items)
return sorted_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:order_dict_by; 3, parameters; 3, 4; 3, 5; 4, identifier:dict_; 5, identifier:key_order; 6, block; 6, 7; 6, 9; 6, 20; 6, 29; 6, 39; 6, 57; 7, expression_statement; 7, 8; 8, identifier:r; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:dict_keys; 12, call; 12, 13; 12, 14; 13, identifier:set; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:dict_; 18, identifier:keys; 19, argument_list; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:other_keys; 23, binary_operator:-; 23, 24; 23, 25; 24, identifier:dict_keys; 25, call; 25, 26; 25, 27; 26, identifier:set; 27, argument_list; 27, 28; 28, identifier:key_order; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:key_order; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:it; 35, identifier:chain; 36, argument_list; 36, 37; 36, 38; 37, identifier:key_order; 38, identifier:other_keys; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:sorted_dict; 42, call; 42, 43; 42, 44; 43, identifier:OrderedDict; 44, generator_expression; 44, 45; 44, 50; 44, 53; 45, tuple; 45, 46; 45, 47; 46, identifier:key; 47, subscript; 47, 48; 47, 49; 48, identifier:dict_; 49, identifier:key; 50, for_in_clause; 50, 51; 50, 52; 51, identifier:key; 52, identifier:key_order; 53, if_clause; 53, 54; 54, comparison_operator:in; 54, 55; 54, 56; 55, identifier:key; 56, identifier:dict_keys; 57, return_statement; 57, 58; 58, identifier:sorted_dict | def order_dict_by(dict_, key_order):
r
dict_keys = set(dict_.keys())
other_keys = dict_keys - set(key_order)
key_order = it.chain(key_order, other_keys)
sorted_dict = OrderedDict(
(key, dict_[key]) for key in key_order if key in dict_keys
)
return sorted_dict |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:iteritems_sorted; 3, parameters; 3, 4; 4, identifier:dict_; 5, block; 5, 6; 6, if_statement; 6, 7; 6, 12; 6, 20; 7, call; 7, 8; 7, 9; 8, identifier:isinstance; 9, argument_list; 9, 10; 9, 11; 10, identifier:dict_; 11, identifier:OrderedDict; 12, block; 12, 13; 13, return_statement; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:six; 17, identifier:iteritems; 18, argument_list; 18, 19; 19, identifier:dict_; 20, else_clause; 20, 21; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:iter; 25, argument_list; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:sorted; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:six; 32, identifier:iteritems; 33, argument_list; 33, 34; 34, identifier:dict_ | def iteritems_sorted(dict_):
if isinstance(dict_, OrderedDict):
return six.iteritems(dict_)
else:
return iter(sorted(six.iteritems(dict_))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:num_fmt; 3, parameters; 3, 4; 3, 5; 4, identifier:num; 5, default_parameter; 5, 6; 5, 7; 6, identifier:max_digits; 7, None; 8, block; 8, 9; 8, 11; 8, 18; 8, 36; 8, 71; 9, expression_statement; 9, 10; 10, identifier:r; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:num; 14, None; 15, block; 15, 16; 16, return_statement; 16, 17; 17, string:'None'; 18, function_definition; 18, 19; 18, 20; 18, 23; 19, function_name:num_in_mag; 20, parameters; 20, 21; 20, 22; 21, identifier:num; 22, identifier:mag; 23, block; 23, 24; 24, return_statement; 24, 25; 25, boolean_operator:and; 25, 26; 25, 29; 26, comparison_operator:>; 26, 27; 26, 28; 27, identifier:mag; 28, identifier:num; 29, comparison_operator:>; 29, 30; 29, 31; 30, identifier:num; 31, parenthesized_expression; 31, 32; 32, binary_operator:*; 32, 33; 32, 35; 33, unary_operator:-; 33, 34; 34, integer:1; 35, identifier:mag; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:max_digits; 39, None; 40, block; 40, 41; 41, if_statement; 41, 42; 41, 47; 41, 65; 42, call; 42, 43; 42, 44; 43, identifier:num_in_mag; 44, argument_list; 44, 45; 44, 46; 45, identifier:num; 46, integer:1; 47, block; 47, 48; 48, if_statement; 48, 49; 48, 54; 48, 59; 49, call; 49, 50; 49, 51; 50, identifier:num_in_mag; 51, argument_list; 51, 52; 51, 53; 52, identifier:num; 53, float:.1; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:max_digits; 58, integer:4; 59, else_clause; 59, 60; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:max_digits; 64, integer:3; 65, else_clause; 65, 66; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:max_digits; 70, integer:1; 71, if_statement; 71, 72; 71, 78; 71, 137; 71, 150; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:util_type; 75, identifier:is_float; 76, argument_list; 76, 77; 77, identifier:num; 78, block; 78, 79; 78, 93; 78, 107; 78, 121; 78, 135; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:num_str; 82, binary_operator:%; 82, 83; 82, 92; 83, parenthesized_expression; 83, 84; 84, binary_operator:+; 84, 85; 84, 91; 85, binary_operator:+; 85, 86; 85, 87; 86, string:'%.'; 87, call; 87, 88; 87, 89; 88, identifier:str; 89, argument_list; 89, 90; 90, identifier:max_digits; 91, string:'f'; 92, identifier:num; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:num_str; 96, call; 96, 97; 96, 105; 97, attribute; 97, 98; 97, 104; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:num_str; 101, identifier:rstrip; 102, argument_list; 102, 103; 103, string:'0'; 104, identifier:lstrip; 105, argument_list; 105, 106; 106, string:'0'; 107, if_statement; 107, 108; 107, 114; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:num_str; 111, identifier:startswith; 112, argument_list; 112, 113; 113, string:'.'; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:num_str; 118, binary_operator:+; 118, 119; 118, 120; 119, string:'0'; 120, identifier:num_str; 121, if_statement; 121, 122; 121, 128; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:num_str; 125, identifier:endswith; 126, argument_list; 126, 127; 127, string:'.'; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:num_str; 132, binary_operator:+; 132, 133; 132, 134; 133, identifier:num_str; 134, string:'0'; 135, return_statement; 135, 136; 136, identifier:num_str; 137, elif_clause; 137, 138; 137, 144; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:util_type; 141, identifier:is_int; 142, argument_list; 142, 143; 143, identifier:num; 144, block; 144, 145; 145, return_statement; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:int_comma_str; 148, argument_list; 148, 149; 149, identifier:num; 150, else_clause; 150, 151; 151, block; 151, 152; 152, return_statement; 152, 153; 153, string:'%r' | def num_fmt(num, max_digits=None):
r
if num is None:
return 'None'
def num_in_mag(num, mag):
return mag > num and num > (-1 * mag)
if max_digits is None:
if num_in_mag(num, 1):
if num_in_mag(num, .1):
max_digits = 4
else:
max_digits = 3
else:
max_digits = 1
if util_type.is_float(num):
num_str = ('%.' + str(max_digits) + 'f') % num
num_str = num_str.rstrip('0').lstrip('0')
if num_str.startswith('.'):
num_str = '0' + num_str
if num_str.endswith('.'):
num_str = num_str + '0'
return num_str
elif util_type.is_int(num):
return int_comma_str(num)
else:
return '%r' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:inject_print_functions; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:module_name; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:module_prefix; 9, string:'[???]'; 10, default_parameter; 10, 11; 10, 12; 11, identifier:DEBUG; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:module; 15, None; 16, block; 16, 17; 16, 25; 16, 323; 16, 330; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:module; 20, call; 20, 21; 20, 22; 21, identifier:_get_module; 22, argument_list; 22, 23; 22, 24; 23, identifier:module_name; 24, identifier:module; 25, if_statement; 25, 26; 25, 27; 25, 49; 26, identifier:SILENT; 27, block; 27, 28; 27, 35; 27, 42; 28, function_definition; 28, 29; 28, 30; 28, 33; 29, function_name:print; 30, parameters; 30, 31; 31, list_splat_pattern; 31, 32; 32, identifier:args; 33, block; 33, 34; 34, pass_statement; 35, function_definition; 35, 36; 35, 37; 35, 40; 36, function_name:printDBG; 37, parameters; 37, 38; 38, list_splat_pattern; 38, 39; 39, identifier:args; 40, block; 40, 41; 41, pass_statement; 42, function_definition; 42, 43; 42, 44; 42, 47; 43, function_name:print_; 44, parameters; 44, 45; 45, list_splat_pattern; 45, 46; 46, identifier:args; 47, block; 47, 48; 48, pass_statement; 49, else_clause; 49, 50; 50, block; 50, 51; 50, 113; 50, 158; 50, 169; 50, 195; 50, 220; 50, 229; 50, 238; 50, 255; 50, 268; 51, if_statement; 51, 52; 51, 53; 51, 95; 52, identifier:DEBUG_PRINT; 53, block; 53, 54; 54, function_definition; 54, 55; 54, 56; 54, 59; 55, function_name:print; 56, parameters; 56, 57; 57, list_splat_pattern; 57, 58; 58, identifier:args; 59, block; 59, 60; 59, 67; 59, 84; 60, import_from_statement; 60, 61; 60, 65; 61, dotted_name; 61, 62; 61, 63; 61, 64; 62, identifier:utool; 63, identifier:_internal; 64, identifier:meta_util_dbg; 65, dotted_name; 65, 66; 66, identifier:get_caller_name; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:calltag; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, string:''; 73, identifier:join; 74, argument_list; 74, 75; 75, tuple; 75, 76; 75, 77; 75, 83; 76, string:'[caller:'; 77, call; 77, 78; 77, 79; 78, identifier:get_caller_name; 79, argument_list; 79, 80; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:N; 82, identifier:DEBUG_PRINT_N; 83, string:']'; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 91; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:util_logging; 89, identifier:_utool_print; 90, argument_list; 91, argument_list; 91, 92; 91, 93; 92, identifier:calltag; 93, list_splat; 93, 94; 94, identifier:args; 95, else_clause; 95, 96; 96, block; 96, 97; 97, function_definition; 97, 98; 97, 99; 97, 102; 98, function_name:print; 99, parameters; 99, 100; 100, list_splat_pattern; 100, 101; 101, identifier:args; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 110; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:util_logging; 108, identifier:_utool_print; 109, argument_list; 110, argument_list; 110, 111; 111, list_splat; 111, 112; 112, identifier:args; 113, if_statement; 113, 114; 113, 115; 113, 140; 114, identifier:__AGGROFLUSH__; 115, block; 115, 116; 116, function_definition; 116, 117; 116, 118; 116, 121; 117, function_name:print_; 118, parameters; 118, 119; 119, list_splat_pattern; 119, 120; 120, identifier:args; 121, block; 121, 122; 121, 132; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 129; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:util_logging; 127, identifier:_utool_write; 128, argument_list; 129, argument_list; 129, 130; 130, list_splat; 130, 131; 131, identifier:args; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 139; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:util_logging; 137, identifier:_utool_flush; 138, argument_list; 139, argument_list; 140, else_clause; 140, 141; 141, block; 141, 142; 142, function_definition; 142, 143; 142, 144; 142, 147; 143, function_name:print_; 144, parameters; 144, 145; 145, list_splat_pattern; 145, 146; 146, identifier:args; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 155; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:util_logging; 153, identifier:_utool_write; 154, argument_list; 155, argument_list; 155, 156; 156, list_splat; 156, 157; 157, identifier:args; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:dotpos; 161, call; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:module; 165, identifier:__name__; 166, identifier:rfind; 167, argument_list; 167, 168; 168, string:'.'; 169, if_statement; 169, 170; 169, 174; 169, 181; 170, comparison_operator:==; 170, 171; 170, 172; 171, identifier:dotpos; 172, unary_operator:-; 172, 173; 173, integer:1; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:module_name; 178, attribute; 178, 179; 178, 180; 179, identifier:module; 180, identifier:__name__; 181, else_clause; 181, 182; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:module_name; 186, subscript; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:module; 189, identifier:__name__; 190, slice; 190, 191; 190, 194; 191, binary_operator:+; 191, 192; 191, 193; 192, identifier:dotpos; 193, integer:1; 194, colon; 195, function_definition; 195, 196; 195, 197; 195, 199; 196, function_name:_replchars; 197, parameters; 197, 198; 198, identifier:str_; 199, block; 199, 200; 200, return_statement; 200, 201; 201, call; 201, 202; 201, 217; 202, attribute; 202, 203; 202, 216; 203, call; 203, 204; 203, 213; 204, attribute; 204, 205; 204, 212; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:str_; 208, identifier:replace; 209, argument_list; 209, 210; 209, 211; 210, string:'_'; 211, string:'-'; 212, identifier:replace; 213, argument_list; 213, 214; 213, 215; 214, string:']'; 215, string:''; 216, identifier:replace; 217, argument_list; 217, 218; 217, 219; 218, string:'['; 219, string:''; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:flag1; 223, binary_operator:%; 223, 224; 223, 225; 224, string:'--debug-%s'; 225, call; 225, 226; 225, 227; 226, identifier:_replchars; 227, argument_list; 227, 228; 228, identifier:module_name; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:flag2; 232, binary_operator:%; 232, 233; 232, 234; 233, string:'--debug-%s'; 234, call; 234, 235; 234, 236; 235, identifier:_replchars; 236, argument_list; 236, 237; 237, identifier:module_prefix; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:DEBUG_FLAG; 241, call; 241, 242; 241, 243; 242, identifier:any; 243, argument_list; 243, 244; 244, list_comprehension; 244, 245; 244, 250; 245, comparison_operator:in; 245, 246; 245, 247; 246, identifier:flag; 247, attribute; 247, 248; 247, 249; 248, identifier:sys; 249, identifier:argv; 250, for_in_clause; 250, 251; 250, 252; 251, identifier:flag; 252, list:[flag1, flag2]; 252, 253; 252, 254; 253, identifier:flag1; 254, identifier:flag2; 255, for_statement; 255, 256; 255, 257; 255, 258; 256, identifier:curflag; 257, identifier:ARGV_DEBUG_FLAGS; 258, block; 258, 259; 259, if_statement; 259, 260; 259, 263; 260, comparison_operator:in; 260, 261; 260, 262; 261, identifier:curflag; 262, identifier:module_prefix; 263, block; 263, 264; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:DEBUG_FLAG; 267, True; 268, if_statement; 268, 269; 268, 274; 268, 314; 269, boolean_operator:or; 269, 270; 269, 273; 270, boolean_operator:or; 270, 271; 270, 272; 271, identifier:__DEBUG_ALL__; 272, identifier:DEBUG; 273, identifier:DEBUG_FLAG; 274, block; 274, 275; 274, 284; 275, expression_statement; 275, 276; 276, call; 276, 277; 276, 278; 277, identifier:print; 278, argument_list; 278, 279; 279, binary_operator:%; 279, 280; 279, 281; 280, string:'INJECT_PRINT: %r == %r'; 281, tuple; 281, 282; 281, 283; 282, identifier:module_name; 283, identifier:module_prefix; 284, function_definition; 284, 285; 284, 286; 284, 289; 285, function_name:printDBG; 286, parameters; 286, 287; 287, list_splat_pattern; 287, 288; 288, identifier:args; 289, block; 289, 290; 289, 303; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:msg; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, string:', '; 296, identifier:join; 297, argument_list; 297, 298; 298, call; 298, 299; 298, 300; 299, identifier:map; 300, argument_list; 300, 301; 300, 302; 301, identifier:str; 302, identifier:args; 303, expression_statement; 303, 304; 304, call; 304, 305; 304, 308; 305, attribute; 305, 306; 305, 307; 306, identifier:util_logging; 307, identifier:__UTOOL_PRINTDBG__; 308, argument_list; 308, 309; 309, binary_operator:+; 309, 310; 309, 313; 310, binary_operator:+; 310, 311; 310, 312; 311, identifier:module_prefix; 312, string:' DEBUG '; 313, identifier:msg; 314, else_clause; 314, 315; 315, block; 315, 316; 316, function_definition; 316, 317; 316, 318; 316, 321; 317, function_name:printDBG; 318, parameters; 318, 319; 319, list_splat_pattern; 319, 320; 320, identifier:args; 321, block; 321, 322; 322, pass_statement; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:print_funcs; 326, tuple; 326, 327; 326, 328; 326, 329; 327, identifier:print; 328, identifier:print_; 329, identifier:printDBG; 330, return_statement; 330, 331; 331, identifier:print_funcs | def inject_print_functions(module_name=None, module_prefix='[???]',
DEBUG=False, module=None):
module = _get_module(module_name, module)
if SILENT:
def print(*args):
pass
def printDBG(*args):
pass
def print_(*args):
pass
else:
if DEBUG_PRINT:
def print(*args):
from utool._internal.meta_util_dbg import get_caller_name
calltag = ''.join(('[caller:', get_caller_name(N=DEBUG_PRINT_N), ']' ))
util_logging._utool_print()(calltag, *args)
else:
def print(*args):
util_logging._utool_print()(*args)
if __AGGROFLUSH__:
def print_(*args):
util_logging._utool_write()(*args)
util_logging._utool_flush()()
else:
def print_(*args):
util_logging._utool_write()(*args)
dotpos = module.__name__.rfind('.')
if dotpos == -1:
module_name = module.__name__
else:
module_name = module.__name__[dotpos + 1:]
def _replchars(str_):
return str_.replace('_', '-').replace(']', '').replace('[', '')
flag1 = '--debug-%s' % _replchars(module_name)
flag2 = '--debug-%s' % _replchars(module_prefix)
DEBUG_FLAG = any([flag in sys.argv for flag in [flag1, flag2]])
for curflag in ARGV_DEBUG_FLAGS:
if curflag in module_prefix:
DEBUG_FLAG = True
if __DEBUG_ALL__ or DEBUG or DEBUG_FLAG:
print('INJECT_PRINT: %r == %r' % (module_name, module_prefix))
def printDBG(*args):
msg = ', '.join(map(str, args))
util_logging.__UTOOL_PRINTDBG__(module_prefix + ' DEBUG ' + msg)
else:
def printDBG(*args):
pass
print_funcs = (print, print_, printDBG)
return print_funcs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:get_isobaric_ratios; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 10; 3, 11; 3, 12; 4, identifier:psmfn; 5, identifier:psmheader; 6, identifier:channels; 7, identifier:denom_channels; 8, identifier:min_int; 9, identifier:targetfn; 10, identifier:accessioncol; 11, identifier:normalize; 12, identifier:normratiofn; 13, block; 13, 14; 13, 26; 13, 112; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:psm_or_feat_ratios; 17, call; 17, 18; 17, 19; 18, identifier:get_psmratios; 19, argument_list; 19, 20; 19, 21; 19, 22; 19, 23; 19, 24; 19, 25; 20, identifier:psmfn; 21, identifier:psmheader; 22, identifier:channels; 23, identifier:denom_channels; 24, identifier:min_int; 25, identifier:accessioncol; 26, if_statement; 26, 27; 26, 30; 26, 69; 26, 106; 27, boolean_operator:and; 27, 28; 27, 29; 28, identifier:normalize; 29, identifier:normratiofn; 30, block; 30, 31; 30, 40; 30, 49; 30, 60; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:normheader; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:reader; 37, identifier:get_tsv_header; 38, argument_list; 38, 39; 39, identifier:normratiofn; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:normratios; 43, call; 43, 44; 43, 45; 44, identifier:get_ratios_from_fn; 45, argument_list; 45, 46; 45, 47; 45, 48; 46, identifier:normratiofn; 47, identifier:normheader; 48, identifier:channels; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:ch_medians; 52, call; 52, 53; 52, 54; 53, identifier:get_medians; 54, argument_list; 54, 55; 54, 56; 54, 57; 55, identifier:channels; 56, identifier:normratios; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:report; 59, True; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:outratios; 63, call; 63, 64; 63, 65; 64, identifier:calculate_normalized_ratios; 65, argument_list; 65, 66; 65, 67; 65, 68; 66, identifier:psm_or_feat_ratios; 67, identifier:ch_medians; 68, identifier:channels; 69, elif_clause; 69, 70; 69, 71; 70, identifier:normalize; 71, block; 71, 72; 71, 86; 71, 97; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:flatratios; 75, list_comprehension; 75, 76; 75, 83; 76, list_comprehension; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:feat; 79, identifier:ch; 80, for_in_clause; 80, 81; 80, 82; 81, identifier:ch; 82, identifier:channels; 83, for_in_clause; 83, 84; 83, 85; 84, identifier:feat; 85, identifier:psm_or_feat_ratios; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:ch_medians; 89, call; 89, 90; 89, 91; 90, identifier:get_medians; 91, argument_list; 91, 92; 91, 93; 91, 94; 92, identifier:channels; 93, identifier:flatratios; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:report; 96, True; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:outratios; 100, call; 100, 101; 100, 102; 101, identifier:calculate_normalized_ratios; 102, argument_list; 102, 103; 102, 104; 102, 105; 103, identifier:psm_or_feat_ratios; 104, identifier:ch_medians; 105, identifier:channels; 106, else_clause; 106, 107; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:outratios; 111, identifier:psm_or_feat_ratios; 112, if_statement; 112, 113; 112, 116; 112, 136; 112, 150; 113, boolean_operator:and; 113, 114; 113, 115; 114, identifier:accessioncol; 115, identifier:targetfn; 116, block; 116, 117; 116, 129; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:outratios; 120, dictionary_comprehension; 120, 121; 120, 126; 121, pair; 121, 122; 121, 125; 122, subscript; 122, 123; 122, 124; 123, identifier:x; 124, identifier:ISOQUANTRATIO_FEAT_ACC; 125, identifier:x; 126, for_in_clause; 126, 127; 126, 128; 127, identifier:x; 128, identifier:outratios; 129, return_statement; 129, 130; 130, call; 130, 131; 130, 132; 131, identifier:output_to_target_accession_table; 132, argument_list; 132, 133; 132, 134; 132, 135; 133, identifier:targetfn; 134, identifier:outratios; 135, identifier:channels; 136, elif_clause; 136, 137; 136, 142; 137, boolean_operator:and; 137, 138; 137, 140; 138, not_operator; 138, 139; 139, identifier:accessioncol; 140, not_operator; 140, 141; 141, identifier:targetfn; 142, block; 142, 143; 143, return_statement; 143, 144; 144, call; 144, 145; 144, 146; 145, identifier:paste_to_psmtable; 146, argument_list; 146, 147; 146, 148; 146, 149; 147, identifier:psmfn; 148, identifier:psmheader; 149, identifier:outratios; 150, elif_clause; 150, 151; 150, 155; 151, boolean_operator:and; 151, 152; 151, 153; 152, identifier:accessioncol; 153, not_operator; 153, 154; 154, identifier:targetfn; 155, block; 155, 156; 156, return_statement; 156, 157; 157, generator_expression; 157, 158; 157, 180; 158, dictionary_comprehension; 158, 159; 158, 171; 159, pair; 159, 160; 159, 170; 160, parenthesized_expression; 160, 161; 161, conditional_expression:if; 161, 162; 161, 163; 161, 167; 162, identifier:k; 163, not_operator; 163, 164; 164, comparison_operator:==; 164, 165; 164, 166; 165, identifier:k; 166, identifier:ISOQUANTRATIO_FEAT_ACC; 167, attribute; 167, 168; 167, 169; 168, identifier:prottabledata; 169, identifier:HEADER_ACCESSION; 170, identifier:v; 171, for_in_clause; 171, 172; 171, 175; 172, pattern_list; 172, 173; 172, 174; 173, identifier:k; 174, identifier:v; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:ratio; 178, identifier:items; 179, argument_list; 180, for_in_clause; 180, 181; 180, 182; 181, identifier:ratio; 182, identifier:outratios | def get_isobaric_ratios(psmfn, psmheader, channels, denom_channels, min_int,
targetfn, accessioncol, normalize, normratiofn):
psm_or_feat_ratios = get_psmratios(psmfn, psmheader, channels,
denom_channels, min_int, accessioncol)
if normalize and normratiofn:
normheader = reader.get_tsv_header(normratiofn)
normratios = get_ratios_from_fn(normratiofn, normheader, channels)
ch_medians = get_medians(channels, normratios, report=True)
outratios = calculate_normalized_ratios(psm_or_feat_ratios, ch_medians,
channels)
elif normalize:
flatratios = [[feat[ch] for ch in channels]
for feat in psm_or_feat_ratios]
ch_medians = get_medians(channels, flatratios, report=True)
outratios = calculate_normalized_ratios(psm_or_feat_ratios, ch_medians,
channels)
else:
outratios = psm_or_feat_ratios
if accessioncol and targetfn:
outratios = {x[ISOQUANTRATIO_FEAT_ACC]: x for x in outratios}
return output_to_target_accession_table(targetfn, outratios, channels)
elif not accessioncol and not targetfn:
return paste_to_psmtable(psmfn, psmheader, outratios)
elif accessioncol and not targetfn:
return ({(k if not k == ISOQUANTRATIO_FEAT_ACC
else prottabledata.HEADER_ACCESSION): v
for k, v in ratio.items()} for ratio in outratios) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:clean_line_profile_text; 3, parameters; 3, 4; 4, identifier:text; 5, block; 5, 6; 5, 13; 5, 22; 5, 42; 5, 49; 5, 62; 5, 71; 5, 78; 5, 82; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:profile_block_list; 9, call; 9, 10; 9, 11; 10, identifier:parse_rawprofile_blocks; 11, argument_list; 11, 12; 12, identifier:text; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 18; 15, pattern_list; 15, 16; 15, 17; 16, identifier:prefix_list; 17, identifier:timemap; 18, call; 18, 19; 18, 20; 19, identifier:parse_timemap_from_blocks; 20, argument_list; 20, 21; 21, identifier:profile_block_list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sorted_lists; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 27, 34; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:six; 31, identifier:iteritems; 32, argument_list; 32, 33; 33, identifier:timemap; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:key; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:operator; 39, identifier:itemgetter; 40, argument_list; 40, 41; 41, integer:0; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:newlist; 45, subscript; 45, 46; 45, 47; 46, identifier:prefix_list; 47, slice; 47, 48; 48, colon; 49, for_statement; 49, 50; 49, 53; 49, 54; 50, pattern_list; 50, 51; 50, 52; 51, identifier:key; 52, identifier:val; 53, identifier:sorted_lists; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:newlist; 59, identifier:extend; 60, argument_list; 60, 61; 61, identifier:val; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:output_text; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, string:'\n'; 68, identifier:join; 69, argument_list; 69, 70; 70, identifier:newlist; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:summary_text; 74, call; 74, 75; 74, 76; 75, identifier:get_summary; 76, argument_list; 76, 77; 77, identifier:profile_block_list; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:output_text; 81, identifier:output_text; 82, return_statement; 82, 83; 83, expression_list; 83, 84; 83, 85; 84, identifier:output_text; 85, identifier:summary_text | def clean_line_profile_text(text):
profile_block_list = parse_rawprofile_blocks(text)
prefix_list, timemap = parse_timemap_from_blocks(profile_block_list)
sorted_lists = sorted(six.iteritems(timemap), key=operator.itemgetter(0))
newlist = prefix_list[:]
for key, val in sorted_lists:
newlist.extend(val)
output_text = '\n'.join(newlist)
summary_text = get_summary(profile_block_list)
output_text = output_text
return output_text, summary_text |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:random_product; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:items; 5, default_parameter; 5, 6; 5, 7; 6, identifier:num; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:rng; 10, None; 11, block; 11, 12; 11, 17; 11, 27; 11, 33; 11, 44; 11, 57; 11, 66; 11, 76; 12, import_statement; 12, 13; 13, aliased_import; 13, 14; 13, 16; 14, dotted_name; 14, 15; 15, identifier:utool; 16, identifier:ut; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:rng; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:ut; 23, identifier:ensure_rng; 24, argument_list; 24, 25; 24, 26; 25, identifier:rng; 26, string:'python'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:seen; 30, call; 30, 31; 30, 32; 31, identifier:set; 32, argument_list; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:items; 36, list_comprehension; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:list; 39, argument_list; 39, 40; 40, identifier:g; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:g; 43, identifier:items; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:max_num; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:ut; 50, identifier:prod; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:map; 54, argument_list; 54, 55; 54, 56; 55, identifier:len; 56, identifier:items; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:num; 60, None; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:num; 65, identifier:max_num; 66, if_statement; 66, 67; 66, 70; 67, comparison_operator:>; 67, 68; 67, 69; 68, identifier:num; 69, identifier:max_num; 70, block; 70, 71; 71, raise_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:ValueError; 74, argument_list; 74, 75; 75, string:'num exceedes maximum number of products'; 76, if_statement; 76, 77; 76, 82; 76, 107; 77, comparison_operator:>; 77, 78; 77, 79; 78, identifier:num; 79, binary_operator://; 79, 80; 79, 81; 80, identifier:max_num; 81, integer:2; 82, block; 82, 83; 83, for_statement; 83, 84; 83, 85; 83, 103; 84, identifier:prod; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:ut; 88, identifier:shuffle; 89, argument_list; 89, 90; 89, 100; 90, call; 90, 91; 90, 92; 91, identifier:list; 92, argument_list; 92, 93; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:it; 96, identifier:product; 97, argument_list; 97, 98; 98, list_splat; 98, 99; 99, identifier:items; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:rng; 102, identifier:rng; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, yield; 105, 106; 106, identifier:prod; 107, else_clause; 107, 108; 108, block; 108, 109; 109, while_statement; 109, 110; 109, 116; 110, comparison_operator:<; 110, 111; 110, 115; 111, call; 111, 112; 111, 113; 112, identifier:len; 113, argument_list; 113, 114; 114, identifier:seen; 115, identifier:num; 116, block; 116, 117; 116, 138; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:idxs; 120, call; 120, 121; 120, 122; 121, identifier:tuple; 122, generator_expression; 122, 123; 122, 135; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:rng; 126, identifier:randint; 127, argument_list; 127, 128; 127, 129; 128, integer:0; 129, binary_operator:-; 129, 130; 129, 134; 130, call; 130, 131; 130, 132; 131, identifier:len; 132, argument_list; 132, 133; 133, identifier:g; 134, integer:1; 135, for_in_clause; 135, 136; 135, 137; 136, identifier:g; 137, identifier:items; 138, if_statement; 138, 139; 138, 142; 139, comparison_operator:not; 139, 140; 139, 141; 140, identifier:idxs; 141, identifier:seen; 142, block; 142, 143; 142, 150; 142, 168; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:seen; 147, identifier:add; 148, argument_list; 148, 149; 149, identifier:idxs; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:prod; 153, call; 153, 154; 153, 155; 154, identifier:tuple; 155, generator_expression; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:g; 158, identifier:x; 159, for_in_clause; 159, 160; 159, 163; 160, pattern_list; 160, 161; 160, 162; 161, identifier:g; 162, identifier:x; 163, call; 163, 164; 163, 165; 164, identifier:zip; 165, argument_list; 165, 166; 165, 167; 166, identifier:items; 167, identifier:idxs; 168, expression_statement; 168, 169; 169, yield; 169, 170; 170, identifier:prod | def random_product(items, num=None, rng=None):
import utool as ut
rng = ut.ensure_rng(rng, 'python')
seen = set()
items = [list(g) for g in items]
max_num = ut.prod(map(len, items))
if num is None:
num = max_num
if num > max_num:
raise ValueError('num exceedes maximum number of products')
if num > max_num // 2:
for prod in ut.shuffle(list(it.product(*items)), rng=rng):
yield prod
else:
while len(seen) < num:
idxs = tuple(rng.randint(0, len(g) - 1) for g in items)
if idxs not in seen:
seen.add(idxs)
prod = tuple(g[x] for g, x in zip(items, idxs))
yield prod |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:parse_dsn; 3, parameters; 3, 4; 4, identifier:dsn_string; 5, block; 5, 6; 5, 13; 5, 26; 5, 36; 5, 42; 5, 88; 5, 111; 5, 128; 5, 150; 5, 161; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:dsn; 9, call; 9, 10; 9, 11; 10, identifier:urlparse; 11, argument_list; 11, 12; 12, identifier:dsn_string; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:scheme; 16, subscript; 16, 17; 16, 25; 17, call; 17, 18; 17, 23; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:dsn; 21, identifier:scheme; 22, identifier:split; 23, argument_list; 23, 24; 24, string:'+'; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:username; 29, assignment; 29, 30; 29, 31; 30, identifier:password; 31, assignment; 31, 32; 31, 33; 32, identifier:host; 33, assignment; 33, 34; 33, 35; 34, identifier:port; 35, None; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:host; 39, attribute; 39, 40; 39, 41; 40, identifier:dsn; 41, identifier:netloc; 42, if_statement; 42, 43; 42, 46; 43, comparison_operator:in; 43, 44; 43, 45; 44, string:'@'; 45, identifier:host; 46, block; 46, 47; 46, 58; 46, 81; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, pattern_list; 49, 50; 49, 51; 50, identifier:username; 51, identifier:host; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:host; 55, identifier:split; 56, argument_list; 56, 57; 57, string:'@'; 58, if_statement; 58, 59; 58, 62; 59, comparison_operator:in; 59, 60; 59, 61; 60, string:':'; 61, identifier:username; 62, block; 62, 63; 62, 74; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, pattern_list; 65, 66; 65, 67; 66, identifier:username; 67, identifier:password; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:username; 71, identifier:split; 72, argument_list; 72, 73; 73, string:':'; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:password; 77, call; 77, 78; 77, 79; 78, identifier:unquote; 79, argument_list; 79, 80; 80, identifier:password; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:username; 84, call; 84, 85; 84, 86; 85, identifier:unquote; 86, argument_list; 86, 87; 87, identifier:username; 88, if_statement; 88, 89; 88, 92; 89, comparison_operator:in; 89, 90; 89, 91; 90, string:':'; 91, identifier:host; 92, block; 92, 93; 92, 104; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 98; 95, pattern_list; 95, 96; 95, 97; 96, identifier:host; 97, identifier:port; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:host; 101, identifier:split; 102, argument_list; 102, 103; 103, string:':'; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:port; 107, call; 107, 108; 107, 109; 108, identifier:int; 109, argument_list; 109, 110; 110, identifier:port; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:database; 114, subscript; 114, 115; 114, 125; 115, subscript; 115, 116; 115, 124; 116, call; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:dsn; 120, identifier:path; 121, identifier:split; 122, argument_list; 122, 123; 123, string:'?'; 124, integer:0; 125, slice; 125, 126; 125, 127; 126, integer:1; 127, colon; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:query; 131, conditional_expression:if; 131, 132; 131, 142; 131, 147; 132, subscript; 132, 133; 132, 141; 133, call; 133, 134; 133, 139; 134, attribute; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:dsn; 137, identifier:path; 138, identifier:split; 139, argument_list; 139, 140; 140, string:'?'; 141, integer:1; 142, comparison_operator:in; 142, 143; 142, 144; 143, string:'?'; 144, attribute; 144, 145; 144, 146; 145, identifier:dsn; 146, identifier:path; 147, attribute; 147, 148; 147, 149; 148, identifier:dsn; 149, identifier:query; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:kwargs; 153, call; 153, 154; 153, 155; 154, identifier:dict; 155, argument_list; 155, 156; 156, call; 156, 157; 156, 158; 157, identifier:parse_qsl; 158, argument_list; 158, 159; 158, 160; 159, identifier:query; 160, True; 161, if_statement; 161, 162; 161, 165; 161, 174; 161, 225; 161, 292; 162, comparison_operator:==; 162, 163; 162, 164; 163, identifier:scheme; 164, string:'sqlite'; 165, block; 165, 166; 166, return_statement; 166, 167; 167, expression_list; 167, 168; 167, 169; 167, 173; 168, identifier:SQLiteDriver; 169, list:[dsn.path]; 169, 170; 170, attribute; 170, 171; 170, 172; 171, identifier:dsn; 172, identifier:path; 173, dictionary; 174, elif_clause; 174, 175; 174, 178; 175, comparison_operator:==; 175, 176; 175, 177; 176, identifier:scheme; 177, string:'mysql'; 178, block; 178, 179; 178, 187; 178, 193; 178, 202; 178, 211; 178, 220; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 184; 181, subscript; 181, 182; 181, 183; 182, identifier:kwargs; 183, string:'user'; 184, boolean_operator:or; 184, 185; 184, 186; 185, identifier:username; 186, string:'root'; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:kwargs; 191, string:'db'; 192, identifier:database; 193, if_statement; 193, 194; 193, 195; 194, identifier:port; 195, block; 195, 196; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:kwargs; 200, string:'port'; 201, identifier:port; 202, if_statement; 202, 203; 202, 204; 203, identifier:host; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:kwargs; 209, string:'host'; 210, identifier:host; 211, if_statement; 211, 212; 211, 213; 212, identifier:password; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:kwargs; 218, string:'passwd'; 219, identifier:password; 220, return_statement; 220, 221; 221, expression_list; 221, 222; 221, 223; 221, 224; 222, identifier:MySQLDriver; 223, list:[]; 224, identifier:kwargs; 225, elif_clause; 225, 226; 225, 229; 226, comparison_operator:==; 226, 227; 226, 228; 227, identifier:scheme; 228, string:'postgresql'; 229, block; 229, 230; 229, 238; 229, 244; 229, 253; 229, 278; 229, 287; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 235; 232, subscript; 232, 233; 232, 234; 233, identifier:kwargs; 234, string:'user'; 235, boolean_operator:or; 235, 236; 235, 237; 236, identifier:username; 237, string:'postgres'; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 243; 240, subscript; 240, 241; 240, 242; 241, identifier:kwargs; 242, string:'database'; 243, identifier:database; 244, if_statement; 244, 245; 244, 246; 245, identifier:port; 246, block; 246, 247; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 252; 249, subscript; 249, 250; 249, 251; 250, identifier:kwargs; 251, string:'port'; 252, identifier:port; 253, if_statement; 253, 254; 253, 257; 253, 269; 254, comparison_operator:in; 254, 255; 254, 256; 255, string:'unix_socket'; 256, identifier:kwargs; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 263; 260, subscript; 260, 261; 260, 262; 261, identifier:kwargs; 262, string:'host'; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:kwargs; 266, identifier:pop; 267, argument_list; 267, 268; 268, string:'unix_socket'; 269, elif_clause; 269, 270; 269, 271; 270, identifier:host; 271, block; 271, 272; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 277; 274, subscript; 274, 275; 274, 276; 275, identifier:kwargs; 276, string:'host'; 277, identifier:host; 278, if_statement; 278, 279; 278, 280; 279, identifier:password; 280, block; 280, 281; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 286; 283, subscript; 283, 284; 283, 285; 284, identifier:kwargs; 285, string:'password'; 286, identifier:password; 287, return_statement; 287, 288; 288, expression_list; 288, 289; 288, 290; 288, 291; 289, identifier:PostgreSQLDriver; 290, list:[]; 291, identifier:kwargs; 292, else_clause; 292, 293; 293, block; 293, 294; 294, raise_statement; 294, 295; 295, call; 295, 296; 295, 297; 296, identifier:ValueError; 297, argument_list; 297, 298; 298, binary_operator:%; 298, 299; 298, 300; 299, string:'Unknown driver %s'; 300, identifier:dsn_string | def parse_dsn(dsn_string):
dsn = urlparse(dsn_string)
scheme = dsn.scheme.split('+')[0]
username = password = host = port = None
host = dsn.netloc
if '@' in host:
username, host = host.split('@')
if ':' in username:
username, password = username.split(':')
password = unquote(password)
username = unquote(username)
if ':' in host:
host, port = host.split(':')
port = int(port)
database = dsn.path.split('?')[0][1:]
query = dsn.path.split('?')[1] if '?' in dsn.path else dsn.query
kwargs = dict(parse_qsl(query, True))
if scheme == 'sqlite':
return SQLiteDriver, [dsn.path], {}
elif scheme == 'mysql':
kwargs['user'] = username or 'root'
kwargs['db'] = database
if port:
kwargs['port'] = port
if host:
kwargs['host'] = host
if password:
kwargs['passwd'] = password
return MySQLDriver, [], kwargs
elif scheme == 'postgresql':
kwargs['user'] = username or 'postgres'
kwargs['database'] = database
if port:
kwargs['port'] = port
if 'unix_socket' in kwargs:
kwargs['host'] = kwargs.pop('unix_socket')
elif host:
kwargs['host'] = host
if password:
kwargs['password'] = password
return PostgreSQLDriver, [], kwargs
else:
raise ValueError('Unknown driver %s' % dsn_string) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 31; 2, function_name:numpy_str; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:arr; 5, default_parameter; 5, 6; 5, 7; 6, identifier:strvals; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:precision; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:pr; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:force_dtype; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:with_dtype; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:suppress_small; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:max_line_width; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:threshold; 28, None; 29, dictionary_splat_pattern; 29, 30; 30, identifier:kwargs; 31, block; 31, 32; 31, 42; 31, 58; 31, 62; 31, 68; 31, 172; 31, 237; 31, 252; 31, 260; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:itemsep; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:kwargs; 38, identifier:get; 39, argument_list; 39, 40; 39, 41; 40, string:'itemsep'; 41, string:' '; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:newlines; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:kwargs; 48, identifier:pop; 49, argument_list; 49, 50; 49, 51; 50, string:'nl'; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:kwargs; 54, identifier:pop; 55, argument_list; 55, 56; 55, 57; 56, string:'newlines'; 57, integer:1; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:data; 61, identifier:arr; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:separator; 65, binary_operator:+; 65, 66; 65, 67; 66, string:','; 67, identifier:itemsep; 68, if_statement; 68, 69; 68, 70; 68, 79; 69, identifier:strvals; 70, block; 70, 71; 70, 75; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:prefix; 74, string:''; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:suffix; 78, string:''; 79, else_clause; 79, 80; 80, block; 80, 81; 80, 90; 80, 94; 80, 105; 80, 116; 80, 125; 80, 134; 80, 144; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:modname; 84, attribute; 84, 85; 84, 89; 85, call; 85, 86; 85, 87; 86, identifier:type; 87, argument_list; 87, 88; 88, identifier:data; 89, identifier:__module__; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:np_nice; 93, string:'np'; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:modname; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:re; 100, identifier:sub; 101, argument_list; 101, 102; 101, 103; 101, 104; 102, string:'\\bnumpy\\b'; 103, identifier:np_nice; 104, identifier:modname; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:modname; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:re; 111, identifier:sub; 112, argument_list; 112, 113; 112, 114; 112, 115; 113, string:'\\bma.core\\b'; 114, string:'ma'; 115, identifier:modname; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:class_name; 119, attribute; 119, 120; 119, 124; 120, call; 120, 121; 120, 122; 121, identifier:type; 122, argument_list; 122, 123; 123, identifier:data; 124, identifier:__name__; 125, if_statement; 125, 126; 125, 129; 126, comparison_operator:==; 126, 127; 126, 128; 127, identifier:class_name; 128, string:'ndarray'; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:class_name; 133, string:'array'; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:prefix; 137, binary_operator:+; 137, 138; 137, 143; 138, binary_operator:+; 138, 139; 138, 142; 139, binary_operator:+; 139, 140; 139, 141; 140, identifier:modname; 141, string:'.'; 142, identifier:class_name; 143, string:'('; 144, if_statement; 144, 145; 144, 146; 144, 166; 145, identifier:with_dtype; 146, block; 146, 147; 146, 155; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:dtype_repr; 150, attribute; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:data; 153, identifier:dtype; 154, identifier:name; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:suffix; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, string:',{}dtype={}.{})'; 161, identifier:format; 162, argument_list; 162, 163; 162, 164; 162, 165; 163, identifier:itemsep; 164, identifier:np_nice; 165, identifier:dtype_repr; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:suffix; 171, string:')'; 172, if_statement; 172, 173; 172, 188; 172, 211; 173, boolean_operator:and; 173, 174; 173, 182; 174, boolean_operator:and; 174, 175; 174, 177; 175, not_operator; 175, 176; 176, identifier:strvals; 177, comparison_operator:==; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:data; 180, identifier:size; 181, integer:0; 182, comparison_operator:!=; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:data; 185, identifier:shape; 186, tuple; 186, 187; 187, integer:0; 188, block; 188, 189; 188, 195; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:prefix; 192, binary_operator:+; 192, 193; 192, 194; 193, identifier:modname; 194, string:'.empty('; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:body; 198, call; 198, 199; 198, 200; 199, identifier:repr; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:tuple; 203, argument_list; 203, 204; 204, call; 204, 205; 204, 206; 205, identifier:map; 206, argument_list; 206, 207; 206, 208; 207, identifier:int; 208, attribute; 208, 209; 208, 210; 209, identifier:data; 210, identifier:shape; 211, else_clause; 211, 212; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:body; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:np; 219, identifier:array2string; 220, argument_list; 220, 221; 220, 222; 220, 225; 220, 228; 220, 231; 220, 234; 221, identifier:data; 222, keyword_argument; 222, 223; 222, 224; 223, identifier:precision; 224, identifier:precision; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:separator; 227, identifier:separator; 228, keyword_argument; 228, 229; 228, 230; 229, identifier:suppress_small; 230, identifier:suppress_small; 231, keyword_argument; 231, 232; 231, 233; 232, identifier:prefix; 233, identifier:prefix; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:max_line_width; 236, identifier:max_line_width; 237, if_statement; 237, 238; 237, 240; 238, not_operator; 238, 239; 239, identifier:newlines; 240, block; 240, 241; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:body; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:re; 247, identifier:sub; 248, argument_list; 248, 249; 248, 250; 248, 251; 249, string:'\n *'; 250, string:''; 251, identifier:body; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 255; 254, identifier:formatted; 255, binary_operator:+; 255, 256; 255, 259; 256, binary_operator:+; 256, 257; 256, 258; 257, identifier:prefix; 258, identifier:body; 259, identifier:suffix; 260, return_statement; 260, 261; 261, identifier:formatted | def numpy_str(arr, strvals=False, precision=None, pr=None,
force_dtype=False,
with_dtype=None, suppress_small=None, max_line_width=None,
threshold=None, **kwargs):
itemsep = kwargs.get('itemsep', ' ')
newlines = kwargs.pop('nl', kwargs.pop('newlines', 1))
data = arr
separator = ',' + itemsep
if strvals:
prefix = ''
suffix = ''
else:
modname = type(data).__module__
np_nice = 'np'
modname = re.sub('\\bnumpy\\b', np_nice, modname)
modname = re.sub('\\bma.core\\b', 'ma', modname)
class_name = type(data).__name__
if class_name == 'ndarray':
class_name = 'array'
prefix = modname + '.' + class_name + '('
if with_dtype:
dtype_repr = data.dtype.name
suffix = ',{}dtype={}.{})'.format(itemsep, np_nice, dtype_repr)
else:
suffix = ')'
if not strvals and data.size == 0 and data.shape != (0,):
prefix = modname + '.empty('
body = repr(tuple(map(int, data.shape)))
else:
body = np.array2string(data, precision=precision,
separator=separator,
suppress_small=suppress_small,
prefix=prefix,
max_line_width=max_line_width)
if not newlines:
body = re.sub('\n *', '', body)
formatted = prefix + body + suffix
return formatted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:list_str; 3, parameters; 3, 4; 3, 5; 4, identifier:list_; 5, dictionary_splat_pattern; 5, 6; 6, identifier:listkw; 7, block; 7, 8; 7, 10; 7, 15; 7, 31; 7, 41; 7, 51; 7, 60; 7, 69; 7, 78; 7, 94; 7, 104; 7, 114; 7, 118; 7, 127; 7, 135; 7, 148; 7, 164; 7, 207; 7, 219; 7, 392; 7, 407; 7, 429; 8, expression_statement; 8, 9; 9, identifier:r; 10, import_statement; 10, 11; 11, aliased_import; 11, 12; 11, 14; 12, dotted_name; 12, 13; 13, identifier:utool; 14, identifier:ut; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:newlines; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:listkw; 21, identifier:pop; 22, argument_list; 22, 23; 22, 24; 23, string:'nl'; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:listkw; 27, identifier:pop; 28, argument_list; 28, 29; 28, 30; 29, string:'newlines'; 30, integer:1; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:packed; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:listkw; 37, identifier:pop; 38, argument_list; 38, 39; 38, 40; 39, string:'packed'; 40, False; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:truncate; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:listkw; 47, identifier:pop; 48, argument_list; 48, 49; 48, 50; 49, string:'truncate'; 50, False; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:listkw; 55, string:'nl'; 56, call; 56, 57; 56, 58; 57, identifier:_rectify_countdown_or_bool; 58, argument_list; 58, 59; 59, identifier:newlines; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:listkw; 64, string:'truncate'; 65, call; 65, 66; 65, 67; 66, identifier:_rectify_countdown_or_bool; 67, argument_list; 67, 68; 68, identifier:truncate; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:listkw; 73, string:'packed'; 74, call; 74, 75; 74, 76; 75, identifier:_rectify_countdown_or_bool; 76, argument_list; 76, 77; 77, identifier:packed; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:nobraces; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:listkw; 84, identifier:pop; 85, argument_list; 85, 86; 85, 87; 86, string:'nobr'; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:listkw; 90, identifier:pop; 91, argument_list; 91, 92; 91, 93; 92, string:'nobraces'; 93, False; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:itemsep; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:listkw; 100, identifier:get; 101, argument_list; 101, 102; 101, 103; 102, string:'itemsep'; 103, string:' '; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:trailing_sep; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:listkw; 110, identifier:get; 111, argument_list; 111, 112; 111, 113; 112, string:'trailing_sep'; 113, True; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:with_comma; 117, True; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:itemstr_list; 121, call; 121, 122; 121, 123; 122, identifier:get_itemstr_list; 123, argument_list; 123, 124; 123, 125; 124, identifier:list_; 125, dictionary_splat; 125, 126; 126, identifier:listkw; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:is_tuple; 130, call; 130, 131; 130, 132; 131, identifier:isinstance; 132, argument_list; 132, 133; 132, 134; 133, identifier:list_; 134, identifier:tuple; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:is_set; 138, call; 138, 139; 138, 140; 139, identifier:isinstance; 140, argument_list; 140, 141; 140, 142; 141, identifier:list_; 142, tuple; 142, 143; 142, 144; 142, 145; 143, identifier:set; 144, identifier:frozenset; 145, attribute; 145, 146; 145, 147; 146, identifier:ut; 147, identifier:oset; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:is_onetup; 151, boolean_operator:and; 151, 152; 151, 158; 152, call; 152, 153; 152, 154; 153, identifier:isinstance; 154, argument_list; 154, 155; 154, 156; 155, identifier:list_; 156, parenthesized_expression; 156, 157; 157, identifier:tuple; 158, comparison_operator:<=; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:list_; 163, integer:1; 164, if_statement; 164, 165; 164, 166; 164, 175; 164, 186; 164, 197; 165, identifier:nobraces; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 172; 169, pattern_list; 169, 170; 169, 171; 170, identifier:lbr; 171, identifier:rbr; 172, expression_list; 172, 173; 172, 174; 173, string:''; 174, string:''; 175, elif_clause; 175, 176; 175, 177; 176, identifier:is_tuple; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, pattern_list; 180, 181; 180, 182; 181, identifier:lbr; 182, identifier:rbr; 183, expression_list; 183, 184; 183, 185; 184, string:'('; 185, string:')'; 186, elif_clause; 186, 187; 186, 188; 187, identifier:is_set; 188, block; 188, 189; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, pattern_list; 191, 192; 191, 193; 192, identifier:lbr; 193, identifier:rbr; 194, expression_list; 194, 195; 194, 196; 195, string:'{'; 196, string:'}'; 197, else_clause; 197, 198; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 204; 201, pattern_list; 201, 202; 201, 203; 202, identifier:lbr; 203, identifier:rbr; 204, expression_list; 204, 205; 204, 206; 205, string:'['; 206, string:']'; 207, if_statement; 207, 208; 207, 214; 208, comparison_operator:==; 208, 209; 208, 213; 209, call; 209, 210; 209, 211; 210, identifier:len; 211, argument_list; 211, 212; 212, identifier:itemstr_list; 213, integer:0; 214, block; 214, 215; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:newlines; 218, False; 219, if_statement; 219, 220; 219, 232; 219, 356; 220, boolean_operator:and; 220, 221; 220, 224; 221, comparison_operator:is; 221, 222; 221, 223; 222, identifier:newlines; 223, False; 224, parenthesized_expression; 224, 225; 225, boolean_operator:or; 225, 226; 225, 229; 226, comparison_operator:is; 226, 227; 226, 228; 227, identifier:newlines; 228, True; 229, comparison_operator:>; 229, 230; 229, 231; 230, identifier:newlines; 231, integer:0; 232, block; 232, 233; 232, 240; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:sep; 236, conditional_expression:if; 236, 237; 236, 238; 236, 239; 237, string:',\n'; 238, identifier:with_comma; 239, string:'\n'; 240, if_statement; 240, 241; 240, 242; 240, 263; 241, identifier:nobraces; 242, block; 242, 243; 242, 252; 242, 259; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:body_str; 246, call; 246, 247; 246, 250; 247, attribute; 247, 248; 247, 249; 248, identifier:sep; 249, identifier:join; 250, argument_list; 250, 251; 251, identifier:itemstr_list; 252, if_statement; 252, 253; 252, 254; 253, identifier:trailing_sep; 254, block; 254, 255; 255, expression_statement; 255, 256; 256, augmented_assignment:+=; 256, 257; 256, 258; 257, identifier:body_str; 258, string:','; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:retstr; 262, identifier:body_str; 263, else_clause; 263, 264; 264, block; 264, 265; 264, 352; 265, if_statement; 265, 266; 265, 267; 265, 312; 266, identifier:packed; 267, block; 267, 268; 267, 279; 267, 292; 267, 299; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:joinstr; 271, binary_operator:+; 271, 272; 271, 273; 272, identifier:sep; 273, binary_operator:*; 273, 274; 273, 275; 274, identifier:itemsep; 275, call; 275, 276; 275, 277; 276, identifier:len; 277, argument_list; 277, 278; 278, identifier:lbr; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:body_str; 282, call; 282, 283; 282, 286; 283, attribute; 283, 284; 283, 285; 284, identifier:joinstr; 285, identifier:join; 286, argument_list; 286, 287; 287, list_comprehension; 287, 288; 287, 289; 288, identifier:itemstr; 289, for_in_clause; 289, 290; 289, 291; 290, identifier:itemstr; 291, identifier:itemstr_list; 292, if_statement; 292, 293; 292, 294; 293, identifier:trailing_sep; 294, block; 294, 295; 295, expression_statement; 295, 296; 296, augmented_assignment:+=; 296, 297; 296, 298; 297, identifier:body_str; 298, string:','; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:braced_body_str; 302, parenthesized_expression; 302, 303; 303, binary_operator:+; 303, 304; 303, 311; 304, binary_operator:+; 304, 305; 304, 310; 305, binary_operator:+; 305, 306; 305, 309; 306, binary_operator:+; 306, 307; 306, 308; 307, identifier:lbr; 308, string:''; 309, identifier:body_str; 310, string:''; 311, identifier:rbr; 312, else_clause; 312, 313; 313, block; 313, 314; 313, 332; 313, 339; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:body_str; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:sep; 320, identifier:join; 321, argument_list; 321, 322; 322, list_comprehension; 322, 323; 322, 329; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:ut; 326, identifier:indent; 327, argument_list; 327, 328; 328, identifier:itemstr; 329, for_in_clause; 329, 330; 329, 331; 330, identifier:itemstr; 331, identifier:itemstr_list; 332, if_statement; 332, 333; 332, 334; 333, identifier:trailing_sep; 334, block; 334, 335; 335, expression_statement; 335, 336; 336, augmented_assignment:+=; 336, 337; 336, 338; 337, identifier:body_str; 338, string:','; 339, expression_statement; 339, 340; 340, assignment; 340, 341; 340, 342; 341, identifier:braced_body_str; 342, parenthesized_expression; 342, 343; 343, binary_operator:+; 343, 344; 343, 351; 344, binary_operator:+; 344, 345; 344, 350; 345, binary_operator:+; 345, 346; 345, 349; 346, binary_operator:+; 346, 347; 346, 348; 347, identifier:lbr; 348, string:'\n'; 349, identifier:body_str; 350, string:'\n'; 351, identifier:rbr; 352, expression_statement; 352, 353; 353, assignment; 353, 354; 353, 355; 354, identifier:retstr; 355, identifier:braced_body_str; 356, else_clause; 356, 357; 357, block; 357, 358; 357, 367; 357, 376; 357, 383; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 361; 360, identifier:sep; 361, conditional_expression:if; 361, 362; 361, 365; 361, 366; 362, binary_operator:+; 362, 363; 362, 364; 363, string:','; 364, identifier:itemsep; 365, identifier:with_comma; 366, identifier:itemsep; 367, expression_statement; 367, 368; 368, assignment; 368, 369; 368, 370; 369, identifier:body_str; 370, call; 370, 371; 370, 374; 371, attribute; 371, 372; 371, 373; 372, identifier:sep; 373, identifier:join; 374, argument_list; 374, 375; 375, identifier:itemstr_list; 376, if_statement; 376, 377; 376, 378; 377, identifier:is_onetup; 378, block; 378, 379; 379, expression_statement; 379, 380; 380, augmented_assignment:+=; 380, 381; 380, 382; 381, identifier:body_str; 382, string:','; 383, expression_statement; 383, 384; 384, assignment; 384, 385; 384, 386; 385, identifier:retstr; 386, parenthesized_expression; 386, 387; 387, binary_operator:+; 387, 388; 387, 391; 388, binary_operator:+; 388, 389; 388, 390; 389, identifier:lbr; 390, identifier:body_str; 391, identifier:rbr; 392, expression_statement; 392, 393; 393, assignment; 393, 394; 393, 395; 394, identifier:do_truncate; 395, boolean_operator:and; 395, 396; 395, 399; 396, comparison_operator:is; 396, 397; 396, 398; 397, identifier:truncate; 398, False; 399, parenthesized_expression; 399, 400; 400, boolean_operator:or; 400, 401; 400, 404; 401, comparison_operator:is; 401, 402; 401, 403; 402, identifier:truncate; 403, True; 404, comparison_operator:==; 404, 405; 404, 406; 405, identifier:truncate; 406, integer:0; 407, if_statement; 407, 408; 407, 409; 408, identifier:do_truncate; 409, block; 409, 410; 409, 420; 410, expression_statement; 410, 411; 411, assignment; 411, 412; 411, 413; 412, identifier:truncatekw; 413, call; 413, 414; 413, 417; 414, attribute; 414, 415; 414, 416; 415, identifier:listkw; 416, identifier:get; 417, argument_list; 417, 418; 417, 419; 418, string:'truncatekw'; 419, dictionary; 420, expression_statement; 420, 421; 421, assignment; 421, 422; 421, 423; 422, identifier:retstr; 423, call; 423, 424; 423, 425; 424, identifier:truncate_str; 425, argument_list; 425, 426; 425, 427; 426, identifier:retstr; 427, dictionary_splat; 427, 428; 428, identifier:truncatekw; 429, return_statement; 429, 430; 430, identifier:retstr | def list_str(list_, **listkw):
r
import utool as ut
newlines = listkw.pop('nl', listkw.pop('newlines', 1))
packed = listkw.pop('packed', False)
truncate = listkw.pop('truncate', False)
listkw['nl'] = _rectify_countdown_or_bool(newlines)
listkw['truncate'] = _rectify_countdown_or_bool(truncate)
listkw['packed'] = _rectify_countdown_or_bool(packed)
nobraces = listkw.pop('nobr', listkw.pop('nobraces', False))
itemsep = listkw.get('itemsep', ' ')
trailing_sep = listkw.get('trailing_sep', True)
with_comma = True
itemstr_list = get_itemstr_list(list_, **listkw)
is_tuple = isinstance(list_, tuple)
is_set = isinstance(list_, (set, frozenset, ut.oset))
is_onetup = isinstance(list_, (tuple)) and len(list_) <= 1
if nobraces:
lbr, rbr = '', ''
elif is_tuple:
lbr, rbr = '(', ')'
elif is_set:
lbr, rbr = '{', '}'
else:
lbr, rbr = '[', ']'
if len(itemstr_list) == 0:
newlines = False
if newlines is not False and (newlines is True or newlines > 0):
sep = ',\n' if with_comma else '\n'
if nobraces:
body_str = sep.join(itemstr_list)
if trailing_sep:
body_str += ','
retstr = body_str
else:
if packed:
joinstr = sep + itemsep * len(lbr)
body_str = joinstr.join([itemstr for itemstr in itemstr_list])
if trailing_sep:
body_str += ','
braced_body_str = (lbr + '' + body_str + '' + rbr)
else:
body_str = sep.join([
ut.indent(itemstr) for itemstr in itemstr_list])
if trailing_sep:
body_str += ','
braced_body_str = (lbr + '\n' + body_str + '\n' + rbr)
retstr = braced_body_str
else:
sep = ',' + itemsep if with_comma else itemsep
body_str = sep.join(itemstr_list)
if is_onetup:
body_str += ','
retstr = (lbr + body_str + rbr)
do_truncate = truncate is not False and (truncate is True or truncate == 0)
if do_truncate:
truncatekw = listkw.get('truncatekw', {})
retstr = truncate_str(retstr, **truncatekw)
return retstr |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:horiz_string; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 12; 8, 22; 8, 32; 8, 63; 8, 80; 8, 84; 8, 88; 8, 258; 8, 271; 8, 280; 9, import_statement; 9, 10; 10, dotted_name; 10, 11; 11, identifier:unicodedata; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:precision; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:kwargs; 18, identifier:get; 19, argument_list; 19, 20; 19, 21; 20, string:'precision'; 21, None; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sep; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:kwargs; 28, identifier:get; 29, argument_list; 29, 30; 29, 31; 30, string:'sep'; 31, string:''; 32, if_statement; 32, 33; 32, 50; 32, 57; 33, boolean_operator:and; 33, 34; 33, 40; 34, comparison_operator:==; 34, 35; 34, 39; 35, call; 35, 36; 35, 37; 36, identifier:len; 37, argument_list; 37, 38; 38, identifier:args; 39, integer:1; 40, not_operator; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:args; 46, integer:0; 47, attribute; 47, 48; 47, 49; 48, identifier:six; 49, identifier:string_types; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:val_list; 54, subscript; 54, 55; 54, 56; 55, identifier:args; 56, integer:0; 57, else_clause; 57, 58; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:val_list; 62, identifier:args; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:val_list; 66, list_comprehension; 66, 67; 66, 77; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:unicodedata; 70, identifier:normalize; 71, argument_list; 71, 72; 71, 73; 72, string:'NFC'; 73, call; 73, 74; 73, 75; 74, identifier:ensure_unicode; 75, argument_list; 75, 76; 76, identifier:val; 77, for_in_clause; 77, 78; 77, 79; 78, identifier:val; 79, identifier:val_list; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:all_lines; 83, list:[]; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:hpos; 87, integer:0; 88, for_statement; 88, 89; 88, 90; 88, 97; 89, identifier:sx; 90, call; 90, 91; 90, 92; 91, identifier:range; 92, argument_list; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, identifier:val_list; 97, block; 97, 98; 97, 104; 97, 108; 97, 148; 97, 164; 97, 173; 97, 185; 97, 199; 97, 227; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:val; 101, subscript; 101, 102; 101, 103; 102, identifier:val_list; 103, identifier:sx; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:str_; 107, None; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:precision; 111, None; 112, block; 112, 113; 113, if_statement; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:util_type; 116, identifier:HAVE_NUMPY; 117, block; 117, 118; 118, try_statement; 118, 119; 118, 144; 119, block; 119, 120; 120, if_statement; 120, 121; 120, 128; 121, call; 121, 122; 121, 123; 122, identifier:isinstance; 123, argument_list; 123, 124; 123, 125; 124, identifier:val; 125, attribute; 125, 126; 125, 127; 126, identifier:np; 127, identifier:ndarray; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:str_; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:np; 135, identifier:array_str; 136, argument_list; 136, 137; 136, 138; 136, 141; 137, identifier:val; 138, keyword_argument; 138, 139; 138, 140; 139, identifier:precision; 140, identifier:precision; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:suppress_small; 143, True; 144, except_clause; 144, 145; 144, 146; 145, identifier:ImportError; 146, block; 146, 147; 147, pass_statement; 148, if_statement; 148, 149; 148, 152; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:str_; 151, None; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:str_; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:six; 159, identifier:text_type; 160, argument_list; 160, 161; 161, subscript; 161, 162; 161, 163; 162, identifier:val_list; 163, identifier:sx; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:lines; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:str_; 170, identifier:split; 171, argument_list; 171, 172; 172, string:'\n'; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:line_diff; 176, binary_operator:-; 176, 177; 176, 181; 177, call; 177, 178; 177, 179; 178, identifier:len; 179, argument_list; 179, 180; 180, identifier:lines; 181, call; 181, 182; 181, 183; 182, identifier:len; 183, argument_list; 183, 184; 184, identifier:all_lines; 185, if_statement; 185, 186; 185, 189; 186, comparison_operator:>; 186, 187; 186, 188; 187, identifier:line_diff; 188, integer:0; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, augmented_assignment:+=; 191, 192; 191, 193; 192, identifier:all_lines; 193, binary_operator:*; 193, 194; 193, 198; 194, list:[' ' * hpos]; 194, 195; 195, binary_operator:*; 195, 196; 195, 197; 196, string:' '; 197, identifier:hpos; 198, identifier:line_diff; 199, for_statement; 199, 200; 199, 203; 199, 207; 200, pattern_list; 200, 201; 200, 202; 201, identifier:lx; 202, identifier:line; 203, call; 203, 204; 203, 205; 204, identifier:enumerate; 205, argument_list; 205, 206; 206, identifier:lines; 207, block; 207, 208; 207, 214; 208, expression_statement; 208, 209; 209, augmented_assignment:+=; 209, 210; 209, 213; 210, subscript; 210, 211; 210, 212; 211, identifier:all_lines; 212, identifier:lx; 213, identifier:line; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:hpos; 217, call; 217, 218; 217, 219; 218, identifier:max; 219, argument_list; 219, 220; 219, 221; 220, identifier:hpos; 221, call; 221, 222; 221, 223; 222, identifier:len; 223, argument_list; 223, 224; 224, subscript; 224, 225; 224, 226; 225, identifier:all_lines; 226, identifier:lx; 227, for_statement; 227, 228; 227, 229; 227, 236; 228, identifier:lx; 229, call; 229, 230; 229, 231; 230, identifier:range; 231, argument_list; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:len; 234, argument_list; 234, 235; 235, identifier:all_lines; 236, block; 236, 237; 236, 248; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:hpos_diff; 240, binary_operator:-; 240, 241; 240, 242; 241, identifier:hpos; 242, call; 242, 243; 242, 244; 243, identifier:len; 244, argument_list; 244, 245; 245, subscript; 245, 246; 245, 247; 246, identifier:all_lines; 247, identifier:lx; 248, expression_statement; 248, 249; 249, augmented_assignment:+=; 249, 250; 249, 253; 250, subscript; 250, 251; 250, 252; 251, identifier:all_lines; 252, identifier:lx; 253, binary_operator:+; 253, 254; 253, 257; 254, binary_operator:*; 254, 255; 254, 256; 255, string:' '; 256, identifier:hpos_diff; 257, identifier:sep; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 261; 260, identifier:all_lines; 261, list_comprehension; 261, 262; 261, 268; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:line; 265, identifier:rstrip; 266, argument_list; 266, 267; 267, string:' '; 268, for_in_clause; 268, 269; 268, 270; 269, identifier:line; 270, identifier:all_lines; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:ret; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, string:'\n'; 277, identifier:join; 278, argument_list; 278, 279; 279, identifier:all_lines; 280, return_statement; 280, 281; 281, identifier:ret | def horiz_string(*args, **kwargs):
import unicodedata
precision = kwargs.get('precision', None)
sep = kwargs.get('sep', '')
if len(args) == 1 and not isinstance(args[0], six.string_types):
val_list = args[0]
else:
val_list = args
val_list = [unicodedata.normalize('NFC', ensure_unicode(val))
for val in val_list]
all_lines = []
hpos = 0
for sx in range(len(val_list)):
val = val_list[sx]
str_ = None
if precision is not None:
if util_type.HAVE_NUMPY:
try:
if isinstance(val, np.ndarray):
str_ = np.array_str(val, precision=precision,
suppress_small=True)
except ImportError:
pass
if str_ is None:
str_ = six.text_type(val_list[sx])
lines = str_.split('\n')
line_diff = len(lines) - len(all_lines)
if line_diff > 0:
all_lines += [' ' * hpos] * line_diff
for lx, line in enumerate(lines):
all_lines[lx] += line
hpos = max(hpos, len(all_lines[lx]))
for lx in range(len(all_lines)):
hpos_diff = hpos - len(all_lines[lx])
all_lines[lx] += ' ' * hpos_diff + sep
all_lines = [line.rstrip(' ') for line in all_lines]
ret = '\n'.join(all_lines)
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:get_textdiff; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:text1; 5, identifier:text2; 6, default_parameter; 6, 7; 6, 8; 7, identifier:num_context_lines; 8, integer:0; 9, default_parameter; 9, 10; 9, 11; 10, identifier:ignore_whitespace; 11, False; 12, block; 12, 13; 12, 15; 12, 18; 12, 25; 12, 32; 12, 40; 12, 48; 12, 97; 12, 112; 12, 279; 13, expression_statement; 13, 14; 14, identifier:r; 15, import_statement; 15, 16; 16, dotted_name; 16, 17; 17, identifier:difflib; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:text1; 21, call; 21, 22; 21, 23; 22, identifier:ensure_unicode; 23, argument_list; 23, 24; 24, identifier:text1; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:text2; 28, call; 28, 29; 28, 30; 29, identifier:ensure_unicode; 30, argument_list; 30, 31; 31, identifier:text2; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:text1_lines; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:text1; 38, identifier:splitlines; 39, argument_list; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:text2_lines; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:text2; 46, identifier:splitlines; 47, argument_list; 48, if_statement; 48, 49; 48, 50; 48, 91; 49, identifier:ignore_whitespace; 50, block; 50, 51; 50, 63; 50, 75; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:text1_lines; 54, list_comprehension; 54, 55; 54, 60; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:t; 58, identifier:rstrip; 59, argument_list; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:t; 62, identifier:text1_lines; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:text2_lines; 66, list_comprehension; 66, 67; 66, 72; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:t; 70, identifier:rstrip; 71, argument_list; 72, for_in_clause; 72, 73; 72, 74; 73, identifier:t; 74, identifier:text2_lines; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:ndiff_kw; 78, call; 78, 79; 78, 80; 79, identifier:dict; 80, argument_list; 80, 81; 80, 86; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:linejunk; 83, attribute; 83, 84; 83, 85; 84, identifier:difflib; 85, identifier:IS_LINE_JUNK; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:charjunk; 88, attribute; 88, 89; 88, 90; 89, identifier:difflib; 90, identifier:IS_CHARACTER_JUNK; 91, else_clause; 91, 92; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:ndiff_kw; 96, dictionary; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:all_diff_lines; 100, call; 100, 101; 100, 102; 101, identifier:list; 102, argument_list; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:difflib; 106, identifier:ndiff; 107, argument_list; 107, 108; 107, 109; 107, 110; 108, identifier:text1_lines; 109, identifier:text2_lines; 110, dictionary_splat; 110, 111; 111, identifier:ndiff_kw; 112, if_statement; 112, 113; 112, 116; 112, 121; 113, comparison_operator:is; 113, 114; 113, 115; 114, identifier:num_context_lines; 115, None; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:diff_lines; 120, identifier:all_diff_lines; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 128; 122, 147; 122, 154; 122, 211; 122, 215; 123, import_from_statement; 123, 124; 123, 126; 124, dotted_name; 124, 125; 125, identifier:utool; 126, dotted_name; 126, 127; 127, identifier:util_list; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:ismarked_list; 131, list_comprehension; 131, 132; 131, 144; 132, boolean_operator:and; 132, 133; 132, 139; 133, comparison_operator:>; 133, 134; 133, 138; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, identifier:line; 138, integer:0; 139, comparison_operator:in; 139, 140; 139, 143; 140, subscript; 140, 141; 140, 142; 141, identifier:line; 142, integer:0; 143, string:'+-?'; 144, for_in_clause; 144, 145; 144, 146; 145, identifier:line; 146, identifier:all_diff_lines; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:isvalid_list; 150, subscript; 150, 151; 150, 152; 151, identifier:ismarked_list; 152, slice; 152, 153; 153, colon; 154, for_statement; 154, 155; 154, 156; 154, 163; 155, identifier:i; 156, call; 156, 157; 156, 158; 157, identifier:range; 158, argument_list; 158, 159; 158, 160; 159, integer:1; 160, binary_operator:+; 160, 161; 160, 162; 161, identifier:num_context_lines; 162, integer:1; 163, block; 163, 164; 163, 188; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 172; 166, subscript; 166, 167; 166, 168; 167, identifier:isvalid_list; 168, slice; 168, 169; 168, 170; 169, colon; 170, unary_operator:-; 170, 171; 171, identifier:i; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:util_list; 175, identifier:or_lists; 176, argument_list; 176, 177; 176, 183; 177, subscript; 177, 178; 177, 179; 178, identifier:isvalid_list; 179, slice; 179, 180; 179, 181; 180, colon; 181, unary_operator:-; 181, 182; 182, identifier:i; 183, subscript; 183, 184; 183, 185; 184, identifier:ismarked_list; 185, slice; 185, 186; 185, 187; 186, identifier:i; 187, colon; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 195; 190, subscript; 190, 191; 190, 192; 191, identifier:isvalid_list; 192, slice; 192, 193; 192, 194; 193, identifier:i; 194, colon; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:util_list; 198, identifier:or_lists; 199, argument_list; 199, 200; 199, 205; 200, subscript; 200, 201; 200, 202; 201, identifier:isvalid_list; 202, slice; 202, 203; 202, 204; 203, identifier:i; 204, colon; 205, subscript; 205, 206; 205, 207; 206, identifier:ismarked_list; 207, slice; 207, 208; 207, 209; 208, colon; 209, unary_operator:-; 209, 210; 210, identifier:i; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:USE_BREAK_LINE; 214, True; 215, if_statement; 215, 216; 215, 217; 215, 267; 216, identifier:USE_BREAK_LINE; 217, block; 217, 218; 217, 222; 217, 226; 217, 230; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:diff_lines; 221, list:[]; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:prev; 225, False; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 229; 228, identifier:visual_break; 229, string:'\n <... FILTERED CONTEXT ...> \n'; 230, for_statement; 230, 231; 230, 234; 230, 239; 231, pattern_list; 231, 232; 231, 233; 232, identifier:line; 233, identifier:valid; 234, call; 234, 235; 234, 236; 235, identifier:zip; 236, argument_list; 236, 237; 236, 238; 237, identifier:all_diff_lines; 238, identifier:isvalid_list; 239, block; 239, 240; 239, 263; 240, if_statement; 240, 241; 240, 242; 240, 250; 241, identifier:valid; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:diff_lines; 247, identifier:append; 248, argument_list; 248, 249; 249, identifier:line; 250, elif_clause; 250, 251; 250, 252; 251, identifier:prev; 252, block; 252, 253; 253, if_statement; 253, 254; 253, 255; 254, False; 255, block; 255, 256; 256, expression_statement; 256, 257; 257, call; 257, 258; 257, 261; 258, attribute; 258, 259; 258, 260; 259, identifier:diff_lines; 260, identifier:append; 261, argument_list; 261, 262; 262, identifier:visual_break; 263, expression_statement; 263, 264; 264, assignment; 264, 265; 264, 266; 265, identifier:prev; 266, identifier:valid; 267, else_clause; 267, 268; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:diff_lines; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:util_list; 275, identifier:compress; 276, argument_list; 276, 277; 276, 278; 277, identifier:all_diff_lines; 278, identifier:isvalid_list; 279, return_statement; 279, 280; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, string:'\n'; 283, identifier:join; 284, argument_list; 284, 285; 285, identifier:diff_lines | def get_textdiff(text1, text2, num_context_lines=0, ignore_whitespace=False):
r
import difflib
text1 = ensure_unicode(text1)
text2 = ensure_unicode(text2)
text1_lines = text1.splitlines()
text2_lines = text2.splitlines()
if ignore_whitespace:
text1_lines = [t.rstrip() for t in text1_lines]
text2_lines = [t.rstrip() for t in text2_lines]
ndiff_kw = dict(linejunk=difflib.IS_LINE_JUNK,
charjunk=difflib.IS_CHARACTER_JUNK)
else:
ndiff_kw = {}
all_diff_lines = list(difflib.ndiff(text1_lines, text2_lines, **ndiff_kw))
if num_context_lines is None:
diff_lines = all_diff_lines
else:
from utool import util_list
ismarked_list = [len(line) > 0 and line[0] in '+-?'
for line in all_diff_lines]
isvalid_list = ismarked_list[:]
for i in range(1, num_context_lines + 1):
isvalid_list[:-i] = util_list.or_lists(isvalid_list[:-i],
ismarked_list[i:])
isvalid_list[i:] = util_list.or_lists(isvalid_list[i:],
ismarked_list[:-i])
USE_BREAK_LINE = True
if USE_BREAK_LINE:
diff_lines = []
prev = False
visual_break = '\n <... FILTERED CONTEXT ...> \n'
for line, valid in zip(all_diff_lines, isvalid_list):
if valid:
diff_lines.append(line)
elif prev:
if False:
diff_lines.append(visual_break)
prev = valid
else:
diff_lines = util_list.compress(all_diff_lines, isvalid_list)
return '\n'.join(diff_lines) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:data; 6, default_parameter; 6, 7; 6, 8; 7, identifier:value; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:timestamp; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:namespace; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:debug; 17, False; 18, block; 18, 19; 18, 43; 18, 49; 18, 56; 18, 72; 18, 78; 18, 84; 18, 90; 18, 101; 18, 112; 18, 175; 18, 191; 18, 203; 18, 255; 18, 259; 18, 267; 18, 273; 18, 283; 18, 293; 18, 484; 18, 490; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:value; 22, None; 23, block; 23, 24; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:add; 29, argument_list; 29, 30; 29, 34; 29, 37; 29, 40; 30, tuple; 30, 31; 31, tuple; 31, 32; 31, 33; 32, identifier:data; 33, identifier:value; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:timestamp; 36, identifier:timestamp; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:namespace; 39, identifier:namespace; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:debug; 42, identifier:debug; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:writer; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:writer; 49, if_statement; 49, 50; 49, 53; 50, comparison_operator:is; 50, 51; 50, 52; 51, identifier:writer; 52, None; 53, block; 53, 54; 54, raise_statement; 54, 55; 55, identifier:GaugedUseAfterFreeError; 56, if_statement; 56, 57; 56, 60; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:timestamp; 59, None; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:timestamp; 64, call; 64, 65; 64, 66; 65, identifier:long; 66, argument_list; 66, 67; 67, binary_operator:*; 67, 68; 67, 71; 68, call; 68, 69; 68, 70; 69, identifier:time; 70, argument_list; 71, integer:1000; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:config; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:config; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:block_size; 81, attribute; 81, 82; 81, 83; 82, identifier:config; 83, identifier:block_size; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:this_block; 87, binary_operator://; 87, 88; 87, 89; 88, identifier:timestamp; 89, identifier:block_size; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:this_array; 93, binary_operator://; 93, 94; 93, 98; 94, parenthesized_expression; 94, 95; 95, binary_operator:%; 95, 96; 95, 97; 96, identifier:timestamp; 97, identifier:block_size; 98, attribute; 98, 99; 98, 100; 99, identifier:config; 100, identifier:resolution; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:namespace; 104, None; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:namespace; 109, attribute; 109, 110; 109, 111; 110, identifier:config; 111, identifier:namespace; 112, if_statement; 112, 113; 112, 132; 113, boolean_operator:or; 113, 114; 113, 119; 113, 120; 114, comparison_operator:<; 114, 115; 114, 116; 115, identifier:this_block; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:current_block; 119, line_continuation:\; 120, parenthesized_expression; 120, 121; 121, boolean_operator:and; 121, 122; 121, 127; 122, comparison_operator:==; 122, 123; 122, 124; 123, identifier:this_block; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:current_block; 127, comparison_operator:<; 127, 128; 127, 129; 128, identifier:this_array; 129, attribute; 129, 130; 129, 131; 130, identifier:self; 131, identifier:current_array; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 141; 133, 151; 133, 172; 134, comparison_operator:==; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:config; 137, identifier:append_only_violation; 138, attribute; 138, 139; 138, 140; 139, identifier:Writer; 140, identifier:ERROR; 141, block; 141, 142; 141, 146; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:msg; 145, string:'Gauged is append-only; timestamps must be increasing'; 146, raise_statement; 146, 147; 147, call; 147, 148; 147, 149; 148, identifier:GaugedAppendOnlyError; 149, argument_list; 149, 150; 150, identifier:msg; 151, elif_clause; 151, 152; 151, 159; 152, comparison_operator:==; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:config; 155, identifier:append_only_violation; 156, attribute; 156, 157; 156, 158; 157, identifier:Writer; 158, identifier:REWRITE; 159, block; 159, 160; 159, 166; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:this_block; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:current_block; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:this_array; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:current_array; 172, else_clause; 172, 173; 173, block; 173, 174; 174, return_statement; 175, if_statement; 175, 176; 175, 181; 176, call; 176, 177; 176, 178; 177, identifier:isinstance; 178, argument_list; 178, 179; 178, 180; 179, identifier:data; 180, identifier:unicode; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:data; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:data; 188, identifier:encode; 189, argument_list; 189, 190; 190, string:'utf8'; 191, if_statement; 191, 192; 191, 193; 192, identifier:debug; 193, block; 193, 194; 194, return_statement; 194, 195; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:debug; 199, argument_list; 199, 200; 199, 201; 199, 202; 200, identifier:timestamp; 201, identifier:namespace; 202, identifier:data; 203, if_statement; 203, 204; 203, 209; 203, 228; 204, comparison_operator:>; 204, 205; 204, 206; 205, identifier:this_block; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:current_block; 209, block; 209, 210; 209, 216; 209, 222; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:self; 214, identifier:flush_blocks; 215, argument_list; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:self; 220, identifier:current_block; 221, identifier:this_block; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:self; 226, identifier:current_array; 227, identifier:this_array; 228, elif_clause; 228, 229; 228, 234; 229, comparison_operator:>; 229, 230; 229, 231; 230, identifier:this_array; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:current_array; 234, block; 234, 235; 234, 249; 235, if_statement; 235, 236; 235, 246; 236, not_operator; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:Gauged; 240, identifier:writer_flush_arrays; 241, argument_list; 241, 242; 241, 243; 242, identifier:writer; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:current_array; 246, block; 246, 247; 247, raise_statement; 247, 248; 248, identifier:MemoryError; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:self; 253, identifier:current_array; 254, identifier:this_array; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:data_points; 258, integer:0; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:namespace_statistics; 262, subscript; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:self; 265, identifier:statistics; 266, identifier:namespace; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:whitelist; 270, attribute; 270, 271; 270, 272; 271, identifier:config; 272, identifier:key_whitelist; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:skip_long_keys; 276, comparison_operator:==; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:config; 279, identifier:key_overflow; 280, attribute; 280, 281; 280, 282; 281, identifier:Writer; 282, identifier:IGNORE; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:skip_gauge_nan; 286, comparison_operator:==; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:config; 289, identifier:gauge_nan; 290, attribute; 290, 291; 290, 292; 291, identifier:Writer; 292, identifier:IGNORE; 293, if_statement; 293, 294; 293, 308; 293, 339; 294, boolean_operator:and; 294, 295; 294, 305; 295, boolean_operator:and; 295, 296; 295, 303; 295, 304; 296, boolean_operator:and; 296, 297; 296, 302; 297, call; 297, 298; 297, 299; 298, identifier:isinstance; 299, argument_list; 299, 300; 299, 301; 300, identifier:data; 301, identifier:str; 302, identifier:skip_gauge_nan; 303, line_continuation:\; 304, identifier:skip_long_keys; 305, comparison_operator:is; 305, 306; 305, 307; 306, identifier:whitelist; 307, None; 308, block; 308, 309; 308, 316; 308, 333; 309, expression_statement; 309, 310; 310, assignment; 310, 311; 310, 312; 311, identifier:data_points; 312, call; 312, 313; 312, 314; 313, identifier:c_uint32; 314, argument_list; 314, 315; 315, integer:0; 316, if_statement; 316, 317; 316, 330; 317, not_operator; 317, 318; 318, call; 318, 319; 318, 322; 319, attribute; 319, 320; 319, 321; 320, identifier:Gauged; 321, identifier:writer_emit_pairs; 322, argument_list; 322, 323; 322, 324; 322, 325; 322, 326; 323, identifier:writer; 324, identifier:namespace; 325, identifier:data; 326, call; 326, 327; 326, 328; 327, identifier:byref; 328, argument_list; 328, 329; 329, identifier:data_points; 330, block; 330, 331; 331, raise_statement; 331, 332; 332, identifier:MemoryError; 333, expression_statement; 333, 334; 334, assignment; 334, 335; 334, 336; 335, identifier:data_points; 336, attribute; 336, 337; 336, 338; 337, identifier:data_points; 338, identifier:value; 339, else_clause; 339, 340; 340, block; 340, 341; 340, 372; 340, 378; 341, if_statement; 341, 342; 341, 347; 341, 356; 342, call; 342, 343; 342, 344; 343, identifier:isinstance; 344, argument_list; 344, 345; 344, 346; 345, identifier:data; 346, identifier:dict; 347, block; 347, 348; 348, expression_statement; 348, 349; 349, assignment; 349, 350; 349, 351; 350, identifier:data; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:data; 354, identifier:iteritems; 355, argument_list; 356, elif_clause; 356, 357; 356, 362; 357, call; 357, 358; 357, 359; 358, identifier:isinstance; 359, argument_list; 359, 360; 359, 361; 360, identifier:data; 361, identifier:str; 362, block; 362, 363; 363, expression_statement; 363, 364; 364, assignment; 364, 365; 364, 366; 365, identifier:data; 366, call; 366, 367; 366, 370; 367, attribute; 367, 368; 367, 369; 368, identifier:self; 369, identifier:parse_query; 370, argument_list; 370, 371; 371, identifier:data; 372, expression_statement; 372, 373; 373, assignment; 373, 374; 373, 375; 374, identifier:emit; 375, attribute; 375, 376; 375, 377; 376, identifier:Gauged; 377, identifier:writer_emit; 378, for_statement; 378, 379; 378, 382; 378, 383; 379, pattern_list; 379, 380; 379, 381; 380, identifier:key; 381, identifier:value; 382, identifier:data; 383, block; 383, 384; 383, 391; 383, 401; 383, 420; 383, 431; 383, 444; 383, 480; 384, expression_statement; 384, 385; 385, assignment; 385, 386; 385, 387; 386, identifier:key; 387, call; 387, 388; 387, 389; 388, identifier:to_bytes; 389, argument_list; 389, 390; 390, identifier:key; 391, if_statement; 391, 392; 391, 399; 392, boolean_operator:and; 392, 393; 392, 396; 393, comparison_operator:is; 393, 394; 393, 395; 394, identifier:whitelist; 395, None; 396, comparison_operator:not; 396, 397; 396, 398; 397, identifier:key; 398, identifier:whitelist; 399, block; 399, 400; 400, continue_statement; 401, try_statement; 401, 402; 401, 410; 402, block; 402, 403; 403, expression_statement; 403, 404; 404, assignment; 404, 405; 404, 406; 405, identifier:value; 406, call; 406, 407; 406, 408; 407, identifier:float; 408, argument_list; 408, 409; 409, identifier:value; 410, except_clause; 410, 411; 410, 412; 411, identifier:ValueError; 412, block; 412, 413; 413, expression_statement; 413, 414; 414, assignment; 414, 415; 414, 416; 415, identifier:value; 416, call; 416, 417; 416, 418; 417, identifier:float; 418, argument_list; 418, 419; 419, string:'nan'; 420, if_statement; 420, 421; 420, 424; 421, comparison_operator:!=; 421, 422; 421, 423; 422, identifier:value; 423, identifier:value; 424, block; 424, 425; 424, 429; 425, if_statement; 425, 426; 425, 427; 426, identifier:skip_gauge_nan; 427, block; 427, 428; 428, continue_statement; 429, raise_statement; 429, 430; 430, identifier:GaugedNaNError; 431, expression_statement; 431, 432; 432, assignment; 432, 433; 432, 434; 433, identifier:success; 434, call; 434, 435; 434, 436; 435, identifier:emit; 436, argument_list; 436, 437; 436, 438; 436, 439; 436, 440; 437, identifier:writer; 438, identifier:namespace; 439, identifier:key; 440, call; 440, 441; 440, 442; 441, identifier:c_float; 442, argument_list; 442, 443; 443, identifier:value; 444, if_statement; 444, 445; 444, 448; 445, comparison_operator:!=; 445, 446; 445, 447; 446, identifier:success; 447, integer:1; 448, block; 448, 449; 449, if_statement; 449, 450; 449, 452; 449, 455; 450, not_operator; 450, 451; 451, identifier:success; 452, block; 452, 453; 453, raise_statement; 453, 454; 454, identifier:MemoryError; 455, elif_clause; 455, 456; 455, 464; 456, boolean_operator:and; 456, 457; 456, 462; 457, comparison_operator:==; 457, 458; 457, 459; 458, identifier:success; 459, attribute; 459, 460; 459, 461; 460, identifier:Writer; 461, identifier:KEY_OVERFLOW; 462, not_operator; 462, 463; 463, identifier:skip_long_keys; 464, block; 464, 465; 464, 469; 464, 475; 465, expression_statement; 465, 466; 466, assignment; 466, 467; 466, 468; 467, identifier:msg; 468, string:'Key is larger than the driver allows '; 469, expression_statement; 469, 470; 470, augmented_assignment:+=; 470, 471; 470, 472; 471, identifier:msg; 472, binary_operator:%; 472, 473; 472, 474; 473, string:'(%s)'; 474, identifier:key; 475, raise_statement; 475, 476; 476, call; 476, 477; 476, 478; 477, identifier:GaugedKeyOverflowError; 478, argument_list; 478, 479; 479, identifier:msg; 480, expression_statement; 480, 481; 481, augmented_assignment:+=; 481, 482; 481, 483; 482, identifier:data_points; 483, integer:1; 484, expression_statement; 484, 485; 485, augmented_assignment:+=; 485, 486; 485, 489; 486, attribute; 486, 487; 486, 488; 487, identifier:namespace_statistics; 488, identifier:data_points; 489, identifier:data_points; 490, if_statement; 490, 491; 490, 494; 491, attribute; 491, 492; 491, 493; 492, identifier:self; 493, identifier:flush_now; 494, block; 494, 495; 495, expression_statement; 495, 496; 496, call; 496, 497; 496, 500; 497, attribute; 497, 498; 497, 499; 498, identifier:self; 499, identifier:flush; 500, argument_list | def add(self, data, value=None, timestamp=None, namespace=None,
debug=False):
if value is not None:
return self.add(((data, value),), timestamp=timestamp,
namespace=namespace, debug=debug)
writer = self.writer
if writer is None:
raise GaugedUseAfterFreeError
if timestamp is None:
timestamp = long(time() * 1000)
config = self.config
block_size = config.block_size
this_block = timestamp // block_size
this_array = (timestamp % block_size) // config.resolution
if namespace is None:
namespace = config.namespace
if this_block < self.current_block or \
(this_block == self.current_block and
this_array < self.current_array):
if config.append_only_violation == Writer.ERROR:
msg = 'Gauged is append-only; timestamps must be increasing'
raise GaugedAppendOnlyError(msg)
elif config.append_only_violation == Writer.REWRITE:
this_block = self.current_block
this_array = self.current_array
else:
return
if isinstance(data, unicode):
data = data.encode('utf8')
if debug:
return self.debug(timestamp, namespace, data)
if this_block > self.current_block:
self.flush_blocks()
self.current_block = this_block
self.current_array = this_array
elif this_array > self.current_array:
if not Gauged.writer_flush_arrays(writer, self.current_array):
raise MemoryError
self.current_array = this_array
data_points = 0
namespace_statistics = self.statistics[namespace]
whitelist = config.key_whitelist
skip_long_keys = config.key_overflow == Writer.IGNORE
skip_gauge_nan = config.gauge_nan == Writer.IGNORE
if isinstance(data, str) and skip_gauge_nan \
and skip_long_keys and whitelist is None:
data_points = c_uint32(0)
if not Gauged.writer_emit_pairs(writer, namespace, data,
byref(data_points)):
raise MemoryError
data_points = data_points.value
else:
if isinstance(data, dict):
data = data.iteritems()
elif isinstance(data, str):
data = self.parse_query(data)
emit = Gauged.writer_emit
for key, value in data:
key = to_bytes(key)
if whitelist is not None and key not in whitelist:
continue
try:
value = float(value)
except ValueError:
value = float('nan')
if value != value:
if skip_gauge_nan:
continue
raise GaugedNaNError
success = emit(writer, namespace, key, c_float(value))
if success != 1:
if not success:
raise MemoryError
elif success == Writer.KEY_OVERFLOW and not skip_long_keys:
msg = 'Key is larger than the driver allows '
msg += '(%s)' % key
raise GaugedKeyOverflowError(msg)
data_points += 1
namespace_statistics.data_points += data_points
if self.flush_now:
self.flush() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:generate_psms_quanted; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 11; 4, identifier:quantdb; 5, identifier:tsvfn; 6, identifier:isob_header; 7, identifier:oldheader; 8, default_parameter; 8, 9; 8, 10; 9, identifier:isobaric; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:precursor; 13, False; 14, block; 14, 15; 14, 27; 14, 34; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, pattern_list; 17, 18; 17, 19; 18, identifier:allquants; 19, identifier:sqlfields; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:quantdb; 23, identifier:select_all_psm_quants; 24, argument_list; 24, 25; 24, 26; 25, identifier:isobaric; 26, identifier:precursor; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:quant; 30, call; 30, 31; 30, 32; 31, identifier:next; 32, argument_list; 32, 33; 33, identifier:allquants; 34, for_statement; 34, 35; 34, 38; 34, 48; 35, pattern_list; 35, 36; 35, 37; 36, identifier:rownr; 37, identifier:psm; 38, call; 38, 39; 38, 40; 39, identifier:enumerate; 40, argument_list; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:readers; 44, identifier:generate_tsv_psms; 45, argument_list; 45, 46; 45, 47; 46, identifier:tsvfn; 47, identifier:oldheader; 48, block; 48, 49; 48, 65; 48, 100; 48, 177; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:outpsm; 52, dictionary_comprehension; 52, 53; 52, 56; 53, pair; 53, 54; 53, 55; 54, identifier:x; 55, identifier:y; 56, for_in_clause; 56, 57; 56, 60; 57, pattern_list; 57, 58; 57, 59; 58, identifier:x; 59, identifier:y; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:psm; 63, identifier:items; 64, argument_list; 65, if_statement; 65, 66; 65, 67; 66, identifier:precursor; 67, block; 67, 68; 67, 76; 67, 85; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:pquant; 71, subscript; 71, 72; 71, 73; 72, identifier:quant; 73, subscript; 73, 74; 73, 75; 74, identifier:sqlfields; 75, string:'precursor'; 76, if_statement; 76, 77; 76, 80; 77, comparison_operator:is; 77, 78; 77, 79; 78, identifier:pquant; 79, None; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:pquant; 84, string:'NA'; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:outpsm; 89, identifier:update; 90, argument_list; 90, 91; 91, dictionary; 91, 92; 92, pair; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:mzidtsvdata; 95, identifier:HEADER_PRECURSOR_QUANT; 96, call; 96, 97; 96, 98; 97, identifier:str; 98, argument_list; 98, 99; 99, identifier:pquant; 100, if_statement; 100, 101; 100, 102; 100, 159; 101, identifier:isobaric; 102, block; 102, 103; 102, 107; 102, 148; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:isoquants; 106, dictionary; 107, while_statement; 107, 108; 107, 113; 108, comparison_operator:==; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:quant; 111, integer:0; 112, identifier:rownr; 113, block; 113, 114; 113, 135; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:isoquants; 118, identifier:update; 119, argument_list; 119, 120; 120, dictionary; 120, 121; 121, pair; 121, 122; 121, 127; 122, subscript; 122, 123; 122, 124; 123, identifier:quant; 124, subscript; 124, 125; 124, 126; 125, identifier:sqlfields; 126, string:'isochan'; 127, call; 127, 128; 127, 129; 128, identifier:str; 129, argument_list; 129, 130; 130, subscript; 130, 131; 130, 132; 131, identifier:quant; 132, subscript; 132, 133; 132, 134; 133, identifier:sqlfields; 134, string:'isoquant'; 135, try_statement; 135, 136; 135, 144; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:quant; 140, call; 140, 141; 140, 142; 141, identifier:next; 142, argument_list; 142, 143; 143, identifier:allquants; 144, except_clause; 144, 145; 144, 146; 145, identifier:StopIteration; 146, block; 146, 147; 147, break_statement; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:outpsm; 152, identifier:update; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:get_quant_NAs; 156, argument_list; 156, 157; 156, 158; 157, identifier:isoquants; 158, identifier:isob_header; 159, else_clause; 159, 160; 160, block; 160, 161; 161, try_statement; 161, 162; 161, 170; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:quant; 166, call; 166, 167; 166, 168; 167, identifier:next; 168, argument_list; 168, 169; 169, identifier:allquants; 170, except_clause; 170, 171; 170, 172; 171, identifier:StopIteration; 172, block; 172, 173; 172, 176; 173, expression_statement; 173, 174; 174, yield; 174, 175; 175, identifier:outpsm; 176, break_statement; 177, expression_statement; 177, 178; 178, yield; 178, 179; 179, identifier:outpsm | def generate_psms_quanted(quantdb, tsvfn, isob_header, oldheader,
isobaric=False, precursor=False):
allquants, sqlfields = quantdb.select_all_psm_quants(isobaric, precursor)
quant = next(allquants)
for rownr, psm in enumerate(readers.generate_tsv_psms(tsvfn, oldheader)):
outpsm = {x: y for x, y in psm.items()}
if precursor:
pquant = quant[sqlfields['precursor']]
if pquant is None:
pquant = 'NA'
outpsm.update({mzidtsvdata.HEADER_PRECURSOR_QUANT: str(pquant)})
if isobaric:
isoquants = {}
while quant[0] == rownr:
isoquants.update({quant[sqlfields['isochan']]:
str(quant[sqlfields['isoquant']])})
try:
quant = next(allquants)
except StopIteration:
break
outpsm.update(get_quant_NAs(isoquants, isob_header))
else:
try:
quant = next(allquants)
except StopIteration:
yield outpsm
break
yield outpsm |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:total_purge_developed_repo; 3, parameters; 3, 4; 4, identifier:repodir; 5, block; 5, 6; 5, 8; 5, 12; 5, 17; 5, 20; 5, 33; 5, 41; 5, 86; 5, 106; 5, 111; 5, 121; 5, 140; 5, 148; 5, 156; 5, 201; 5, 216; 5, 235; 5, 357; 5, 372; 5, 375; 5, 383; 6, expression_statement; 6, 7; 7, identifier:r; 8, assert_statement; 8, 9; 9, comparison_operator:is; 9, 10; 9, 11; 10, identifier:repodir; 11, None; 12, import_statement; 12, 13; 13, aliased_import; 13, 14; 13, 16; 14, dotted_name; 14, 15; 15, identifier:utool; 16, identifier:ut; 17, import_statement; 17, 18; 18, dotted_name; 18, 19; 19, identifier:os; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:repo; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:ut; 27, identifier:util_git; 28, identifier:Repo; 29, argument_list; 29, 30; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:dpath; 32, identifier:repodir; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:user; 36, subscript; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:os; 39, identifier:environ; 40, string:'USER'; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:fmtdict; 44, call; 44, 45; 44, 46; 45, identifier:dict; 46, argument_list; 46, 47; 46, 50; 46, 55; 46, 60; 46, 65; 46, 72; 46, 79; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:user; 49, identifier:user; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:modname; 52, attribute; 52, 53; 52, 54; 53, identifier:repo; 54, identifier:modname; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:reponame; 57, attribute; 57, 58; 57, 59; 58, identifier:repo; 59, identifier:reponame; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:dpath; 62, attribute; 62, 63; 62, 64; 63, identifier:repo; 64, identifier:dpath; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:global_site_pkgs; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:ut; 70, identifier:get_global_dist_packages_dir; 71, argument_list; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:local_site_pkgs; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:ut; 77, identifier:get_local_dist_packages_dir; 78, argument_list; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:venv_site_pkgs; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:ut; 84, identifier:get_site_packages_dir; 85, argument_list; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:commands; 89, list_comprehension; 89, 90; 89, 97; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:_; 93, identifier:format; 94, argument_list; 94, 95; 95, dictionary_splat; 95, 96; 96, identifier:fmtdict; 97, for_in_clause; 97, 98; 97, 99; 98, identifier:_; 99, list:[
'pip uninstall {modname}',
'sudo -H pip uninstall {modname}',
'sudo pip uninstall {modname}',
'easy_install -m {modname}',
'cd {dpath} && python setup.py develop --uninstall',
'sudo chown -R {user}:{user} {dpath}',
]; 99, 100; 99, 101; 99, 102; 99, 103; 99, 104; 99, 105; 100, string:'pip uninstall {modname}'; 101, string:'sudo -H pip uninstall {modname}'; 102, string:'sudo pip uninstall {modname}'; 103, string:'easy_install -m {modname}'; 104, string:'cd {dpath} && python setup.py develop --uninstall'; 105, string:'sudo chown -R {user}:{user} {dpath}'; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:print; 109, argument_list; 109, 110; 110, string:'Normal uninstall commands'; 111, expression_statement; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:print; 114, argument_list; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, string:'\n'; 118, identifier:join; 119, argument_list; 119, 120; 120, identifier:commands; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:possible_link_paths; 124, list_comprehension; 124, 125; 124, 132; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:_; 128, identifier:format; 129, argument_list; 129, 130; 130, dictionary_splat; 130, 131; 131, identifier:fmtdict; 132, for_in_clause; 132, 133; 132, 134; 133, identifier:_; 134, list:[
'{dpath}/{modname}.egg-info',
'{dpath}/build',
'{venv_site_pkgs}/{reponame}.egg-info',
'{local_site_pkgs}/{reponame}.egg-info',
'{venv_site_pkgs}/{reponame}.egg-info',
]; 134, 135; 134, 136; 134, 137; 134, 138; 134, 139; 135, string:'{dpath}/{modname}.egg-info'; 136, string:'{dpath}/build'; 137, string:'{venv_site_pkgs}/{reponame}.egg-info'; 138, string:'{local_site_pkgs}/{reponame}.egg-info'; 139, string:'{venv_site_pkgs}/{reponame}.egg-info'; 140, import_from_statement; 140, 141; 140, 144; 140, 146; 141, dotted_name; 141, 142; 141, 143; 142, identifier:os; 143, identifier:path; 144, dotted_name; 144, 145; 145, identifier:exists; 146, dotted_name; 146, 147; 147, identifier:basename; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:existing_link_paths; 151, list_comprehension; 151, 152; 151, 153; 152, identifier:path; 153, for_in_clause; 153, 154; 153, 155; 154, identifier:path; 155, identifier:possible_link_paths; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 157, 165; 157, 167; 158, identifier:print; 159, ERROR; 159, 160; 159, 162; 160, ERROR; 160, 161; 161, identifier:for; 162, comparison_operator:in; 162, 163; 162, 164; 163, identifier:path; 164, identifier:existing_link_paths; 165, ERROR; 165, 166; 166, identifier:if; 167, type; 167, 168; 168, constrained_type; 168, 169; 168, 174; 168, 176; 169, type; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:exists; 172, argument_list; 172, 173; 173, identifier:path; 174, ERROR; 174, 175; 175, identifier:if; 176, type; 176, 177; 177, constrained_type; 177, 178; 177, 189; 178, type; 178, 179; 179, comparison_operator:!=; 179, 180; 179, 188; 180, subscript; 180, 181; 180, 187; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:ut; 184, identifier:get_file_info; 185, argument_list; 185, 186; 186, identifier:path; 187, string:'owner'; 188, identifier:user; 189, type; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:print; 192, argument_list; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, string:'sudo /bin/rm -rf {path}'; 196, identifier:format; 197, argument_list; 197, 198; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:path; 200, identifier:path; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:else; 204, type; 204, 205; 205, call; 205, 206; 205, 207; 206, identifier:print; 207, argument_list; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, string:'/bin/rm -rf {path}'; 211, identifier:format; 212, argument_list; 212, 213; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:path; 215, identifier:path; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 217, 221; 218, identifier:print; 219, ERROR; 219, 220; 220, identifier:easyinstall_paths; 221, list_comprehension; 221, 222; 221, 229; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:_; 225, identifier:format; 226, argument_list; 226, 227; 227, dictionary_splat; 227, 228; 228, identifier:fmtdict; 229, for_in_clause; 229, 230; 229, 231; 230, identifier:_; 231, list:[
'{venv_site_pkgs}/easy-install.pth',
'{local_site_pkgs}/easy-install.pth',
'{venv_site_pkgs}/easy-install.pth',
]; 231, 232; 231, 233; 231, 234; 232, string:'{venv_site_pkgs}/easy-install.pth'; 233, string:'{local_site_pkgs}/easy-install.pth'; 234, string:'{venv_site_pkgs}/easy-install.pth'; 235, for_statement; 235, 236; 235, 237; 235, 238; 236, identifier:path; 237, identifier:easyinstall_paths; 238, block; 238, 239; 239, if_statement; 239, 240; 239, 244; 240, call; 240, 241; 240, 242; 241, identifier:exists; 242, argument_list; 242, 243; 243, identifier:path; 244, block; 244, 245; 244, 266; 244, 277; 244, 289; 244, 301; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:easy_install_list; 248, call; 248, 249; 248, 264; 249, attribute; 249, 250; 249, 263; 250, call; 250, 251; 250, 262; 251, attribute; 251, 252; 251, 261; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:ut; 255, identifier:readfrom; 256, argument_list; 256, 257; 256, 258; 257, identifier:path; 258, keyword_argument; 258, 259; 258, 260; 259, identifier:verbose; 260, False; 261, identifier:strip; 262, argument_list; 263, identifier:split; 264, argument_list; 264, 265; 265, string:'\n'; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 269; 268, identifier:easy_install_list_; 269, list_comprehension; 269, 270; 269, 274; 270, call; 270, 271; 270, 272; 271, identifier:basename; 272, argument_list; 272, 273; 273, identifier:p; 274, for_in_clause; 274, 275; 274, 276; 275, identifier:p; 276, identifier:easy_install_list; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:index1; 280, call; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:ut; 283, identifier:listfind; 284, argument_list; 284, 285; 284, 286; 285, identifier:easy_install_list_; 286, attribute; 286, 287; 286, 288; 287, identifier:repo; 288, identifier:reponame; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 292; 291, identifier:index2; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, identifier:ut; 295, identifier:listfind; 296, argument_list; 296, 297; 296, 298; 297, identifier:easy_install_list_; 298, attribute; 298, 299; 298, 300; 299, identifier:repo; 300, identifier:modname; 301, if_statement; 301, 302; 301, 309; 302, boolean_operator:or; 302, 303; 302, 306; 303, comparison_operator:is; 303, 304; 303, 305; 304, identifier:index1; 305, None; 306, comparison_operator:is; 306, 307; 306, 308; 307, identifier:index2; 308, None; 309, block; 309, 310; 309, 319; 310, expression_statement; 310, 311; 311, call; 311, 312; 311, 313; 312, identifier:print; 313, argument_list; 313, 314; 314, binary_operator:%; 314, 315; 314, 316; 315, string:'Found at index1=%r, index=%r'; 316, tuple; 316, 317; 316, 318; 317, identifier:index1; 318, identifier:index2; 319, if_statement; 319, 320; 319, 330; 319, 343; 320, comparison_operator:!=; 320, 321; 320, 329; 321, subscript; 321, 322; 321, 328; 322, call; 322, 323; 322, 326; 323, attribute; 323, 324; 323, 325; 324, identifier:ut; 325, identifier:get_file_info; 326, argument_list; 326, 327; 327, identifier:path; 328, string:'owner'; 329, identifier:user; 330, block; 330, 331; 331, expression_statement; 331, 332; 332, call; 332, 333; 332, 334; 333, identifier:print; 334, argument_list; 334, 335; 335, call; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, string:'sudo gvim {path}'; 338, identifier:format; 339, argument_list; 339, 340; 340, keyword_argument; 340, 341; 340, 342; 341, identifier:path; 342, identifier:path; 343, else_clause; 343, 344; 344, block; 344, 345; 345, expression_statement; 345, 346; 346, call; 346, 347; 346, 348; 347, identifier:print; 348, argument_list; 348, 349; 349, call; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, string:'gvim {path}'; 352, identifier:format; 353, argument_list; 353, 354; 354, keyword_argument; 354, 355; 354, 356; 355, identifier:path; 356, identifier:path; 357, expression_statement; 357, 358; 358, assignment; 358, 359; 358, 360; 359, identifier:checkcmds; 360, list_comprehension; 360, 361; 360, 368; 361, call; 361, 362; 361, 365; 362, attribute; 362, 363; 362, 364; 363, identifier:_; 364, identifier:format; 365, argument_list; 365, 366; 366, dictionary_splat; 366, 367; 367, identifier:fmtdict; 368, for_in_clause; 368, 369; 368, 370; 369, identifier:_; 370, list:[
'python -c "import {modname}; print({modname}.__file__)"'
]; 370, 371; 371, string:'python -c "import {modname}; print({modname}.__file__)"'; 372, import_statement; 372, 373; 373, dotted_name; 373, 374; 374, identifier:sys; 375, assert_statement; 375, 376; 376, comparison_operator:not; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:repo; 379, identifier:modname; 380, attribute; 380, 381; 380, 382; 381, identifier:sys; 382, identifier:modules; 383, expression_statement; 383, 384; 384, assignment; 384, 385; 384, 386; 384, 392; 385, identifier:print; 386, ERROR; 386, 387; 386, 389; 387, ERROR; 387, 388; 388, identifier:for; 389, comparison_operator:in; 389, 390; 389, 391; 390, identifier:cmd; 391, identifier:checkcmds; 392, type; 392, 393; 393, call; 393, 394; 393, 395; 394, identifier:print; 395, argument_list; 395, 396; 396, identifier:cmd | def total_purge_developed_repo(repodir):
r
assert repodir is not None
import utool as ut
import os
repo = ut.util_git.Repo(dpath=repodir)
user = os.environ['USER']
fmtdict = dict(
user=user,
modname=repo.modname,
reponame=repo.reponame,
dpath=repo.dpath,
global_site_pkgs=ut.get_global_dist_packages_dir(),
local_site_pkgs=ut.get_local_dist_packages_dir(),
venv_site_pkgs=ut.get_site_packages_dir(),
)
commands = [_.format(**fmtdict) for _ in [
'pip uninstall {modname}',
'sudo -H pip uninstall {modname}',
'sudo pip uninstall {modname}',
'easy_install -m {modname}',
'cd {dpath} && python setup.py develop --uninstall',
'sudo chown -R {user}:{user} {dpath}',
]]
print('Normal uninstall commands')
print('\n'.join(commands))
possible_link_paths = [_.format(**fmtdict) for _ in [
'{dpath}/{modname}.egg-info',
'{dpath}/build',
'{venv_site_pkgs}/{reponame}.egg-info',
'{local_site_pkgs}/{reponame}.egg-info',
'{venv_site_pkgs}/{reponame}.egg-info',
]]
from os.path import exists, basename
existing_link_paths = [path for path in possible_link_paths]
print('
for path in existing_link_paths:
if exists(path):
if ut.get_file_info(path)['owner'] != user:
print('sudo /bin/rm -rf {path}'.format(path=path))
else:
print('/bin/rm -rf {path}'.format(path=path))
print('
easyinstall_paths = [_.format(**fmtdict) for _ in [
'{venv_site_pkgs}/easy-install.pth',
'{local_site_pkgs}/easy-install.pth',
'{venv_site_pkgs}/easy-install.pth',
]]
for path in easyinstall_paths:
if exists(path):
easy_install_list = ut.readfrom(path, verbose=False).strip().split('\n')
easy_install_list_ = [basename(p) for p in easy_install_list]
index1 = ut.listfind(easy_install_list_, repo.reponame)
index2 = ut.listfind(easy_install_list_, repo.modname)
if index1 is not None or index2 is not None:
print('Found at index1=%r, index=%r' % (index1, index2))
if ut.get_file_info(path)['owner'] != user:
print('sudo gvim {path}'.format(path=path))
else:
print('gvim {path}'.format(path=path))
checkcmds = [_.format(**fmtdict) for _ in [
'python -c "import {modname}; print({modname}.__file__)"'
]]
import sys
assert repo.modname not in sys.modules
print("
for cmd in checkcmds:
print(cmd) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:nx_dag_node_rank; 3, parameters; 3, 4; 3, 5; 4, identifier:graph; 5, default_parameter; 5, 6; 5, 7; 6, identifier:nodes; 7, None; 8, block; 8, 9; 8, 14; 8, 28; 8, 50; 8, 60; 9, import_statement; 9, 10; 10, aliased_import; 10, 11; 10, 13; 11, dotted_name; 11, 12; 12, identifier:utool; 13, identifier:ut; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:source; 17, subscript; 17, 18; 17, 27; 18, call; 18, 19; 18, 20; 19, identifier:list; 20, argument_list; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:ut; 24, identifier:nx_source_nodes; 25, argument_list; 25, 26; 26, identifier:graph; 27, integer:0; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:longest_paths; 31, call; 31, 32; 31, 33; 32, identifier:dict; 33, argument_list; 33, 34; 34, list_comprehension; 34, 35; 34, 43; 35, tuple; 35, 36; 35, 37; 36, identifier:target; 37, call; 37, 38; 37, 39; 38, identifier:dag_longest_path; 39, argument_list; 39, 40; 39, 41; 39, 42; 40, identifier:graph; 41, identifier:source; 42, identifier:target; 43, for_in_clause; 43, 44; 43, 45; 44, identifier:target; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:graph; 48, identifier:nodes; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:node_to_rank; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:ut; 56, identifier:map_dict_vals; 57, argument_list; 57, 58; 57, 59; 58, identifier:len; 59, identifier:longest_paths; 60, if_statement; 60, 61; 60, 64; 60, 67; 61, comparison_operator:is; 61, 62; 61, 63; 62, identifier:nodes; 63, None; 64, block; 64, 65; 65, return_statement; 65, 66; 66, identifier:node_to_rank; 67, else_clause; 67, 68; 68, block; 68, 69; 68, 79; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:ranks; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:ut; 75, identifier:dict_take; 76, argument_list; 76, 77; 76, 78; 77, identifier:node_to_rank; 78, identifier:nodes; 79, return_statement; 79, 80; 80, identifier:ranks | def nx_dag_node_rank(graph, nodes=None):
import utool as ut
source = list(ut.nx_source_nodes(graph))[0]
longest_paths = dict([(target, dag_longest_path(graph, source, target))
for target in graph.nodes()])
node_to_rank = ut.map_dict_vals(len, longest_paths)
if nodes is None:
return node_to_rank
else:
ranks = ut.dict_take(node_to_rank, nodes)
return ranks |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:nx_all_simple_edge_paths; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 4, identifier:G; 5, identifier:source; 6, identifier:target; 7, default_parameter; 7, 8; 7, 9; 8, identifier:cutoff; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:keys; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:data; 15, False; 16, block; 16, 17; 16, 31; 16, 37; 16, 42; 16, 45; 16, 50; 16, 54; 16, 94; 16, 105; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:cutoff; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:cutoff; 25, binary_operator:-; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:G; 30, integer:1; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:<; 32, 33; 32, 34; 33, identifier:cutoff; 34, integer:1; 35, block; 35, 36; 36, return_statement; 37, import_statement; 37, 38; 38, aliased_import; 38, 39; 38, 41; 39, dotted_name; 39, 40; 40, identifier:utool; 41, identifier:ut; 42, import_statement; 42, 43; 43, dotted_name; 43, 44; 44, identifier:six; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:visited_nodes; 48, list:[source]; 48, 49; 49, identifier:source; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:visited_edges; 53, list:[]; 54, if_statement; 54, 55; 54, 60; 54, 78; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:G; 58, identifier:is_multigraph; 59, argument_list; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:get_neighbs; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:ut; 67, identifier:partial; 68, argument_list; 68, 69; 68, 72; 68, 75; 69, attribute; 69, 70; 69, 71; 70, identifier:G; 71, identifier:edges; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:keys; 74, identifier:keys; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:data; 77, identifier:data; 78, else_clause; 78, 79; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:get_neighbs; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:ut; 86, identifier:partial; 87, argument_list; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:G; 90, identifier:edges; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:data; 93, identifier:data; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:edge_stack; 97, list:[iter(get_neighbs(source))]; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:iter; 100, argument_list; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:get_neighbs; 103, argument_list; 103, 104; 104, identifier:source; 105, while_statement; 105, 106; 105, 107; 106, identifier:edge_stack; 107, block; 107, 108; 107, 115; 107, 125; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:children_edges; 111, subscript; 111, 112; 111, 113; 112, identifier:edge_stack; 113, unary_operator:-; 113, 114; 114, integer:1; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:child_edge; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:six; 121, identifier:next; 122, argument_list; 122, 123; 122, 124; 123, identifier:children_edges; 124, None; 125, if_statement; 125, 126; 125, 129; 125, 156; 125, 213; 126, comparison_operator:is; 126, 127; 126, 128; 127, identifier:child_edge; 128, None; 129, block; 129, 130; 129, 136; 129, 142; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:edge_stack; 134, identifier:pop; 135, argument_list; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:visited_nodes; 140, identifier:pop; 141, argument_list; 142, if_statement; 142, 143; 142, 149; 143, comparison_operator:>; 143, 144; 143, 148; 144, call; 144, 145; 144, 146; 145, identifier:len; 146, argument_list; 146, 147; 147, identifier:visited_edges; 148, integer:0; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:visited_edges; 154, identifier:pop; 155, argument_list; 156, elif_clause; 156, 157; 156, 163; 157, comparison_operator:<; 157, 158; 157, 162; 158, call; 158, 159; 158, 160; 159, identifier:len; 160, argument_list; 160, 161; 161, identifier:visited_nodes; 162, identifier:cutoff; 163, block; 163, 164; 163, 170; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:child_node; 167, subscript; 167, 168; 167, 169; 168, identifier:child_edge; 169, integer:1; 170, if_statement; 170, 171; 170, 174; 170, 181; 171, comparison_operator:==; 171, 172; 171, 173; 172, identifier:child_node; 173, identifier:target; 174, block; 174, 175; 175, expression_statement; 175, 176; 176, yield; 176, 177; 177, binary_operator:+; 177, 178; 177, 179; 178, identifier:visited_edges; 179, list:[child_edge]; 179, 180; 180, identifier:child_edge; 181, elif_clause; 181, 182; 181, 185; 182, comparison_operator:not; 182, 183; 182, 184; 183, identifier:child_node; 184, identifier:visited_nodes; 185, block; 185, 186; 185, 193; 185, 200; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:visited_nodes; 190, identifier:append; 191, argument_list; 191, 192; 192, identifier:child_node; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:visited_edges; 197, identifier:append; 198, argument_list; 198, 199; 199, identifier:child_edge; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:edge_stack; 204, identifier:append; 205, argument_list; 205, 206; 206, call; 206, 207; 206, 208; 207, identifier:iter; 208, argument_list; 208, 209; 209, call; 209, 210; 209, 211; 210, identifier:get_neighbs; 211, argument_list; 211, 212; 212, identifier:child_node; 213, else_clause; 213, 214; 214, block; 214, 215; 214, 238; 214, 244; 214, 250; 215, for_statement; 215, 216; 215, 217; 215, 224; 216, identifier:edge; 217, binary_operator:+; 217, 218; 217, 220; 218, list:[child_edge]; 218, 219; 219, identifier:child_edge; 220, call; 220, 221; 220, 222; 221, identifier:list; 222, argument_list; 222, 223; 223, identifier:children_edges; 224, block; 224, 225; 225, if_statement; 225, 226; 225, 231; 226, comparison_operator:==; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:edge; 229, integer:1; 230, identifier:target; 231, block; 231, 232; 232, expression_statement; 232, 233; 233, yield; 233, 234; 234, binary_operator:+; 234, 235; 234, 236; 235, identifier:visited_edges; 236, list:[edge]; 236, 237; 237, identifier:edge; 238, expression_statement; 238, 239; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:edge_stack; 242, identifier:pop; 243, argument_list; 244, expression_statement; 244, 245; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:visited_nodes; 248, identifier:pop; 249, argument_list; 250, if_statement; 250, 251; 250, 257; 251, comparison_operator:>; 251, 252; 251, 256; 252, call; 252, 253; 252, 254; 253, identifier:len; 254, argument_list; 254, 255; 255, identifier:visited_edges; 256, integer:0; 257, block; 257, 258; 258, expression_statement; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:visited_edges; 262, identifier:pop; 263, argument_list | def nx_all_simple_edge_paths(G, source, target, cutoff=None, keys=False,
data=False):
if cutoff is None:
cutoff = len(G) - 1
if cutoff < 1:
return
import utool as ut
import six
visited_nodes = [source]
visited_edges = []
if G.is_multigraph():
get_neighbs = ut.partial(G.edges, keys=keys, data=data)
else:
get_neighbs = ut.partial(G.edges, data=data)
edge_stack = [iter(get_neighbs(source))]
while edge_stack:
children_edges = edge_stack[-1]
child_edge = six.next(children_edges, None)
if child_edge is None:
edge_stack.pop()
visited_nodes.pop()
if len(visited_edges) > 0:
visited_edges.pop()
elif len(visited_nodes) < cutoff:
child_node = child_edge[1]
if child_node == target:
yield visited_edges + [child_edge]
elif child_node not in visited_nodes:
visited_nodes.append(child_node)
visited_edges.append(child_edge)
edge_stack.append(iter(get_neighbs(child_node)))
else:
for edge in [child_edge] + list(children_edges):
if edge[1] == target:
yield visited_edges + [edge]
edge_stack.pop()
visited_nodes.pop()
if len(visited_edges) > 0:
visited_edges.pop() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:nx_gen_node_attrs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 14; 3, 17; 4, identifier:G; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:nodes; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:default; 11, attribute; 11, 12; 11, 13; 12, identifier:util_const; 13, identifier:NoParam; 14, default_parameter; 14, 15; 14, 16; 15, identifier:on_missing; 16, string:'error'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:on_keyerr; 19, string:'default'; 20, block; 20, 21; 20, 30; 20, 45; 20, 58; 20, 65; 20, 136; 20, 213; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:on_missing; 24, None; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:on_missing; 29, string:'error'; 30, if_statement; 30, 31; 30, 40; 31, boolean_operator:and; 31, 32; 31, 37; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:default; 34, attribute; 34, 35; 34, 36; 35, identifier:util_const; 36, identifier:NoParam; 37, comparison_operator:==; 37, 38; 37, 39; 38, identifier:on_keyerr; 39, string:'default'; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:on_keyerr; 44, string:'error'; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:nodes; 48, None; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:nodes; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:G; 56, identifier:nodes; 57, argument_list; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:node_dict; 61, call; 61, 62; 61, 63; 62, identifier:nx_node_dict; 63, argument_list; 63, 64; 64, identifier:G; 65, if_statement; 65, 66; 65, 69; 65, 82; 65, 103; 65, 124; 66, comparison_operator:==; 66, 67; 66, 68; 67, identifier:on_missing; 68, string:'error'; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:node_data; 73, generator_expression; 73, 74; 73, 79; 74, tuple; 74, 75; 74, 76; 75, identifier:n; 76, subscript; 76, 77; 76, 78; 77, identifier:node_dict; 78, identifier:n; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:n; 81, identifier:nodes; 82, elif_clause; 82, 83; 82, 86; 83, comparison_operator:==; 83, 84; 83, 85; 84, identifier:on_missing; 85, string:'filter'; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:node_data; 90, generator_expression; 90, 91; 90, 96; 90, 99; 91, tuple; 91, 92; 91, 93; 92, identifier:n; 93, subscript; 93, 94; 93, 95; 94, identifier:node_dict; 95, identifier:n; 96, for_in_clause; 96, 97; 96, 98; 97, identifier:n; 98, identifier:nodes; 99, if_clause; 99, 100; 100, comparison_operator:in; 100, 101; 100, 102; 101, identifier:n; 102, identifier:G; 103, elif_clause; 103, 104; 103, 107; 104, comparison_operator:==; 104, 105; 104, 106; 105, identifier:on_missing; 106, string:'default'; 107, block; 107, 108; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:node_data; 111, generator_expression; 111, 112; 111, 121; 112, tuple; 112, 113; 112, 114; 113, identifier:n; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:node_dict; 117, identifier:get; 118, argument_list; 118, 119; 118, 120; 119, identifier:n; 120, dictionary; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:n; 123, identifier:nodes; 124, else_clause; 124, 125; 125, block; 125, 126; 126, raise_statement; 126, 127; 127, call; 127, 128; 127, 129; 128, identifier:KeyError; 129, argument_list; 129, 130; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, string:'on_missing={} must be error, filter or default'; 133, identifier:format; 134, argument_list; 134, 135; 135, identifier:on_missing; 136, if_statement; 136, 137; 136, 140; 136, 155; 136, 178; 136, 201; 137, comparison_operator:==; 137, 138; 137, 139; 138, identifier:on_keyerr; 139, string:'error'; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:node_attrs; 144, generator_expression; 144, 145; 144, 150; 145, tuple; 145, 146; 145, 147; 146, identifier:n; 147, subscript; 147, 148; 147, 149; 148, identifier:d; 149, identifier:key; 150, for_in_clause; 150, 151; 150, 154; 151, pattern_list; 151, 152; 151, 153; 152, identifier:n; 153, identifier:d; 154, identifier:node_data; 155, elif_clause; 155, 156; 155, 159; 156, comparison_operator:==; 156, 157; 156, 158; 157, identifier:on_keyerr; 158, string:'filter'; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:node_attrs; 163, generator_expression; 163, 164; 163, 169; 163, 174; 164, tuple; 164, 165; 164, 166; 165, identifier:n; 166, subscript; 166, 167; 166, 168; 167, identifier:d; 168, identifier:key; 169, for_in_clause; 169, 170; 169, 173; 170, pattern_list; 170, 171; 170, 172; 171, identifier:n; 172, identifier:d; 173, identifier:node_data; 174, if_clause; 174, 175; 175, comparison_operator:in; 175, 176; 175, 177; 176, identifier:key; 177, identifier:d; 178, elif_clause; 178, 179; 178, 182; 179, comparison_operator:==; 179, 180; 179, 181; 180, identifier:on_keyerr; 181, string:'default'; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:node_attrs; 186, generator_expression; 186, 187; 186, 196; 187, tuple; 187, 188; 187, 189; 188, identifier:n; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:d; 192, identifier:get; 193, argument_list; 193, 194; 193, 195; 194, identifier:key; 195, identifier:default; 196, for_in_clause; 196, 197; 196, 200; 197, pattern_list; 197, 198; 197, 199; 198, identifier:n; 199, identifier:d; 200, identifier:node_data; 201, else_clause; 201, 202; 202, block; 202, 203; 203, raise_statement; 203, 204; 204, call; 204, 205; 204, 206; 205, identifier:KeyError; 206, argument_list; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, string:'on_keyerr={} must be error filter or default'; 210, identifier:format; 211, argument_list; 211, 212; 212, identifier:on_keyerr; 213, return_statement; 213, 214; 214, identifier:node_attrs | def nx_gen_node_attrs(G, key, nodes=None, default=util_const.NoParam,
on_missing='error', on_keyerr='default'):
if on_missing is None:
on_missing = 'error'
if default is util_const.NoParam and on_keyerr == 'default':
on_keyerr = 'error'
if nodes is None:
nodes = G.nodes()
node_dict = nx_node_dict(G)
if on_missing == 'error':
node_data = ((n, node_dict[n]) for n in nodes)
elif on_missing == 'filter':
node_data = ((n, node_dict[n]) for n in nodes if n in G)
elif on_missing == 'default':
node_data = ((n, node_dict.get(n, {})) for n in nodes)
else:
raise KeyError('on_missing={} must be error, filter or default'.format(
on_missing))
if on_keyerr == 'error':
node_attrs = ((n, d[key]) for n, d in node_data)
elif on_keyerr == 'filter':
node_attrs = ((n, d[key]) for n, d in node_data if key in d)
elif on_keyerr == 'default':
node_attrs = ((n, d.get(key, default)) for n, d in node_data)
else:
raise KeyError('on_keyerr={} must be error filter or default'.format(on_keyerr))
return node_attrs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:nx_gen_edge_values; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 14; 3, 17; 4, identifier:G; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:edges; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:default; 11, attribute; 11, 12; 11, 13; 12, identifier:util_const; 13, identifier:NoParam; 14, default_parameter; 14, 15; 14, 16; 15, identifier:on_missing; 16, string:'error'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:on_keyerr; 19, string:'default'; 20, block; 20, 21; 20, 34; 20, 43; 20, 52; 20, 67; 20, 130; 20, 176; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:edges; 24, None; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:edges; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:G; 32, identifier:edges; 33, argument_list; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:is; 35, 36; 35, 37; 36, identifier:on_missing; 37, None; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:on_missing; 42, string:'error'; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:is; 44, 45; 44, 46; 45, identifier:on_keyerr; 46, None; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:on_keyerr; 51, string:'default'; 52, if_statement; 52, 53; 52, 62; 53, boolean_operator:and; 53, 54; 53, 59; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:default; 56, attribute; 56, 57; 56, 58; 57, identifier:util_const; 58, identifier:NoParam; 59, comparison_operator:==; 59, 60; 59, 61; 60, identifier:on_keyerr; 61, string:'default'; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:on_keyerr; 66, string:'error'; 67, if_statement; 67, 68; 67, 71; 67, 88; 67, 118; 68, comparison_operator:==; 68, 69; 68, 70; 69, identifier:on_missing; 70, string:'error'; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:data_iter; 75, generator_expression; 75, 76; 75, 83; 76, subscript; 76, 77; 76, 82; 77, subscript; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:G; 80, identifier:adj; 81, identifier:u; 82, identifier:v; 83, for_in_clause; 83, 84; 83, 87; 84, pattern_list; 84, 85; 84, 86; 85, identifier:u; 86, identifier:v; 87, identifier:edges; 88, elif_clause; 88, 89; 88, 92; 89, comparison_operator:==; 89, 90; 89, 91; 90, identifier:on_missing; 91, string:'default'; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:data_iter; 96, generator_expression; 96, 97; 96, 113; 97, conditional_expression:if; 97, 98; 97, 105; 97, 112; 98, subscript; 98, 99; 98, 104; 99, subscript; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:G; 102, identifier:adj; 103, identifier:u; 104, identifier:v; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:G; 108, identifier:has_edge; 109, argument_list; 109, 110; 109, 111; 110, identifier:u; 111, identifier:v; 112, dictionary; 113, for_in_clause; 113, 114; 113, 117; 114, pattern_list; 114, 115; 114, 116; 115, identifier:u; 116, identifier:v; 117, identifier:edges; 118, else_clause; 118, 119; 119, block; 119, 120; 120, raise_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:KeyError; 123, argument_list; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, string:'on_missing={} must be error, filter or default'; 127, identifier:format; 128, argument_list; 128, 129; 129, identifier:on_missing; 130, if_statement; 130, 131; 130, 134; 130, 145; 130, 164; 131, comparison_operator:==; 131, 132; 131, 133; 132, identifier:on_keyerr; 133, string:'error'; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:value_iter; 138, generator_expression; 138, 139; 138, 142; 139, subscript; 139, 140; 139, 141; 140, identifier:d; 141, identifier:key; 142, for_in_clause; 142, 143; 142, 144; 143, identifier:d; 144, identifier:data_iter; 145, elif_clause; 145, 146; 145, 149; 146, comparison_operator:==; 146, 147; 146, 148; 147, identifier:on_keyerr; 148, string:'default'; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:value_iter; 153, generator_expression; 153, 154; 153, 161; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:d; 157, identifier:get; 158, argument_list; 158, 159; 158, 160; 159, identifier:key; 160, identifier:default; 161, for_in_clause; 161, 162; 161, 163; 162, identifier:d; 163, identifier:data_iter; 164, else_clause; 164, 165; 165, block; 165, 166; 166, raise_statement; 166, 167; 167, call; 167, 168; 167, 169; 168, identifier:KeyError; 169, argument_list; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, string:'on_keyerr={} must be error or default'; 173, identifier:format; 174, argument_list; 174, 175; 175, identifier:on_keyerr; 176, return_statement; 176, 177; 177, identifier:value_iter | def nx_gen_edge_values(G, key, edges=None, default=util_const.NoParam,
on_missing='error', on_keyerr='default'):
if edges is None:
edges = G.edges()
if on_missing is None:
on_missing = 'error'
if on_keyerr is None:
on_keyerr = 'default'
if default is util_const.NoParam and on_keyerr == 'default':
on_keyerr = 'error'
if on_missing == 'error':
data_iter = (G.adj[u][v] for u, v in edges)
elif on_missing == 'default':
data_iter = (G.adj[u][v] if G.has_edge(u, v) else {}
for u, v in edges)
else:
raise KeyError('on_missing={} must be error, filter or default'.format(
on_missing))
if on_keyerr == 'error':
value_iter = (d[key] for d in data_iter)
elif on_keyerr == 'default':
value_iter = (d.get(key, default) for d in data_iter)
else:
raise KeyError('on_keyerr={} must be error or default'.format(on_keyerr))
return value_iter |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:nx_gen_edge_attrs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 14; 3, 17; 4, identifier:G; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:edges; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:default; 11, attribute; 11, 12; 11, 13; 12, identifier:util_const; 13, identifier:NoParam; 14, default_parameter; 14, 15; 14, 16; 15, identifier:on_missing; 16, string:'error'; 17, default_parameter; 17, 18; 17, 19; 18, identifier:on_keyerr; 19, string:'default'; 20, block; 20, 21; 20, 30; 20, 45; 20, 72; 20, 180; 20, 257; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:on_missing; 24, None; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:on_missing; 29, string:'error'; 30, if_statement; 30, 31; 30, 40; 31, boolean_operator:and; 31, 32; 31, 37; 32, comparison_operator:is; 32, 33; 32, 34; 33, identifier:default; 34, attribute; 34, 35; 34, 36; 35, identifier:util_const; 36, identifier:NoParam; 37, comparison_operator:==; 37, 38; 37, 39; 38, identifier:on_keyerr; 39, string:'default'; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:on_keyerr; 44, string:'error'; 45, if_statement; 45, 46; 45, 49; 46, comparison_operator:is; 46, 47; 46, 48; 47, identifier:edges; 48, None; 49, block; 49, 50; 50, if_statement; 50, 51; 50, 56; 50, 62; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:G; 54, identifier:is_multigraph; 55, argument_list; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:NotImplementedError; 60, argument_list; 60, 61; 61, string:''; 62, else_clause; 62, 63; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:edges; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:G; 70, identifier:edges; 71, argument_list; 72, if_statement; 72, 73; 72, 76; 72, 97; 72, 130; 72, 168; 73, comparison_operator:==; 73, 74; 73, 75; 74, identifier:on_missing; 75, string:'error'; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:edge_data; 80, generator_expression; 80, 81; 80, 92; 81, tuple; 81, 82; 81, 85; 82, tuple; 82, 83; 82, 84; 83, identifier:u; 84, identifier:v; 85, subscript; 85, 86; 85, 91; 86, subscript; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:G; 89, identifier:adj; 90, identifier:u; 91, identifier:v; 92, for_in_clause; 92, 93; 92, 96; 93, pattern_list; 93, 94; 93, 95; 94, identifier:u; 95, identifier:v; 96, identifier:edges; 97, elif_clause; 97, 98; 97, 101; 98, comparison_operator:==; 98, 99; 98, 100; 99, identifier:on_missing; 100, string:'filter'; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:edge_data; 105, generator_expression; 105, 106; 105, 117; 105, 122; 106, tuple; 106, 107; 106, 110; 107, tuple; 107, 108; 107, 109; 108, identifier:u; 109, identifier:v; 110, subscript; 110, 111; 110, 116; 111, subscript; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:G; 114, identifier:adj; 115, identifier:u; 116, identifier:v; 117, for_in_clause; 117, 118; 117, 121; 118, pattern_list; 118, 119; 118, 120; 119, identifier:u; 120, identifier:v; 121, identifier:edges; 122, if_clause; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:G; 126, identifier:has_edge; 127, argument_list; 127, 128; 127, 129; 128, identifier:u; 129, identifier:v; 130, elif_clause; 130, 131; 130, 134; 131, comparison_operator:==; 131, 132; 131, 133; 132, identifier:on_missing; 133, string:'default'; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:edge_data; 138, generator_expression; 138, 139; 138, 163; 139, conditional_expression:if; 139, 140; 139, 151; 139, 158; 140, tuple; 140, 141; 140, 144; 141, tuple; 141, 142; 141, 143; 142, identifier:u; 143, identifier:v; 144, subscript; 144, 145; 144, 150; 145, subscript; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:G; 148, identifier:adj; 149, identifier:u; 150, identifier:v; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:G; 154, identifier:has_edge; 155, argument_list; 155, 156; 155, 157; 156, identifier:u; 157, identifier:v; 158, tuple; 158, 159; 158, 162; 159, tuple; 159, 160; 159, 161; 160, identifier:u; 161, identifier:v; 162, dictionary; 163, for_in_clause; 163, 164; 163, 167; 164, pattern_list; 164, 165; 164, 166; 165, identifier:u; 166, identifier:v; 167, identifier:edges; 168, else_clause; 168, 169; 169, block; 169, 170; 170, raise_statement; 170, 171; 171, call; 171, 172; 171, 173; 172, identifier:KeyError; 173, argument_list; 173, 174; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, string:'on_missing={}'; 177, identifier:format; 178, argument_list; 178, 179; 179, identifier:on_missing; 180, if_statement; 180, 181; 180, 184; 180, 199; 180, 222; 180, 245; 181, comparison_operator:==; 181, 182; 181, 183; 182, identifier:on_keyerr; 183, string:'error'; 184, block; 184, 185; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:edge_attrs; 188, generator_expression; 188, 189; 188, 194; 189, tuple; 189, 190; 189, 191; 190, identifier:e; 191, subscript; 191, 192; 191, 193; 192, identifier:d; 193, identifier:key; 194, for_in_clause; 194, 195; 194, 198; 195, pattern_list; 195, 196; 195, 197; 196, identifier:e; 197, identifier:d; 198, identifier:edge_data; 199, elif_clause; 199, 200; 199, 203; 200, comparison_operator:==; 200, 201; 200, 202; 201, identifier:on_keyerr; 202, string:'filter'; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:edge_attrs; 207, generator_expression; 207, 208; 207, 213; 207, 218; 208, tuple; 208, 209; 208, 210; 209, identifier:e; 210, subscript; 210, 211; 210, 212; 211, identifier:d; 212, identifier:key; 213, for_in_clause; 213, 214; 213, 217; 214, pattern_list; 214, 215; 214, 216; 215, identifier:e; 216, identifier:d; 217, identifier:edge_data; 218, if_clause; 218, 219; 219, comparison_operator:in; 219, 220; 219, 221; 220, identifier:key; 221, identifier:d; 222, elif_clause; 222, 223; 222, 226; 223, comparison_operator:==; 223, 224; 223, 225; 224, identifier:on_keyerr; 225, string:'default'; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:edge_attrs; 230, generator_expression; 230, 231; 230, 240; 231, tuple; 231, 232; 231, 233; 232, identifier:e; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:d; 236, identifier:get; 237, argument_list; 237, 238; 237, 239; 238, identifier:key; 239, identifier:default; 240, for_in_clause; 240, 241; 240, 244; 241, pattern_list; 241, 242; 241, 243; 242, identifier:e; 243, identifier:d; 244, identifier:edge_data; 245, else_clause; 245, 246; 246, block; 246, 247; 247, raise_statement; 247, 248; 248, call; 248, 249; 248, 250; 249, identifier:KeyError; 250, argument_list; 250, 251; 251, call; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, string:'on_keyerr={}'; 254, identifier:format; 255, argument_list; 255, 256; 256, identifier:on_keyerr; 257, return_statement; 257, 258; 258, identifier:edge_attrs | def nx_gen_edge_attrs(G, key, edges=None, default=util_const.NoParam,
on_missing='error', on_keyerr='default'):
if on_missing is None:
on_missing = 'error'
if default is util_const.NoParam and on_keyerr == 'default':
on_keyerr = 'error'
if edges is None:
if G.is_multigraph():
raise NotImplementedError('')
else:
edges = G.edges()
if on_missing == 'error':
edge_data = (((u, v), G.adj[u][v]) for u, v in edges)
elif on_missing == 'filter':
edge_data = (((u, v), G.adj[u][v]) for u, v in edges if G.has_edge(u, v))
elif on_missing == 'default':
edge_data = (((u, v), G.adj[u][v])
if G.has_edge(u, v) else ((u, v), {})
for u, v in edges)
else:
raise KeyError('on_missing={}'.format(on_missing))
if on_keyerr == 'error':
edge_attrs = ((e, d[key]) for e, d in edge_data)
elif on_keyerr == 'filter':
edge_attrs = ((e, d[key]) for e, d in edge_data if key in d)
elif on_keyerr == 'default':
edge_attrs = ((e, d.get(key, default)) for e, d in edge_data)
else:
raise KeyError('on_keyerr={}'.format(on_keyerr))
return edge_attrs |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 3; 1, 5; 1, 10; 1, 15; 1, 16; 1, 18; 1, 188; 1, 199; 2, identifier:nx_ensure_agraph_color; 3, parameters; 3, 4; 4, identifier:graph; 5, import_from_statement; 5, 6; 5, 8; 6, dotted_name; 6, 7; 7, identifier:plottool; 8, dotted_name; 8, 9; 9, identifier:color_funcs; 10, import_statement; 10, 11; 11, aliased_import; 11, 12; 11, 14; 12, dotted_name; 12, 13; 13, identifier:plottool; 14, identifier:pt; 15, identifier:_fix_agraph_color; 16, parameters; 16, 17; 17, identifier:data; 18, ERROR; 18, 19; 18, 176; 19, ERROR; 19, 20; 19, 174; 19, 175; 20, block; 20, 21; 20, 31; 20, 41; 20, 45; 20, 61; 20, 155; 20, 160; 20, 173; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:orig_color; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:data; 27, identifier:get; 28, argument_list; 28, 29; 28, 30; 29, string:'color'; 30, None; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:alpha; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:data; 37, identifier:get; 38, argument_list; 38, 39; 38, 40; 39, string:'alpha'; 40, None; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:color; 44, identifier:orig_color; 45, if_statement; 45, 46; 45, 53; 46, boolean_operator:and; 46, 47; 46, 50; 47, comparison_operator:is; 47, 48; 47, 49; 48, identifier:color; 49, None; 50, comparison_operator:is; 50, 51; 50, 52; 51, identifier:alpha; 52, None; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:color; 57, list:[0, 0, 0]; 57, 58; 57, 59; 57, 60; 58, integer:0; 59, integer:0; 60, integer:0; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:color; 64, None; 65, block; 65, 66; 65, 75; 65, 87; 65, 123; 65, 130; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:color; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:pt; 72, identifier:ensure_nonhex_color; 73, argument_list; 73, 74; 74, identifier:color; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:color; 78, call; 78, 79; 78, 80; 79, identifier:list; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:color_funcs; 84, identifier:ensure_base255; 85, argument_list; 85, 86; 86, identifier:color; 87, if_statement; 87, 88; 87, 91; 88, comparison_operator:is; 88, 89; 88, 90; 89, identifier:alpha; 90, None; 91, block; 91, 92; 92, if_statement; 92, 93; 92, 99; 92, 110; 93, comparison_operator:==; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:len; 96, argument_list; 96, 97; 97, identifier:color; 98, integer:3; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, augmented_assignment:+=; 101, 102; 101, 103; 102, identifier:color; 103, list:[int(alpha * 255)]; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:int; 106, argument_list; 106, 107; 107, binary_operator:*; 107, 108; 107, 109; 108, identifier:alpha; 109, integer:255; 110, else_clause; 110, 111; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:color; 116, integer:3; 117, call; 117, 118; 117, 119; 118, identifier:int; 119, argument_list; 119, 120; 120, binary_operator:*; 120, 121; 120, 122; 121, identifier:alpha; 122, integer:255; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:color; 126, call; 126, 127; 126, 128; 127, identifier:tuple; 128, argument_list; 128, 129; 129, identifier:color; 130, if_statement; 130, 131; 130, 137; 130, 154; 131, comparison_operator:==; 131, 132; 131, 136; 132, call; 132, 133; 132, 134; 133, identifier:len; 134, argument_list; 134, 135; 135, identifier:color; 136, integer:3; 137, ERROR; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 143; 139, 145; 140, subscript; 140, 141; 140, 142; 141, identifier:data; 142, string:'color'; 143, ERROR; 143, 144; 144, identifier:else; 145, assignment; 145, 146; 145, 149; 145, 150; 146, subscript; 146, 147; 146, 148; 147, identifier:data; 148, string:'color'; 149, ERROR; 150, as_pattern; 150, 151; 150, 152; 151, identifier:Exception; 152, as_pattern_target; 152, 153; 153, identifier:ex; 154, block:; 155, import_statement; 155, 156; 156, aliased_import; 156, 157; 156, 159; 157, dotted_name; 157, 158; 158, identifier:utool; 159, identifier:ut; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:ut; 164, identifier:printex; 165, argument_list; 165, 166; 165, 167; 166, identifier:ex; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:keys; 169, list:['color', 'orig_color', 'data']; 169, 170; 169, 171; 169, 172; 170, string:'color'; 171, string:'orig_color'; 172, string:'data'; 173, raise_statement; 174, block:; 175, identifier:for; 176, expression_statement; 176, 177; 176, 178; 177, identifier:node; 178, comparison_operator:in; 178, 179; 178, 180; 179, identifier:node_data; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:graph; 183, identifier:nodes; 184, argument_list; 184, 185; 185, keyword_argument; 185, 186; 185, 187; 186, identifier:data; 187, True; 188, ERROR; 188, 189; 189, block; 189, 190; 189, 194; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:data; 193, identifier:node_data; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 197; 196, identifier:_fix_agraph_color; 197, argument_list; 197, 198; 198, identifier:data; 199, block; 199, 200; 200, for_statement; 200, 201; 200, 205; 200, 213; 201, pattern_list; 201, 202; 201, 203; 201, 204; 202, identifier:u; 203, identifier:v; 204, identifier:edge_data; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:graph; 208, identifier:edges; 209, argument_list; 209, 210; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:data; 212, True; 213, block; 213, 214; 213, 218; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 217; 216, identifier:data; 217, identifier:edge_data; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 221; 220, identifier:_fix_agraph_color; 221, argument_list; 221, 222; 222, identifier:data | def nx_ensure_agraph_color(graph):
from plottool import color_funcs
import plottool as pt
def _fix_agraph_color(data):
try:
orig_color = data.get('color', None)
alpha = data.get('alpha', None)
color = orig_color
if color is None and alpha is not None:
color = [0, 0, 0]
if color is not None:
color = pt.ensure_nonhex_color(color)
color = list(color_funcs.ensure_base255(color))
if alpha is not None:
if len(color) == 3:
color += [int(alpha * 255)]
else:
color[3] = int(alpha * 255)
color = tuple(color)
if len(color) == 3:
data['color'] = '
else:
data['color'] = '
except Exception as ex:
import utool as ut
ut.printex(ex, keys=['color', 'orig_color', 'data'])
raise
for node, node_data in graph.nodes(data=True):
data = node_data
_fix_agraph_color(data)
for u, v, edge_data in graph.edges(data=True):
data = edge_data
_fix_agraph_color(data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:simplify_graph; 3, parameters; 3, 4; 4, identifier:graph; 5, block; 5, 6; 5, 11; 5, 25; 5, 34; 5, 68; 5, 78; 5, 127; 5, 133; 5, 139; 5, 146; 5, 153; 6, import_statement; 6, 7; 7, aliased_import; 7, 8; 7, 10; 8, dotted_name; 8, 9; 9, identifier:utool; 10, identifier:ut; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:nodes; 14, call; 14, 15; 14, 16; 15, identifier:sorted; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:list; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:graph; 23, identifier:nodes; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:node_lookup; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:ut; 31, identifier:make_index_lookup; 32, argument_list; 32, 33; 33, identifier:nodes; 34, if_statement; 34, 35; 34, 40; 34, 55; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:graph; 38, identifier:is_multigraph; 39, argument_list; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:edges; 44, call; 44, 45; 44, 46; 45, identifier:list; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:graph; 50, identifier:edges; 51, argument_list; 51, 52; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:keys; 54, True; 55, else_clause; 55, 56; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:edges; 60, call; 60, 61; 60, 62; 61, identifier:list; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:graph; 66, identifier:edges; 67, argument_list; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:new_nodes; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:ut; 74, identifier:take; 75, argument_list; 75, 76; 75, 77; 76, identifier:node_lookup; 77, identifier:nodes; 78, if_statement; 78, 79; 78, 84; 78, 107; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:graph; 82, identifier:is_multigraph; 83, argument_list; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:new_edges; 88, list_comprehension; 88, 89; 88, 104; 89, tuple; 89, 90; 89, 95; 89, 100; 89, 103; 90, subscript; 90, 91; 90, 92; 91, identifier:node_lookup; 92, subscript; 92, 93; 92, 94; 93, identifier:e; 94, integer:0; 95, subscript; 95, 96; 95, 97; 96, identifier:node_lookup; 97, subscript; 97, 98; 97, 99; 98, identifier:e; 99, integer:1; 100, subscript; 100, 101; 100, 102; 101, identifier:e; 102, integer:2; 103, dictionary; 104, for_in_clause; 104, 105; 104, 106; 105, identifier:e; 106, identifier:edges; 107, else_clause; 107, 108; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:new_edges; 112, list_comprehension; 112, 113; 112, 124; 113, tuple; 113, 114; 113, 119; 114, subscript; 114, 115; 114, 116; 115, identifier:node_lookup; 116, subscript; 116, 117; 116, 118; 117, identifier:e; 118, integer:0; 119, subscript; 119, 120; 119, 121; 120, identifier:node_lookup; 121, subscript; 121, 122; 121, 123; 122, identifier:e; 123, integer:1; 124, for_in_clause; 124, 125; 124, 126; 125, identifier:e; 126, identifier:edges; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:cls; 130, attribute; 130, 131; 130, 132; 131, identifier:graph; 132, identifier:__class__; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:new_graph; 136, call; 136, 137; 136, 138; 137, identifier:cls; 138, argument_list; 139, expression_statement; 139, 140; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:new_graph; 143, identifier:add_nodes_from; 144, argument_list; 144, 145; 145, identifier:new_nodes; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:new_graph; 150, identifier:add_edges_from; 151, argument_list; 151, 152; 152, identifier:new_edges; 153, return_statement; 153, 154; 154, identifier:new_graph | def simplify_graph(graph):
import utool as ut
nodes = sorted(list(graph.nodes()))
node_lookup = ut.make_index_lookup(nodes)
if graph.is_multigraph():
edges = list(graph.edges(keys=True))
else:
edges = list(graph.edges())
new_nodes = ut.take(node_lookup, nodes)
if graph.is_multigraph():
new_edges = [(node_lookup[e[0]], node_lookup[e[1]], e[2], {}) for e in edges]
else:
new_edges = [(node_lookup[e[0]], node_lookup[e[1]]) for e in edges]
cls = graph.__class__
new_graph = cls()
new_graph.add_nodes_from(new_nodes)
new_graph.add_edges_from(new_edges)
return new_graph |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:subgraph_from_edges; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:G; 5, identifier:edge_list; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ref_back; 8, True; 9, block; 9, 10; 9, 29; 9, 42; 9, 117; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:sub_nodes; 13, call; 13, 14; 13, 15; 14, identifier:list; 15, argument_list; 15, 16; 16, set_comprehension; 16, 17; 16, 18; 16, 21; 17, identifier:y; 18, for_in_clause; 18, 19; 18, 20; 19, identifier:x; 20, identifier:edge_list; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:y; 23, subscript; 23, 24; 23, 25; 24, identifier:x; 25, slice; 25, 26; 25, 27; 25, 28; 26, integer:0; 27, colon; 28, integer:2; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:multi_edge_list; 32, list_comprehension; 32, 33; 32, 39; 33, subscript; 33, 34; 33, 35; 34, identifier:edge; 35, slice; 35, 36; 35, 37; 35, 38; 36, integer:0; 37, colon; 38, integer:3; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:edge; 41, identifier:edge_list; 42, if_statement; 42, 43; 42, 44; 42, 78; 43, identifier:ref_back; 44, block; 44, 45; 44, 54; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:G_sub; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:G; 51, identifier:subgraph; 52, argument_list; 52, 53; 53, identifier:sub_nodes; 54, for_statement; 54, 55; 54, 56; 54, 64; 55, identifier:edge; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:G_sub; 59, identifier:edges; 60, argument_list; 60, 61; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:keys; 63, True; 64, block; 64, 65; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:not; 66, 67; 66, 68; 67, identifier:edge; 68, identifier:multi_edge_list; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:G_sub; 74, identifier:remove_edge; 75, argument_list; 75, 76; 76, list_splat; 76, 77; 77, identifier:edge; 78, else_clause; 78, 79; 79, block; 79, 80; 79, 93; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:G_sub; 83, call; 83, 84; 83, 92; 84, attribute; 84, 85; 84, 91; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:G; 88, identifier:subgraph; 89, argument_list; 89, 90; 90, identifier:sub_nodes; 91, identifier:copy; 92, argument_list; 93, for_statement; 93, 94; 93, 95; 93, 103; 94, identifier:edge; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:G_sub; 98, identifier:edges; 99, argument_list; 99, 100; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:keys; 102, True; 103, block; 103, 104; 104, if_statement; 104, 105; 104, 108; 105, comparison_operator:not; 105, 106; 105, 107; 106, identifier:edge; 107, identifier:multi_edge_list; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:G_sub; 113, identifier:remove_edge; 114, argument_list; 114, 115; 115, list_splat; 115, 116; 116, identifier:edge; 117, return_statement; 117, 118; 118, identifier:G_sub | def subgraph_from_edges(G, edge_list, ref_back=True):
sub_nodes = list({y for x in edge_list for y in x[0:2]})
multi_edge_list = [edge[0:3] for edge in edge_list]
if ref_back:
G_sub = G.subgraph(sub_nodes)
for edge in G_sub.edges(keys=True):
if edge not in multi_edge_list:
G_sub.remove_edge(*edge)
else:
G_sub = G.subgraph(sub_nodes).copy()
for edge in G_sub.edges(keys=True):
if edge not in multi_edge_list:
G_sub.remove_edge(*edge)
return G_sub |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 30; 2, function_name:bfs_conditional; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 4, identifier:G; 5, identifier:source; 6, default_parameter; 6, 7; 6, 8; 7, identifier:reverse; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:keys; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:data; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:yield_nodes; 17, True; 18, default_parameter; 18, 19; 18, 20; 19, identifier:yield_if; 20, None; 21, default_parameter; 21, 22; 21, 23; 22, identifier:continue_if; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:visited_nodes; 26, None; 27, default_parameter; 27, 28; 27, 29; 28, identifier:yield_source; 29, False; 30, block; 30, 31; 30, 48; 30, 90; 30, 99; 30, 120; 30, 170; 31, if_statement; 31, 32; 31, 39; 32, boolean_operator:and; 32, 33; 32, 34; 33, identifier:reverse; 34, call; 34, 35; 34, 36; 35, identifier:hasattr; 36, argument_list; 36, 37; 36, 38; 37, identifier:G; 38, string:'reverse'; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:G; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:G; 46, identifier:reverse; 47, argument_list; 48, if_statement; 48, 49; 48, 56; 48, 71; 49, call; 49, 50; 49, 51; 50, identifier:isinstance; 51, argument_list; 51, 52; 51, 53; 52, identifier:G; 53, attribute; 53, 54; 53, 55; 54, identifier:nx; 55, identifier:Graph; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:neighbors; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:functools; 63, identifier:partial; 64, argument_list; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:G; 67, identifier:edges; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:data; 70, identifier:data; 71, else_clause; 71, 72; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:neighbors; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:functools; 79, identifier:partial; 80, argument_list; 80, 81; 80, 84; 80, 87; 81, attribute; 81, 82; 81, 83; 82, identifier:G; 83, identifier:edges; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:keys; 86, identifier:keys; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:data; 89, identifier:data; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:queue; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:collections; 96, identifier:deque; 97, argument_list; 97, 98; 98, list:[]; 99, if_statement; 99, 100; 99, 103; 99, 111; 100, comparison_operator:is; 100, 101; 100, 102; 101, identifier:visited_nodes; 102, None; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:visited_nodes; 107, call; 107, 108; 107, 109; 108, identifier:set; 109, argument_list; 109, 110; 110, list:[]; 111, else_clause; 111, 112; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:visited_nodes; 116, call; 116, 117; 116, 118; 117, identifier:set; 118, argument_list; 118, 119; 119, identifier:visited_nodes; 120, if_statement; 120, 121; 120, 124; 121, comparison_operator:not; 121, 122; 121, 123; 122, identifier:source; 123, identifier:visited_nodes; 124, block; 124, 125; 124, 133; 124, 140; 124, 147; 124, 161; 125, if_statement; 125, 126; 125, 129; 126, boolean_operator:and; 126, 127; 126, 128; 127, identifier:yield_nodes; 128, identifier:yield_source; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, yield; 131, 132; 132, identifier:source; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:visited_nodes; 137, identifier:add; 138, argument_list; 138, 139; 139, identifier:source; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:new_edges; 143, call; 143, 144; 143, 145; 144, identifier:neighbors; 145, argument_list; 145, 146; 146, identifier:source; 147, if_statement; 147, 148; 147, 153; 148, call; 148, 149; 148, 150; 149, identifier:isinstance; 150, argument_list; 150, 151; 150, 152; 151, identifier:new_edges; 152, identifier:list; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:new_edges; 157, call; 157, 158; 157, 159; 158, identifier:iter; 159, argument_list; 159, 160; 160, identifier:new_edges; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:queue; 165, identifier:append; 166, argument_list; 166, 167; 167, tuple; 167, 168; 167, 169; 168, identifier:source; 169, identifier:new_edges; 170, while_statement; 170, 171; 170, 172; 171, identifier:queue; 172, block; 172, 173; 172, 181; 172, 285; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 178; 175, pattern_list; 175, 176; 175, 177; 176, identifier:parent; 177, identifier:edges; 178, subscript; 178, 179; 178, 180; 179, identifier:queue; 180, integer:0; 181, for_statement; 181, 182; 181, 183; 181, 184; 182, identifier:edge; 183, identifier:edges; 184, block; 184, 185; 184, 191; 184, 231; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:child; 188, subscript; 188, 189; 188, 190; 189, identifier:edge; 190, integer:1; 191, if_statement; 191, 192; 191, 193; 191, 214; 192, identifier:yield_nodes; 193, block; 193, 194; 194, if_statement; 194, 195; 194, 198; 195, comparison_operator:not; 195, 196; 195, 197; 196, identifier:child; 197, identifier:visited_nodes; 198, block; 198, 199; 199, if_statement; 199, 200; 199, 210; 200, boolean_operator:or; 200, 201; 200, 204; 201, comparison_operator:is; 201, 202; 201, 203; 202, identifier:yield_if; 203, None; 204, call; 204, 205; 204, 206; 205, identifier:yield_if; 206, argument_list; 206, 207; 206, 208; 206, 209; 207, identifier:G; 208, identifier:child; 209, identifier:edge; 210, block; 210, 211; 211, expression_statement; 211, 212; 212, yield; 212, 213; 213, identifier:child; 214, else_clause; 214, 215; 215, block; 215, 216; 216, if_statement; 216, 217; 216, 227; 217, boolean_operator:or; 217, 218; 217, 221; 218, comparison_operator:is; 218, 219; 218, 220; 219, identifier:yield_if; 220, None; 221, call; 221, 222; 221, 223; 222, identifier:yield_if; 223, argument_list; 223, 224; 223, 225; 223, 226; 224, identifier:G; 225, identifier:child; 226, identifier:edge; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, yield; 229, 230; 230, identifier:edge; 231, if_statement; 231, 232; 231, 235; 232, comparison_operator:not; 232, 233; 232, 234; 233, identifier:child; 234, identifier:visited_nodes; 235, block; 235, 236; 235, 243; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:visited_nodes; 240, identifier:add; 241, argument_list; 241, 242; 242, identifier:child; 243, if_statement; 243, 244; 243, 254; 244, boolean_operator:or; 244, 245; 244, 248; 245, comparison_operator:is; 245, 246; 245, 247; 246, identifier:continue_if; 247, None; 248, call; 248, 249; 248, 250; 249, identifier:continue_if; 250, argument_list; 250, 251; 250, 252; 250, 253; 251, identifier:G; 252, identifier:child; 253, identifier:edge; 254, block; 254, 255; 254, 262; 254, 276; 255, expression_statement; 255, 256; 256, assignment; 256, 257; 256, 258; 257, identifier:new_edges; 258, call; 258, 259; 258, 260; 259, identifier:neighbors; 260, argument_list; 260, 261; 261, identifier:child; 262, if_statement; 262, 263; 262, 268; 263, call; 263, 264; 263, 265; 264, identifier:isinstance; 265, argument_list; 265, 266; 265, 267; 266, identifier:new_edges; 267, identifier:list; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, assignment; 270, 271; 270, 272; 271, identifier:new_edges; 272, call; 272, 273; 272, 274; 273, identifier:iter; 274, argument_list; 274, 275; 275, identifier:new_edges; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:queue; 280, identifier:append; 281, argument_list; 281, 282; 282, tuple; 282, 283; 282, 284; 283, identifier:child; 284, identifier:new_edges; 285, expression_statement; 285, 286; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:queue; 289, identifier:popleft; 290, argument_list | def bfs_conditional(G, source, reverse=False, keys=True, data=False,
yield_nodes=True, yield_if=None,
continue_if=None, visited_nodes=None,
yield_source=False):
if reverse and hasattr(G, 'reverse'):
G = G.reverse()
if isinstance(G, nx.Graph):
neighbors = functools.partial(G.edges, data=data)
else:
neighbors = functools.partial(G.edges, keys=keys, data=data)
queue = collections.deque([])
if visited_nodes is None:
visited_nodes = set([])
else:
visited_nodes = set(visited_nodes)
if source not in visited_nodes:
if yield_nodes and yield_source:
yield source
visited_nodes.add(source)
new_edges = neighbors(source)
if isinstance(new_edges, list):
new_edges = iter(new_edges)
queue.append((source, new_edges))
while queue:
parent, edges = queue[0]
for edge in edges:
child = edge[1]
if yield_nodes:
if child not in visited_nodes:
if yield_if is None or yield_if(G, child, edge):
yield child
else:
if yield_if is None or yield_if(G, child, edge):
yield edge
if child not in visited_nodes:
visited_nodes.add(child)
if continue_if is None or continue_if(G, child, edge):
new_edges = neighbors(child)
if isinstance(new_edges, list):
new_edges = iter(new_edges)
queue.append((child, new_edges))
queue.popleft() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:approx_min_num_components; 3, parameters; 3, 4; 3, 5; 4, identifier:nodes; 5, identifier:negative_edges; 6, block; 6, 7; 6, 12; 6, 16; 6, 24; 6, 31; 6, 38; 6, 86; 6, 107; 6, 118; 6, 127; 6, 157; 6, 275; 6, 283; 7, import_statement; 7, 8; 8, aliased_import; 8, 9; 8, 11; 9, dotted_name; 9, 10; 10, identifier:utool; 11, identifier:ut; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:num; 15, integer:0; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:g_neg; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:nx; 22, identifier:Graph; 23, argument_list; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:g_neg; 28, identifier:add_nodes_from; 29, argument_list; 29, 30; 30, identifier:nodes; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:g_neg; 35, identifier:add_edges_from; 36, argument_list; 36, 37; 37, identifier:negative_edges; 38, if_statement; 38, 39; 38, 47; 38, 66; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:nx; 43, identifier:__version__; 44, identifier:startswith; 45, argument_list; 45, 46; 46, string:'2'; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:deg0_nodes; 51, list_comprehension; 51, 52; 51, 53; 51, 62; 52, identifier:n; 53, for_in_clause; 53, 54; 53, 57; 54, pattern_list; 54, 55; 54, 56; 55, identifier:n; 56, identifier:d; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:g_neg; 60, identifier:degree; 61, argument_list; 62, if_clause; 62, 63; 63, comparison_operator:==; 63, 64; 63, 65; 64, identifier:d; 65, integer:0; 66, else_clause; 66, 67; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:deg0_nodes; 71, list_comprehension; 71, 72; 71, 73; 71, 82; 72, identifier:n; 73, for_in_clause; 73, 74; 73, 77; 74, pattern_list; 74, 75; 74, 76; 75, identifier:n; 76, identifier:d; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:g_neg; 80, identifier:degree_iter; 81, argument_list; 82, if_clause; 82, 83; 83, comparison_operator:==; 83, 84; 83, 85; 84, identifier:d; 85, integer:0; 86, for_statement; 86, 87; 86, 90; 86, 96; 87, pattern_list; 87, 88; 87, 89; 88, identifier:u; 89, identifier:v; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:ut; 93, identifier:itertwo; 94, argument_list; 94, 95; 95, identifier:deg0_nodes; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:nx_contracted_nodes; 100, argument_list; 100, 101; 100, 102; 100, 103; 100, 104; 101, identifier:g_neg; 102, identifier:v; 103, identifier:u; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:inplace; 106, True; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:unused; 110, call; 110, 111; 110, 112; 111, identifier:list; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:g_neg; 116, identifier:nodes; 117, argument_list; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:g_pos; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:nx; 124, identifier:complement; 125, argument_list; 125, 126; 126, identifier:g_neg; 127, if_statement; 127, 128; 127, 129; 128, False; 129, block; 129, 130; 129, 137; 129, 148; 129, 155; 130, import_from_statement; 130, 131; 130, 135; 131, dotted_name; 131, 132; 131, 133; 131, 134; 132, identifier:networkx; 133, identifier:algorithms; 134, identifier:approximation; 135, dotted_name; 135, 136; 136, identifier:clique; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 142; 139, pattern_list; 139, 140; 139, 141; 140, identifier:maxiset; 141, identifier:cliques; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:clique; 145, identifier:clique_removal; 146, argument_list; 146, 147; 147, identifier:g_pos; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:num; 151, call; 151, 152; 151, 153; 152, identifier:len; 153, argument_list; 153, 154; 154, identifier:cliques; 155, return_statement; 155, 156; 156, identifier:num; 157, while_statement; 157, 158; 157, 164; 158, comparison_operator:>; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:unused; 163, integer:0; 164, block; 164, 165; 164, 169; 164, 173; 164, 179; 164, 186; 164, 198; 164, 208; 165, expression_statement; 165, 166; 166, augmented_assignment:+=; 166, 167; 166, 168; 167, identifier:num; 168, integer:1; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:idx1; 172, integer:0; 173, expression_statement; 173, 174; 174, assignment; 174, 175; 174, 176; 175, identifier:n1; 176, subscript; 176, 177; 176, 178; 177, identifier:unused; 178, identifier:idx1; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:unused; 183, identifier:remove; 184, argument_list; 184, 185; 185, identifier:n1; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:neigbs; 189, call; 189, 190; 189, 191; 190, identifier:list; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:g_pos; 195, identifier:neighbors; 196, argument_list; 196, 197; 197, identifier:n1; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:neigbs; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:ut; 204, identifier:isect; 205, argument_list; 205, 206; 205, 207; 206, identifier:neigbs; 207, identifier:unused; 208, while_statement; 208, 209; 208, 215; 209, comparison_operator:>; 209, 210; 209, 214; 210, call; 210, 211; 210, 212; 211, identifier:len; 212, argument_list; 212, 213; 213, identifier:neigbs; 214, integer:0; 215, block; 215, 216; 215, 220; 215, 226; 215, 233; 215, 244; 215, 253; 215, 265; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:idx2; 219, integer:0; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:n2; 223, subscript; 223, 224; 223, 225; 224, identifier:neigbs; 225, identifier:idx2; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:unused; 230, identifier:remove; 231, argument_list; 231, 232; 232, identifier:n2; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:g_neg; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:nx; 239, identifier:contracted_nodes; 240, argument_list; 240, 241; 240, 242; 240, 243; 241, identifier:g_neg; 242, identifier:n1; 243, identifier:n2; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:g_pos; 247, call; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:nx; 250, identifier:complement; 251, argument_list; 251, 252; 252, identifier:g_neg; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:neigbs; 256, call; 256, 257; 256, 258; 257, identifier:list; 258, argument_list; 258, 259; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:g_pos; 262, identifier:neighbors; 263, argument_list; 263, 264; 264, identifier:n1; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:neigbs; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:ut; 271, identifier:isect; 272, argument_list; 272, 273; 272, 274; 273, identifier:neigbs; 274, identifier:unused; 275, expression_statement; 275, 276; 276, call; 276, 277; 276, 278; 277, identifier:print; 278, argument_list; 278, 279; 279, binary_operator:%; 279, 280; 279, 281; 280, string:'num = %r'; 281, tuple; 281, 282; 282, identifier:num; 283, return_statement; 283, 284; 284, identifier:num | def approx_min_num_components(nodes, negative_edges):
import utool as ut
num = 0
g_neg = nx.Graph()
g_neg.add_nodes_from(nodes)
g_neg.add_edges_from(negative_edges)
if nx.__version__.startswith('2'):
deg0_nodes = [n for n, d in g_neg.degree() if d == 0]
else:
deg0_nodes = [n for n, d in g_neg.degree_iter() if d == 0]
for u, v in ut.itertwo(deg0_nodes):
nx_contracted_nodes(g_neg, v, u, inplace=True)
unused = list(g_neg.nodes())
g_pos = nx.complement(g_neg)
if False:
from networkx.algorithms.approximation import clique
maxiset, cliques = clique.clique_removal(g_pos)
num = len(cliques)
return num
while len(unused) > 0:
num += 1
idx1 = 0
n1 = unused[idx1]
unused.remove(n1)
neigbs = list(g_pos.neighbors(n1))
neigbs = ut.isect(neigbs, unused)
while len(neigbs) > 0:
idx2 = 0
n2 = neigbs[idx2]
unused.remove(n2)
g_neg = nx.contracted_nodes(g_neg, n1, n2)
g_pos = nx.complement(g_neg)
neigbs = list(g_pos.neighbors(n1))
neigbs = ut.isect(neigbs, unused)
print('num = %r' % (num,))
return num |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:generate_proteins; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 12; 4, identifier:pepfn; 5, identifier:proteins; 6, identifier:pepheader; 7, identifier:scorecol; 8, identifier:minlog; 9, default_parameter; 9, 10; 9, 11; 10, identifier:higherbetter; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:protcol; 14, False; 15, block; 15, 16; 15, 20; 15, 27; 15, 37; 15, 73; 15, 140; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:protein_peptides; 19, dictionary; 20, if_statement; 20, 21; 20, 22; 21, identifier:minlog; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:higherbetter; 26, False; 27, if_statement; 27, 28; 27, 30; 28, not_operator; 28, 29; 29, identifier:protcol; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:protcol; 34, attribute; 34, 35; 34, 36; 35, identifier:peptabledata; 36, identifier:HEADER_MASTERPROTEINS; 37, for_statement; 37, 38; 37, 39; 37, 46; 38, identifier:psm; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:reader; 42, identifier:generate_tsv_psms; 43, argument_list; 43, 44; 43, 45; 44, identifier:pepfn; 45, identifier:pepheader; 46, block; 46, 47; 46, 53; 46, 59; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:p_acc; 50, subscript; 50, 51; 50, 52; 51, identifier:psm; 52, identifier:protcol; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:in; 54, 55; 54, 56; 55, string:';'; 56, identifier:p_acc; 57, block; 57, 58; 58, continue_statement; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:protein_peptides; 62, call; 62, 63; 62, 64; 63, identifier:evaluate_peptide; 64, argument_list; 64, 65; 64, 66; 64, 67; 64, 68; 64, 69; 64, 70; 65, identifier:protein_peptides; 66, identifier:psm; 67, identifier:p_acc; 68, identifier:higherbetter; 69, identifier:scorecol; 70, keyword_argument; 70, 71; 70, 72; 71, identifier:fncol; 72, False; 73, if_statement; 73, 74; 73, 75; 74, identifier:minlog; 75, block; 75, 76; 75, 131; 76, try_statement; 76, 77; 76, 101; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:nextbestscore; 81, call; 81, 82; 81, 83; 82, identifier:min; 83, argument_list; 83, 84; 84, list_comprehension; 84, 85; 84, 88; 84, 95; 85, subscript; 85, 86; 85, 87; 86, identifier:pep; 87, string:'score'; 88, for_in_clause; 88, 89; 88, 90; 89, identifier:pep; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:protein_peptides; 93, identifier:values; 94, argument_list; 95, if_clause; 95, 96; 96, comparison_operator:>; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:pep; 99, string:'score'; 100, integer:0; 101, except_clause; 101, 102; 101, 103; 102, identifier:ValueError; 103, block; 103, 104; 103, 107; 103, 124; 104, import_statement; 104, 105; 105, dotted_name; 105, 106; 106, identifier:sys; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 114; 109, attribute; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:sys; 112, identifier:stderr; 113, identifier:write; 114, argument_list; 114, 115; 115, call; 115, 116; 115, 122; 116, attribute; 116, 117; 116, 121; 117, concatenated_string; 117, 118; 117, 119; 117, 120; 118, string:'Cannot find score of type {} which is above 0. '; 119, string:'Only scores above zero can have a -log value. '; 120, string:'Exiting.'; 121, identifier:format; 122, argument_list; 122, 123; 123, identifier:scorecol; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:sys; 128, identifier:exit; 129, argument_list; 129, 130; 130, integer:1; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:nextbestscore; 134, unary_operator:-; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:log; 137, argument_list; 137, 138; 137, 139; 138, identifier:nextbestscore; 139, integer:10; 140, for_statement; 140, 141; 140, 142; 140, 143; 141, identifier:protein; 142, identifier:proteins; 143, block; 143, 144; 143, 182; 143, 203; 143, 216; 144, try_statement; 144, 145; 144, 156; 145, block; 145, 146; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:peptide; 149, subscript; 149, 150; 149, 151; 150, identifier:protein_peptides; 151, subscript; 151, 152; 151, 153; 152, identifier:protein; 153, attribute; 153, 154; 153, 155; 154, identifier:prottabledata; 155, identifier:HEADER_PROTEIN; 156, except_clause; 156, 157; 156, 158; 157, identifier:KeyError; 158, block; 158, 159; 158, 175; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:print; 162, argument_list; 162, 163; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, concatenated_string; 165, 166; 165, 167; 166, string:'WARNING - protein {} not found in peptide '; 167, string:'table'; 168, identifier:format; 169, argument_list; 169, 170; 170, subscript; 170, 171; 170, 172; 171, identifier:protein; 172, attribute; 172, 173; 172, 174; 173, identifier:prottabledata; 174, identifier:HEADER_PROTEIN; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:peptide; 178, dictionary; 178, 179; 179, pair; 179, 180; 179, 181; 180, string:'score'; 181, string:'NA'; 182, if_statement; 182, 183; 182, 190; 183, boolean_operator:and; 183, 184; 183, 185; 184, identifier:minlog; 185, comparison_operator:!=; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:peptide; 188, string:'score'; 189, string:'NA'; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:peptide; 195, string:'score'; 196, call; 196, 197; 196, 198; 197, identifier:log_score; 198, argument_list; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:peptide; 201, string:'score'; 202, identifier:nextbestscore; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 210; 205, subscript; 205, 206; 205, 207; 206, identifier:protein; 207, attribute; 207, 208; 207, 209; 208, identifier:prottabledata; 209, identifier:HEADER_QSCORE; 210, call; 210, 211; 210, 212; 211, identifier:str; 212, argument_list; 212, 213; 213, subscript; 213, 214; 213, 215; 214, identifier:peptide; 215, string:'score'; 216, expression_statement; 216, 217; 217, yield; 217, 218; 218, identifier:protein | def generate_proteins(pepfn, proteins, pepheader, scorecol, minlog,
higherbetter=True, protcol=False):
protein_peptides = {}
if minlog:
higherbetter = False
if not protcol:
protcol = peptabledata.HEADER_MASTERPROTEINS
for psm in reader.generate_tsv_psms(pepfn, pepheader):
p_acc = psm[protcol]
if ';' in p_acc:
continue
protein_peptides = evaluate_peptide(protein_peptides, psm, p_acc,
higherbetter, scorecol,
fncol=False)
if minlog:
try:
nextbestscore = min([pep['score'] for pep in
protein_peptides.values()
if pep['score'] > 0])
except ValueError:
import sys
sys.stderr.write('Cannot find score of type {} which is above 0. '
'Only scores above zero can have a -log value. '
'Exiting.'.format(scorecol))
sys.exit(1)
nextbestscore = -log(nextbestscore, 10)
for protein in proteins:
try:
peptide = protein_peptides[protein[prottabledata.HEADER_PROTEIN]]
except KeyError:
print('WARNING - protein {} not found in peptide '
'table'.format(protein[prottabledata.HEADER_PROTEIN]))
peptide = {'score': 'NA'}
if minlog and peptide['score'] != 'NA':
peptide['score'] = log_score(peptide['score'], nextbestscore)
protein[prottabledata.HEADER_QSCORE] = str(
peptide['score'])
yield protein |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 2, function_name:grab_file_url; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:file_url; 5, default_parameter; 5, 6; 5, 7; 6, identifier:appname; 7, string:'utool'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:download_dir; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:delay; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:spoof; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:fname; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:verbose; 22, True; 23, default_parameter; 23, 24; 23, 25; 24, identifier:redownload; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:check_hash; 28, False; 29, block; 29, 30; 29, 32; 29, 39; 29, 51; 29, 65; 29, 73; 29, 197; 29, 204; 29, 264; 29, 271; 29, 335; 30, expression_statement; 30, 31; 31, identifier:r; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:file_url; 35, call; 35, 36; 35, 37; 36, identifier:clean_dropbox_link; 37, argument_list; 37, 38; 38, identifier:file_url; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:is; 40, 41; 40, 42; 41, identifier:fname; 42, None; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:fname; 47, call; 47, 48; 47, 49; 48, identifier:basename; 49, argument_list; 49, 50; 50, identifier:file_url; 51, if_statement; 51, 52; 51, 55; 52, comparison_operator:is; 52, 53; 52, 54; 53, identifier:download_dir; 54, None; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:download_dir; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:util_cplat; 62, identifier:get_app_cache_dir; 63, argument_list; 63, 64; 64, identifier:appname; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:fpath; 68, call; 68, 69; 68, 70; 69, identifier:join; 70, argument_list; 70, 71; 70, 72; 71, identifier:download_dir; 72, identifier:fname; 73, if_statement; 73, 74; 73, 75; 74, identifier:check_hash; 75, block; 75, 76; 75, 96; 75, 109; 75, 114; 75, 127; 75, 146; 76, if_statement; 76, 77; 76, 84; 76, 89; 77, call; 77, 78; 77, 79; 78, identifier:isinstance; 79, argument_list; 79, 80; 79, 81; 80, identifier:check_hash; 81, tuple; 81, 82; 81, 83; 82, identifier:list; 83, identifier:tuple; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:hash_list; 88, identifier:check_hash; 89, else_clause; 89, 90; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:hash_list; 94, list:['md5']; 94, 95; 95, string:'md5'; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, pattern_list; 98, 99; 98, 100; 99, identifier:hash_remote; 100, identifier:hash_tag_remote; 101, call; 101, 102; 101, 103; 102, identifier:grab_file_remote_hash; 103, argument_list; 103, 104; 103, 105; 103, 106; 104, identifier:file_url; 105, identifier:hash_list; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:verbose; 108, identifier:verbose; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:hash_list; 112, list:[hash_tag_remote]; 112, 113; 113, identifier:hash_tag_remote; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, pattern_list; 116, 117; 116, 118; 117, identifier:hash_local; 118, identifier:hash_tag_local; 119, call; 119, 120; 119, 121; 120, identifier:get_file_local_hash; 121, argument_list; 121, 122; 121, 123; 121, 124; 122, identifier:fpath; 123, identifier:hash_list; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:verbose; 126, identifier:verbose; 127, if_statement; 127, 128; 127, 129; 128, identifier:verbose; 129, block; 129, 130; 129, 138; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:print; 133, argument_list; 133, 134; 134, binary_operator:%; 134, 135; 134, 136; 135, string:'[utool] Pre Local Hash: %r'; 136, tuple; 136, 137; 137, identifier:hash_local; 138, expression_statement; 138, 139; 139, call; 139, 140; 139, 141; 140, identifier:print; 141, argument_list; 141, 142; 142, binary_operator:%; 142, 143; 142, 144; 143, string:'[utool] Pre Remote Hash: %r'; 144, tuple; 144, 145; 145, identifier:hash_remote; 146, if_statement; 146, 147; 146, 150; 146, 155; 146, 172; 146, 183; 147, comparison_operator:is; 147, 148; 147, 149; 148, identifier:hash_remote; 149, None; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:check_hash; 154, False; 155, elif_clause; 155, 156; 155, 159; 156, comparison_operator:is; 156, 157; 156, 158; 157, identifier:hash_local; 158, None; 159, block; 159, 160; 159, 168; 160, if_statement; 160, 161; 160, 162; 161, identifier:verbose; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:print; 166, argument_list; 166, 167; 167, string:'[utool] Remote hash provided but local hash missing, redownloading.'; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:redownload; 171, True; 172, elif_clause; 172, 173; 172, 176; 173, comparison_operator:==; 173, 174; 173, 175; 174, identifier:hash_local; 175, identifier:hash_remote; 176, block; 176, 177; 177, assert_statement; 177, 178; 177, 181; 178, comparison_operator:==; 178, 179; 178, 180; 179, identifier:hash_tag_local; 180, identifier:hash_tag_remote; 181, parenthesized_expression; 181, 182; 182, string:'hash tag disagreement'; 183, else_clause; 183, 184; 184, block; 184, 185; 184, 193; 185, if_statement; 185, 186; 185, 187; 186, identifier:verbose; 187, block; 187, 188; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:print; 191, argument_list; 191, 192; 192, string:'[utool] Both hashes provided, but they disagree, redownloading.'; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:redownload; 196, True; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:util_path; 201, identifier:ensurepath; 202, argument_list; 202, 203; 203, identifier:download_dir; 204, if_statement; 204, 205; 204, 212; 204, 252; 205, boolean_operator:or; 205, 206; 205, 207; 206, identifier:redownload; 207, not_operator; 207, 208; 208, call; 208, 209; 208, 210; 209, identifier:exists; 210, argument_list; 210, 211; 211, identifier:fpath; 212, block; 212, 213; 212, 223; 212, 243; 213, if_statement; 213, 214; 213, 215; 214, identifier:verbose; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 219; 218, identifier:print; 219, argument_list; 219, 220; 220, binary_operator:%; 220, 221; 220, 222; 221, string:'[utool] Downloading file %s'; 222, identifier:fpath; 223, if_statement; 223, 224; 223, 227; 224, comparison_operator:is; 224, 225; 224, 226; 225, identifier:delay; 226, None; 227, block; 227, 228; 227, 236; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:print; 231, argument_list; 231, 232; 232, binary_operator:%; 232, 233; 232, 234; 233, string:'[utool] delay download by %r seconds'; 234, tuple; 234, 235; 235, identifier:delay; 236, expression_statement; 236, 237; 237, call; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:time; 240, identifier:sleep; 241, argument_list; 241, 242; 242, identifier:delay; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 246; 245, identifier:download_url; 246, argument_list; 246, 247; 246, 248; 246, 249; 247, identifier:file_url; 248, identifier:fpath; 249, keyword_argument; 249, 250; 249, 251; 250, identifier:spoof; 251, identifier:spoof; 252, else_clause; 252, 253; 253, block; 253, 254; 254, if_statement; 254, 255; 254, 256; 255, identifier:verbose; 256, block; 256, 257; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 260; 259, identifier:print; 260, argument_list; 260, 261; 261, binary_operator:%; 261, 262; 261, 263; 262, string:'[utool] Already have file %s'; 263, identifier:fpath; 264, expression_statement; 264, 265; 265, call; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:util_path; 268, identifier:assert_exists; 269, argument_list; 269, 270; 270, identifier:fpath; 271, if_statement; 271, 272; 271, 273; 272, identifier:check_hash; 273, block; 273, 274; 273, 282; 273, 301; 273, 314; 273, 325; 273, 330; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:hash_fpath; 277, binary_operator:%; 277, 278; 277, 279; 278, string:'%s.%s'; 279, tuple; 279, 280; 279, 281; 280, identifier:fpath; 281, identifier:hash_tag_remote; 282, with_statement; 282, 283; 282, 293; 283, with_clause; 283, 284; 284, with_item; 284, 285; 285, as_pattern; 285, 286; 285, 291; 286, call; 286, 287; 286, 288; 287, identifier:open; 288, argument_list; 288, 289; 288, 290; 289, identifier:hash_fpath; 290, string:'w'; 291, as_pattern_target; 291, 292; 292, identifier:hash_file; 293, block; 293, 294; 294, expression_statement; 294, 295; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:hash_file; 298, identifier:write; 299, argument_list; 299, 300; 300, identifier:hash_remote; 301, expression_statement; 301, 302; 302, assignment; 302, 303; 302, 306; 303, pattern_list; 303, 304; 303, 305; 304, identifier:hash_local; 305, identifier:hash_tag_local; 306, call; 306, 307; 306, 308; 307, identifier:get_file_local_hash; 308, argument_list; 308, 309; 308, 310; 308, 311; 309, identifier:fpath; 310, identifier:hash_list; 311, keyword_argument; 311, 312; 311, 313; 312, identifier:verbose; 313, identifier:verbose; 314, if_statement; 314, 315; 314, 316; 315, identifier:verbose; 316, block; 316, 317; 317, expression_statement; 317, 318; 318, call; 318, 319; 318, 320; 319, identifier:print; 320, argument_list; 320, 321; 321, binary_operator:%; 321, 322; 321, 323; 322, string:'[utool] Post Local Hash: %r'; 323, tuple; 323, 324; 324, identifier:hash_local; 325, assert_statement; 325, 326; 325, 329; 326, comparison_operator:==; 326, 327; 326, 328; 327, identifier:hash_local; 328, identifier:hash_remote; 329, string:'Post-download hash disagreement'; 330, assert_statement; 330, 331; 330, 334; 331, comparison_operator:==; 331, 332; 331, 333; 332, identifier:hash_tag_local; 333, identifier:hash_tag_remote; 334, string:'Post-download hash tag disagreement'; 335, return_statement; 335, 336; 336, identifier:fpath | def grab_file_url(file_url, appname='utool', download_dir=None, delay=None,
spoof=False, fname=None, verbose=True, redownload=False,
check_hash=False):
r
file_url = clean_dropbox_link(file_url)
if fname is None:
fname = basename(file_url)
if download_dir is None:
download_dir = util_cplat.get_app_cache_dir(appname)
fpath = join(download_dir, fname)
if check_hash:
if isinstance(check_hash, (list, tuple)):
hash_list = check_hash
else:
hash_list = ['md5']
hash_remote, hash_tag_remote = grab_file_remote_hash(file_url, hash_list, verbose=verbose)
hash_list = [hash_tag_remote]
hash_local, hash_tag_local = get_file_local_hash(fpath, hash_list, verbose=verbose)
if verbose:
print('[utool] Pre Local Hash: %r' % (hash_local, ))
print('[utool] Pre Remote Hash: %r' % (hash_remote, ))
if hash_remote is None:
check_hash = False
elif hash_local is None:
if verbose:
print('[utool] Remote hash provided but local hash missing, redownloading.')
redownload = True
elif hash_local == hash_remote:
assert hash_tag_local == hash_tag_remote, ('hash tag disagreement')
else:
if verbose:
print('[utool] Both hashes provided, but they disagree, redownloading.')
redownload = True
util_path.ensurepath(download_dir)
if redownload or not exists(fpath):
if verbose:
print('[utool] Downloading file %s' % fpath)
if delay is not None:
print('[utool] delay download by %r seconds' % (delay,))
time.sleep(delay)
download_url(file_url, fpath, spoof=spoof)
else:
if verbose:
print('[utool] Already have file %s' % fpath)
util_path.assert_exists(fpath)
if check_hash:
hash_fpath = '%s.%s' % (fpath, hash_tag_remote, )
with open(hash_fpath, 'w') as hash_file:
hash_file.write(hash_remote)
hash_local, hash_tag_local = get_file_local_hash(fpath, hash_list, verbose=verbose)
if verbose:
print('[utool] Post Local Hash: %r' % (hash_local, ))
assert hash_local == hash_remote, 'Post-download hash disagreement'
assert hash_tag_local == hash_tag_remote, 'Post-download hash tag disagreement'
return fpath |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_uniprot_evidence_level; 3, parameters; 3, 4; 4, identifier:header; 5, block; 5, 6; 5, 14; 5, 49; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:header; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:header; 12, identifier:split; 13, argument_list; 14, for_statement; 14, 15; 14, 16; 14, 17; 15, identifier:item; 16, identifier:header; 17, block; 17, 18; 17, 27; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:item; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:item; 24, identifier:split; 25, argument_list; 25, 26; 26, string:'='; 27, try_statement; 27, 28; 27, 45; 28, block; 28, 29; 29, if_statement; 29, 30; 29, 35; 30, comparison_operator:==; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:item; 33, integer:0; 34, string:'PE'; 35, block; 35, 36; 36, return_statement; 36, 37; 37, binary_operator:-; 37, 38; 37, 39; 38, integer:5; 39, call; 39, 40; 39, 41; 40, identifier:int; 41, argument_list; 41, 42; 42, subscript; 42, 43; 42, 44; 43, identifier:item; 44, integer:1; 45, except_clause; 45, 46; 45, 47; 46, identifier:IndexError; 47, block; 47, 48; 48, continue_statement; 49, return_statement; 49, 50; 50, unary_operator:-; 50, 51; 51, integer:1 | def get_uniprot_evidence_level(header):
header = header.split()
for item in header:
item = item.split('=')
try:
if item[0] == 'PE':
return 5 - int(item[1])
except IndexError:
continue
return -1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_drain; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:cycles; 7, None; 8, block; 8, 9; 8, 16; 8, 27; 8, 57; 8, 408; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:log; 13, identifier:info; 14, argument_list; 14, 15; 15, string:"Now draining..."; 16, if_statement; 16, 17; 16, 19; 17, not_operator; 17, 18; 18, identifier:cycles; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:log; 24, identifier:info; 25, argument_list; 25, 26; 26, string:"No cycle count, the pipeline may be drained forever."; 27, if_statement; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:calibration; 31, block; 31, 32; 31, 39; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:log; 36, identifier:info; 37, argument_list; 37, 38; 38, string:"Setting up the detector calibration."; 39, for_statement; 39, 40; 39, 41; 39, 44; 40, identifier:module; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:modules; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:module; 49, identifier:detector; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:self; 54, identifier:calibration; 55, identifier:get_detector; 56, argument_list; 57, try_statement; 57, 58; 57, 397; 57, 398; 58, ERROR; 58, 59; 59, block; 59, 60; 59, 350; 59, 365; 59, 380; 59, 386; 60, while_statement; 60, 61; 60, 65; 60, 95; 61, not_operator; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_stop; 65, ERROR; 65, 66; 65, 72; 65, 78; 65, 81; 65, 87; 65, 90; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:cycle_start; 69, call; 69, 70; 69, 71; 70, identifier:timer; 71, argument_list; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:cycle_start_cpu; 75, call; 75, 76; 75, 77; 76, identifier:process_time; 77, argument_list; 78, attribute; 78, 79; 78, 80; 79, identifier:log; 80, identifier:debug; 81, ERROR; 81, 82; 81, 83; 81, 84; 82, identifier:Pumping; 83, identifier:blob; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:blob; 87, call; 87, 88; 87, 89; 88, identifier:Blob; 89, argument_list; 90, for_in_clause; 90, 91; 90, 92; 91, identifier:module; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:modules; 95, block; 95, 96; 95, 118; 95, 162; 95, 194; 95, 234; 95, 248; 95, 254; 95, 260; 95, 267; 95, 312; 96, if_statement; 96, 97; 96, 102; 97, comparison_operator:is; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:blob; 101, None; 102, block; 102, 103; 102, 117; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:log; 107, identifier:debug; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, string:"Skipping {0}, due to empty blob."; 112, identifier:format; 113, argument_list; 113, 114; 114, attribute; 114, 115; 114, 116; 115, identifier:module; 116, identifier:name; 117, continue_statement; 118, if_statement; 118, 119; 118, 141; 119, boolean_operator:and; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:module; 122, identifier:only_if; 123, not_operator; 123, 124; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:module; 128, identifier:only_if; 129, identifier:issubset; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:set; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:blob; 139, identifier:keys; 140, argument_list; 141, block; 141, 142; 141, 161; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:log; 146, identifier:debug; 147, argument_list; 147, 148; 148, call; 148, 149; 148, 154; 149, attribute; 149, 150; 149, 153; 150, concatenated_string; 150, 151; 150, 152; 151, string:"Skipping {0}, due to missing required key"; 152, string:"'{1}'."; 153, identifier:format; 154, argument_list; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:module; 157, identifier:name; 158, attribute; 158, 159; 158, 160; 159, identifier:module; 160, identifier:only_if; 161, continue_statement; 162, if_statement; 162, 163; 162, 175; 163, comparison_operator:!=; 163, 164; 163, 174; 164, binary_operator:%; 164, 165; 164, 171; 165, parenthesized_expression; 165, 166; 166, binary_operator:+; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:_cycle_count; 170, integer:1; 171, attribute; 171, 172; 171, 173; 172, identifier:module; 173, identifier:every; 174, integer:0; 175, block; 175, 176; 175, 193; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:log; 180, identifier:debug; 181, argument_list; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, string:"Skipping {0} (every {1} iterations)."; 185, identifier:format; 186, argument_list; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:module; 189, identifier:name; 190, attribute; 190, 191; 190, 192; 191, identifier:module; 192, identifier:every; 193, continue_statement; 194, if_statement; 194, 195; 194, 200; 194, 226; 195, comparison_operator:is; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:module; 198, identifier:blob_keys; 199, None; 200, block; 200, 201; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:blob_to_send; 204, call; 204, 205; 204, 206; 205, identifier:Blob; 206, argument_list; 206, 207; 207, dictionary_comprehension; 207, 208; 207, 215; 207, 220; 208, pair; 208, 209; 208, 210; 209, identifier:k; 210, subscript; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:self; 213, identifier:blob; 214, identifier:k; 215, for_in_clause; 215, 216; 215, 217; 216, identifier:k; 217, attribute; 217, 218; 217, 219; 218, identifier:module; 219, identifier:blob_keys; 220, if_clause; 220, 221; 221, comparison_operator:in; 221, 222; 221, 223; 222, identifier:k; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:blob; 226, else_clause; 226, 227; 227, block; 227, 228; 228, expression_statement; 228, 229; 229, assignment; 229, 230; 229, 231; 230, identifier:blob_to_send; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:blob; 234, expression_statement; 234, 235; 235, call; 235, 236; 235, 239; 236, attribute; 236, 237; 236, 238; 237, identifier:log; 238, identifier:debug; 239, argument_list; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, string:"Processing {0} "; 243, identifier:format; 244, argument_list; 244, 245; 245, attribute; 245, 246; 245, 247; 246, identifier:module; 247, identifier:name; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:start; 251, call; 251, 252; 251, 253; 252, identifier:timer; 253, argument_list; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:start_cpu; 257, call; 257, 258; 257, 259; 258, identifier:process_time; 259, argument_list; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:new_blob; 263, call; 263, 264; 263, 265; 264, identifier:module; 265, argument_list; 265, 266; 266, identifier:blob_to_send; 267, if_statement; 267, 268; 267, 275; 268, boolean_operator:or; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:self; 271, identifier:timeit; 272, attribute; 272, 273; 272, 274; 273, identifier:module; 274, identifier:timeit; 275, block; 275, 276; 275, 294; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 288; 278, attribute; 278, 279; 278, 286; 278, 287; 279, subscript; 279, 280; 279, 285; 280, subscript; 280, 281; 280, 284; 281, attribute; 281, 282; 281, 283; 282, identifier:self; 283, identifier:_timeit; 284, identifier:module; 285, string:'process'; 286, line_continuation:\; 287, identifier:append; 288, argument_list; 288, 289; 289, binary_operator:-; 289, 290; 289, 293; 290, call; 290, 291; 290, 292; 291, identifier:timer; 292, argument_list; 293, identifier:start; 294, expression_statement; 294, 295; 295, call; 295, 296; 295, 306; 296, attribute; 296, 297; 296, 304; 296, 305; 297, subscript; 297, 298; 297, 303; 298, subscript; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:self; 301, identifier:_timeit; 302, identifier:module; 303, string:'process_cpu'; 304, line_continuation:\; 305, identifier:append; 306, argument_list; 306, 307; 307, binary_operator:-; 307, 308; 307, 311; 308, call; 308, 309; 308, 310; 309, identifier:process_time; 310, argument_list; 311, identifier:start_cpu; 312, if_statement; 312, 313; 312, 318; 312, 342; 313, comparison_operator:is; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:module; 316, identifier:blob_keys; 317, None; 318, block; 318, 319; 319, if_statement; 319, 320; 319, 323; 320, comparison_operator:is; 320, 321; 320, 322; 321, identifier:new_blob; 322, None; 323, block; 323, 324; 324, for_statement; 324, 325; 324, 326; 324, 331; 325, identifier:key; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:new_blob; 329, identifier:keys; 330, argument_list; 331, block; 331, 332; 332, expression_statement; 332, 333; 333, assignment; 333, 334; 333, 339; 334, subscript; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:self; 337, identifier:blob; 338, identifier:key; 339, subscript; 339, 340; 339, 341; 340, identifier:new_blob; 341, identifier:key; 342, else_clause; 342, 343; 343, block; 343, 344; 344, expression_statement; 344, 345; 345, assignment; 345, 346; 345, 349; 346, attribute; 346, 347; 346, 348; 347, identifier:self; 348, identifier:blob; 349, identifier:new_blob; 350, expression_statement; 350, 351; 351, call; 351, 352; 351, 359; 352, attribute; 352, 353; 352, 358; 353, subscript; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:self; 356, identifier:_timeit; 357, string:'cycles'; 358, identifier:append; 359, argument_list; 359, 360; 360, binary_operator:-; 360, 361; 360, 364; 361, call; 361, 362; 361, 363; 362, identifier:timer; 363, argument_list; 364, identifier:cycle_start; 365, expression_statement; 365, 366; 366, call; 366, 367; 366, 374; 367, attribute; 367, 368; 367, 373; 368, subscript; 368, 369; 368, 372; 369, attribute; 369, 370; 369, 371; 370, identifier:self; 371, identifier:_timeit; 372, string:'cycles_cpu'; 373, identifier:append; 374, argument_list; 374, 375; 375, binary_operator:-; 375, 376; 375, 379; 376, call; 376, 377; 376, 378; 377, identifier:process_time; 378, argument_list; 379, identifier:cycle_start_cpu; 380, expression_statement; 380, 381; 381, augmented_assignment:+=; 381, 382; 381, 385; 382, attribute; 382, 383; 382, 384; 383, identifier:self; 384, identifier:_cycle_count; 385, integer:1; 386, if_statement; 386, 387; 386, 394; 387, boolean_operator:and; 387, 388; 387, 389; 388, identifier:cycles; 389, comparison_operator:>=; 389, 390; 389, 393; 390, attribute; 390, 391; 390, 392; 391, identifier:self; 392, identifier:_cycle_count; 393, identifier:cycles; 394, block; 394, 395; 395, raise_statement; 395, 396; 396, identifier:StopIteration; 397, block:; 398, except_clause; 398, 399; 398, 400; 399, identifier:StopIteration; 400, block; 400, 401; 401, expression_statement; 401, 402; 402, call; 402, 403; 402, 406; 403, attribute; 403, 404; 403, 405; 404, identifier:log; 405, identifier:info; 406, argument_list; 406, 407; 407, string:"Nothing left to pump through."; 408, return_statement; 408, 409; 409, call; 409, 410; 409, 413; 410, attribute; 410, 411; 410, 412; 411, identifier:self; 412, identifier:finish; 413, argument_list | def _drain(self, cycles=None):
log.info("Now draining...")
if not cycles:
log.info("No cycle count, the pipeline may be drained forever.")
if self.calibration:
log.info("Setting up the detector calibration.")
for module in self.modules:
module.detector = self.calibration.get_detector()
try:
while not self._stop:
cycle_start = timer()
cycle_start_cpu = process_time()
log.debug("Pumping blob
self.blob = Blob()
for module in self.modules:
if self.blob is None:
log.debug(
"Skipping {0}, due to empty blob.".format(
module.name
)
)
continue
if module.only_if and not module.only_if.issubset(set(
self.blob.keys())):
log.debug(
"Skipping {0}, due to missing required key"
"'{1}'.".format(module.name, module.only_if)
)
continue
if (self._cycle_count + 1) % module.every != 0:
log.debug(
"Skipping {0} (every {1} iterations).".format(
module.name, module.every
)
)
continue
if module.blob_keys is not None:
blob_to_send = Blob({
k: self.blob[k]
for k in module.blob_keys
if k in self.blob
})
else:
blob_to_send = self.blob
log.debug("Processing {0} ".format(module.name))
start = timer()
start_cpu = process_time()
new_blob = module(blob_to_send)
if self.timeit or module.timeit:
self._timeit[module]['process'] \
.append(timer() - start)
self._timeit[module]['process_cpu'] \
.append(process_time() - start_cpu)
if module.blob_keys is not None:
if new_blob is not None:
for key in new_blob.keys():
self.blob[key] = new_blob[key]
else:
self.blob = new_blob
self._timeit['cycles'].append(timer() - cycle_start)
self._timeit['cycles_cpu'].append(
process_time() - cycle_start_cpu
)
self._cycle_count += 1
if cycles and self._cycle_count >= cycles:
raise StopIteration
except StopIteration:
log.info("Nothing left to pump through.")
return self.finish() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:start; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:backdate; 6, None; 7, block; 7, 8; 7, 20; 7, 38; 7, 50; 7, 56; 7, 122; 7, 130; 7, 138; 7, 146; 7, 154; 8, if_statement; 8, 9; 8, 14; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:f; 12, identifier:s; 13, identifier:cum; 14, block; 14, 15; 15, raise_statement; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:StartError; 18, argument_list; 18, 19; 19, string:"Already have stamps, can't start again (must reset)."; 20, if_statement; 20, 21; 20, 32; 21, boolean_operator:or; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:f; 25, identifier:t; 26, identifier:subdvsn_awaiting; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:f; 30, identifier:t; 31, identifier:par_subdvsn_awaiting; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:StartError; 36, argument_list; 36, 37; 37, string:"Already have subdivisions, can't start again (must reset)."; 38, if_statement; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:f; 42, identifier:t; 43, identifier:stopped; 44, block; 44, 45; 45, raise_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:StoppedError; 48, argument_list; 48, 49; 49, string:"Timer already stopped (must open new or reset)."; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:t; 53, call; 53, 54; 53, 55; 54, identifier:timer; 55, argument_list; 56, if_statement; 56, 57; 56, 60; 56, 65; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:backdate; 59, None; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:t_start; 64, identifier:t; 65, else_clause; 65, 66; 66, block; 66, 67; 66, 81; 66, 94; 66, 104; 66, 118; 67, if_statement; 67, 68; 67, 75; 68, comparison_operator:is; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:f; 71, identifier:t; 72, attribute; 72, 73; 72, 74; 73, identifier:f; 74, identifier:root; 75, block; 75, 76; 76, raise_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:BackdateError; 79, argument_list; 79, 80; 80, string:"Cannot backdate start of root timer."; 81, if_statement; 81, 82; 81, 88; 82, not_operator; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:isinstance; 85, argument_list; 85, 86; 85, 87; 86, identifier:backdate; 87, identifier:float; 88, block; 88, 89; 89, raise_statement; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:TypeError; 92, argument_list; 92, 93; 93, string:"Backdate must be type float."; 94, if_statement; 94, 95; 94, 98; 95, comparison_operator:>; 95, 96; 95, 97; 96, identifier:backdate; 97, identifier:t; 98, block; 98, 99; 99, raise_statement; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:BackdateError; 102, argument_list; 102, 103; 103, string:"Cannot backdate to future time."; 104, if_statement; 104, 105; 104, 112; 105, comparison_operator:<; 105, 106; 105, 107; 106, identifier:backdate; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:f; 110, identifier:tm1; 111, identifier:last_t; 112, block; 112, 113; 113, raise_statement; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:BackdateError; 116, argument_list; 116, 117; 117, string:"Cannot backdate start to time previous to latest stamp in parent timer."; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:t_start; 121, identifier:backdate; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:f; 127, identifier:t; 128, identifier:paused; 129, False; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:f; 135, identifier:t; 136, identifier:tmp_total; 137, float:0.; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 145; 140, attribute; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:f; 143, identifier:t; 144, identifier:start_t; 145, identifier:t_start; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 153; 148, attribute; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:f; 151, identifier:t; 152, identifier:last_t; 153, identifier:t_start; 154, return_statement; 154, 155; 155, identifier:t | def start(backdate=None):
if f.s.cum:
raise StartError("Already have stamps, can't start again (must reset).")
if f.t.subdvsn_awaiting or f.t.par_subdvsn_awaiting:
raise StartError("Already have subdivisions, can't start again (must reset).")
if f.t.stopped:
raise StoppedError("Timer already stopped (must open new or reset).")
t = timer()
if backdate is None:
t_start = t
else:
if f.t is f.root:
raise BackdateError("Cannot backdate start of root timer.")
if not isinstance(backdate, float):
raise TypeError("Backdate must be type float.")
if backdate > t:
raise BackdateError("Cannot backdate to future time.")
if backdate < f.tm1.last_t:
raise BackdateError("Cannot backdate start to time previous to latest stamp in parent timer.")
t_start = backdate
f.t.paused = False
f.t.tmp_total = 0.
f.t.start_t = t_start
f.t.last_t = t_start
return t |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:stamp; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:name; 5, default_parameter; 5, 6; 5, 7; 6, identifier:backdate; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:unique; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:keep_subdivisions; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:quick_print; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:un; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:ks; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:qp; 25, None; 26, block; 26, 27; 26, 33; 26, 45; 26, 57; 26, 109; 26, 119; 26, 140; 26, 161; 26, 182; 26, 191; 26, 199; 26, 207; 26, 217; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:t; 30, call; 30, 31; 30, 32; 31, identifier:timer; 32, argument_list; 33, if_statement; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:f; 37, identifier:t; 38, identifier:stopped; 39, block; 39, 40; 40, raise_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:StoppedError; 43, argument_list; 43, 44; 44, string:"Cannot stamp stopped timer."; 45, if_statement; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:f; 49, identifier:t; 50, identifier:paused; 51, block; 51, 52; 52, raise_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:PausedError; 55, argument_list; 55, 56; 56, string:"Cannot stamp paused timer."; 57, if_statement; 57, 58; 57, 61; 57, 66; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:backdate; 60, None; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:t_stamp; 65, identifier:t; 66, else_clause; 66, 67; 67, block; 67, 68; 67, 81; 67, 91; 67, 105; 68, if_statement; 68, 69; 68, 75; 69, not_operator; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:isinstance; 72, argument_list; 72, 73; 72, 74; 73, identifier:backdate; 74, identifier:float; 75, block; 75, 76; 76, raise_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:TypeError; 79, argument_list; 79, 80; 80, string:"Backdate must be type float."; 81, if_statement; 81, 82; 81, 85; 82, comparison_operator:>; 82, 83; 82, 84; 83, identifier:backdate; 84, identifier:t; 85, block; 85, 86; 86, raise_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:BackdateError; 89, argument_list; 89, 90; 90, string:"Cannot backdate to future time."; 91, if_statement; 91, 92; 91, 99; 92, comparison_operator:<; 92, 93; 92, 94; 93, identifier:backdate; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:f; 97, identifier:t; 98, identifier:last_t; 99, block; 99, 100; 100, raise_statement; 100, 101; 101, call; 101, 102; 101, 103; 102, identifier:BackdateError; 103, argument_list; 103, 104; 104, string:"Cannot backdate to time earlier than last stamp."; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:t_stamp; 108, identifier:backdate; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:elapsed; 112, binary_operator:-; 112, 113; 112, 114; 113, identifier:t_stamp; 114, attribute; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:f; 117, identifier:t; 118, identifier:last_t; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:unique; 122, conditional_expression:if; 122, 123; 122, 126; 122, 134; 123, subscript; 123, 124; 123, 125; 124, identifier:SET; 125, string:'UN'; 126, parenthesized_expression; 126, 127; 127, boolean_operator:and; 127, 128; 127, 131; 128, comparison_operator:is; 128, 129; 128, 130; 129, identifier:unique; 130, None; 131, comparison_operator:is; 131, 132; 131, 133; 132, identifier:un; 133, None; 134, call; 134, 135; 134, 136; 135, identifier:bool; 136, argument_list; 136, 137; 137, boolean_operator:or; 137, 138; 137, 139; 138, identifier:unique; 139, identifier:un; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:keep_subdivisions; 143, conditional_expression:if; 143, 144; 143, 147; 143, 155; 144, subscript; 144, 145; 144, 146; 145, identifier:SET; 146, string:'KS'; 147, parenthesized_expression; 147, 148; 148, boolean_operator:and; 148, 149; 148, 152; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:keep_subdivisions; 151, None; 152, comparison_operator:is; 152, 153; 152, 154; 153, identifier:ks; 154, None; 155, call; 155, 156; 155, 157; 156, identifier:bool; 157, argument_list; 157, 158; 158, boolean_operator:or; 158, 159; 158, 160; 159, identifier:keep_subdivisions; 160, identifier:ks; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:quick_print; 164, conditional_expression:if; 164, 165; 164, 168; 164, 176; 165, subscript; 165, 166; 165, 167; 166, identifier:SET; 167, string:'QP'; 168, parenthesized_expression; 168, 169; 169, boolean_operator:and; 169, 170; 169, 173; 170, comparison_operator:is; 170, 171; 170, 172; 171, identifier:quick_print; 172, None; 173, comparison_operator:is; 173, 174; 173, 175; 174, identifier:qp; 175, None; 176, call; 176, 177; 176, 178; 177, identifier:bool; 178, argument_list; 178, 179; 179, boolean_operator:or; 179, 180; 179, 181; 180, identifier:quick_print; 181, identifier:qp; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:_stamp; 185, argument_list; 185, 186; 185, 187; 185, 188; 185, 189; 185, 190; 186, identifier:name; 187, identifier:elapsed; 188, identifier:unique; 189, identifier:keep_subdivisions; 190, identifier:quick_print; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:tmp_self; 194, binary_operator:-; 194, 195; 194, 198; 195, call; 195, 196; 195, 197; 196, identifier:timer; 197, argument_list; 198, identifier:t; 199, expression_statement; 199, 200; 200, augmented_assignment:+=; 200, 201; 200, 206; 201, attribute; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:f; 204, identifier:t; 205, identifier:self_cut; 206, identifier:tmp_self; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 214; 209, attribute; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:f; 212, identifier:t; 213, identifier:last_t; 214, binary_operator:+; 214, 215; 214, 216; 215, identifier:t_stamp; 216, identifier:tmp_self; 217, return_statement; 217, 218; 218, identifier:t | def stamp(name, backdate=None,
unique=None, keep_subdivisions=None, quick_print=None,
un=None, ks=None, qp=None):
t = timer()
if f.t.stopped:
raise StoppedError("Cannot stamp stopped timer.")
if f.t.paused:
raise PausedError("Cannot stamp paused timer.")
if backdate is None:
t_stamp = t
else:
if not isinstance(backdate, float):
raise TypeError("Backdate must be type float.")
if backdate > t:
raise BackdateError("Cannot backdate to future time.")
if backdate < f.t.last_t:
raise BackdateError("Cannot backdate to time earlier than last stamp.")
t_stamp = backdate
elapsed = t_stamp - f.t.last_t
unique = SET['UN'] if (unique is None and un is None) else bool(unique or un)
keep_subdivisions = SET['KS'] if (keep_subdivisions is None and ks is None) else bool(keep_subdivisions or ks)
quick_print = SET['QP'] if (quick_print is None and qp is None) else bool(quick_print or qp)
_stamp(name, elapsed, unique, keep_subdivisions, quick_print)
tmp_self = timer() - t
f.t.self_cut += tmp_self
f.t.last_t = t_stamp + tmp_self
return t |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 28; 2, function_name:stop; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 4, default_parameter; 4, 5; 4, 6; 5, identifier:name; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:backdate; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:unique; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:keep_subdivisions; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:quick_print; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:un; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:ks; 24, None; 25, default_parameter; 25, 26; 25, 27; 26, identifier:qp; 27, None; 28, block; 28, 29; 28, 35; 28, 47; 28, 113; 28, 134; 28, 155; 28, 176; 28, 222; 28, 260; 28, 282; 28, 294; 28, 306; 28, 312; 28, 320; 28, 342; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:t; 32, call; 32, 33; 32, 34; 33, identifier:timer; 34, argument_list; 35, if_statement; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:f; 39, identifier:t; 40, identifier:stopped; 41, block; 41, 42; 42, raise_statement; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:StoppedError; 45, argument_list; 45, 46; 46, string:"Timer already stopped."; 47, if_statement; 47, 48; 47, 51; 47, 56; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:backdate; 50, None; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:t_stop; 55, identifier:t; 56, else_clause; 56, 57; 57, block; 57, 58; 57, 72; 57, 85; 57, 95; 57, 109; 58, if_statement; 58, 59; 58, 66; 59, comparison_operator:is; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:f; 62, identifier:t; 63, attribute; 63, 64; 63, 65; 64, identifier:f; 65, identifier:root; 66, block; 66, 67; 67, raise_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:BackdateError; 70, argument_list; 70, 71; 71, string:"Cannot backdate stop of root timer."; 72, if_statement; 72, 73; 72, 79; 73, not_operator; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:isinstance; 76, argument_list; 76, 77; 76, 78; 77, identifier:backdate; 78, identifier:float; 79, block; 79, 80; 80, raise_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:TypeError; 83, argument_list; 83, 84; 84, string:"Backdate must be type float."; 85, if_statement; 85, 86; 85, 89; 86, comparison_operator:>; 86, 87; 86, 88; 87, identifier:backdate; 88, identifier:t; 89, block; 89, 90; 90, raise_statement; 90, 91; 91, call; 91, 92; 91, 93; 92, identifier:BackdateError; 93, argument_list; 93, 94; 94, string:"Cannot backdate to future time."; 95, if_statement; 95, 96; 95, 103; 96, comparison_operator:<; 96, 97; 96, 98; 97, identifier:backdate; 98, attribute; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:f; 101, identifier:t; 102, identifier:last_t; 103, block; 103, 104; 104, raise_statement; 104, 105; 105, call; 105, 106; 105, 107; 106, identifier:BackdateError; 107, argument_list; 107, 108; 108, string:"Cannot backdate to time earlier than last stamp."; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:t_stop; 112, identifier:backdate; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:unique; 116, conditional_expression:if; 116, 117; 116, 120; 116, 128; 117, subscript; 117, 118; 117, 119; 118, identifier:SET; 119, string:'UN'; 120, parenthesized_expression; 120, 121; 121, boolean_operator:and; 121, 122; 121, 125; 122, comparison_operator:is; 122, 123; 122, 124; 123, identifier:unique; 124, None; 125, comparison_operator:is; 125, 126; 125, 127; 126, identifier:un; 127, None; 128, call; 128, 129; 128, 130; 129, identifier:bool; 130, argument_list; 130, 131; 131, boolean_operator:or; 131, 132; 131, 133; 132, identifier:unique; 133, identifier:un; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:keep_subdivisions; 137, conditional_expression:if; 137, 138; 137, 141; 137, 149; 138, subscript; 138, 139; 138, 140; 139, identifier:SET; 140, string:'KS'; 141, parenthesized_expression; 141, 142; 142, boolean_operator:and; 142, 143; 142, 146; 143, comparison_operator:is; 143, 144; 143, 145; 144, identifier:keep_subdivisions; 145, None; 146, comparison_operator:is; 146, 147; 146, 148; 147, identifier:ks; 148, None; 149, call; 149, 150; 149, 151; 150, identifier:bool; 151, argument_list; 151, 152; 152, boolean_operator:or; 152, 153; 152, 154; 153, identifier:keep_subdivisions; 154, identifier:ks; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:quick_print; 158, conditional_expression:if; 158, 159; 158, 162; 158, 170; 159, subscript; 159, 160; 159, 161; 160, identifier:SET; 161, string:'QP'; 162, parenthesized_expression; 162, 163; 163, boolean_operator:and; 163, 164; 163, 167; 164, comparison_operator:is; 164, 165; 164, 166; 165, identifier:quick_print; 166, None; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:qp; 169, None; 170, call; 170, 171; 170, 172; 171, identifier:bool; 172, argument_list; 172, 173; 173, boolean_operator:or; 173, 174; 173, 175; 174, identifier:quick_print; 175, identifier:qp; 176, if_statement; 176, 177; 176, 180; 176, 212; 177, comparison_operator:is; 177, 178; 177, 179; 178, identifier:name; 179, None; 180, block; 180, 181; 180, 193; 180, 203; 181, if_statement; 181, 182; 181, 187; 182, attribute; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:f; 185, identifier:t; 186, identifier:paused; 187, block; 187, 188; 188, raise_statement; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:PausedError; 191, argument_list; 191, 192; 192, string:"Cannot stamp paused timer."; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:elapsed; 196, binary_operator:-; 196, 197; 196, 198; 197, identifier:t_stop; 198, attribute; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:f; 201, identifier:t; 202, identifier:last_t; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 206; 205, identifier:_stamp; 206, argument_list; 206, 207; 206, 208; 206, 209; 206, 210; 206, 211; 207, identifier:name; 208, identifier:elapsed; 209, identifier:unique; 210, identifier:keep_subdivisions; 211, identifier:quick_print; 212, else_clause; 212, 213; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:times_priv; 218, identifier:assign_subdivisions; 219, argument_list; 219, 220; 219, 221; 220, identifier:UNASGN; 221, identifier:keep_subdivisions; 222, for_statement; 222, 223; 222, 224; 222, 229; 223, identifier:s; 224, attribute; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:f; 227, identifier:t; 228, identifier:rgstr_stamps; 229, block; 229, 230; 230, if_statement; 230, 231; 230, 238; 231, comparison_operator:not; 231, 232; 231, 233; 232, identifier:s; 233, attribute; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:f; 236, identifier:s; 237, identifier:cum; 238, block; 238, 239; 238, 249; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 248; 241, subscript; 241, 242; 241, 247; 242, attribute; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:f; 245, identifier:s; 246, identifier:cum; 247, identifier:s; 248, float:0.; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 258; 251, attribute; 251, 252; 251, 257; 252, attribute; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:f; 255, identifier:s; 256, identifier:order; 257, identifier:append; 258, argument_list; 258, 259; 259, identifier:s; 260, if_statement; 260, 261; 260, 267; 261, not_operator; 261, 262; 262, attribute; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:f; 265, identifier:t; 266, identifier:paused; 267, block; 267, 268; 268, expression_statement; 268, 269; 269, augmented_assignment:+=; 269, 270; 269, 275; 270, attribute; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:f; 273, identifier:t; 274, identifier:tmp_total; 275, binary_operator:-; 275, 276; 275, 277; 276, identifier:t_stop; 277, attribute; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:f; 280, identifier:t; 281, identifier:start_t; 282, expression_statement; 282, 283; 283, augmented_assignment:-=; 283, 284; 283, 289; 284, attribute; 284, 285; 284, 288; 285, attribute; 285, 286; 285, 287; 286, identifier:f; 287, identifier:t; 288, identifier:tmp_total; 289, attribute; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:f; 292, identifier:t; 293, identifier:self_cut; 294, expression_statement; 294, 295; 295, augmented_assignment:+=; 295, 296; 295, 301; 296, attribute; 296, 297; 296, 300; 297, attribute; 297, 298; 297, 299; 298, identifier:f; 299, identifier:t; 300, identifier:self_cut; 301, binary_operator:-; 301, 302; 301, 305; 302, call; 302, 303; 302, 304; 303, identifier:timer; 304, argument_list; 305, identifier:t; 306, expression_statement; 306, 307; 307, call; 307, 308; 307, 311; 308, attribute; 308, 309; 308, 310; 309, identifier:times_priv; 310, identifier:dump_times; 311, argument_list; 312, expression_statement; 312, 313; 313, assignment; 313, 314; 313, 319; 314, attribute; 314, 315; 314, 318; 315, attribute; 315, 316; 315, 317; 316, identifier:f; 317, identifier:t; 318, identifier:stopped; 319, True; 320, if_statement; 320, 321; 320, 322; 321, identifier:quick_print; 322, block; 322, 323; 323, expression_statement; 323, 324; 324, call; 324, 325; 324, 326; 325, identifier:print; 326, argument_list; 326, 327; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, string:"({}) Total: {:.4f}"; 330, identifier:format; 331, argument_list; 331, 332; 331, 337; 332, attribute; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:f; 335, identifier:t; 336, identifier:name; 337, attribute; 337, 338; 337, 341; 338, attribute; 338, 339; 338, 340; 339, identifier:f; 340, identifier:r; 341, identifier:total; 342, return_statement; 342, 343; 343, identifier:t | def stop(name=None, backdate=None,
unique=None, keep_subdivisions=None, quick_print=None,
un=None, ks=None, qp=None):
t = timer()
if f.t.stopped:
raise StoppedError("Timer already stopped.")
if backdate is None:
t_stop = t
else:
if f.t is f.root:
raise BackdateError("Cannot backdate stop of root timer.")
if not isinstance(backdate, float):
raise TypeError("Backdate must be type float.")
if backdate > t:
raise BackdateError("Cannot backdate to future time.")
if backdate < f.t.last_t:
raise BackdateError("Cannot backdate to time earlier than last stamp.")
t_stop = backdate
unique = SET['UN'] if (unique is None and un is None) else bool(unique or un)
keep_subdivisions = SET['KS'] if (keep_subdivisions is None and ks is None) else bool(keep_subdivisions or ks)
quick_print = SET['QP'] if (quick_print is None and qp is None) else bool(quick_print or qp)
if name is not None:
if f.t.paused:
raise PausedError("Cannot stamp paused timer.")
elapsed = t_stop - f.t.last_t
_stamp(name, elapsed, unique, keep_subdivisions, quick_print)
else:
times_priv.assign_subdivisions(UNASGN, keep_subdivisions)
for s in f.t.rgstr_stamps:
if s not in f.s.cum:
f.s.cum[s] = 0.
f.s.order.append(s)
if not f.t.paused:
f.t.tmp_total += t_stop - f.t.start_t
f.t.tmp_total -= f.t.self_cut
f.t.self_cut += timer() - t
times_priv.dump_times()
f.t.stopped = True
if quick_print:
print("({}) Total: {:.4f}".format(f.t.name, f.r.total))
return t |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 38; 2, function_name:timed_loop; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 15; 3, 18; 3, 23; 3, 28; 3, 33; 4, default_parameter; 4, 5; 4, 6; 5, identifier:name; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:rgstr_stamps; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:save_itrs; 12, subscript; 12, 13; 12, 14; 13, identifier:SET; 14, string:'SI'; 15, default_parameter; 15, 16; 15, 17; 16, identifier:loop_end_stamp; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:end_stamp_unique; 20, subscript; 20, 21; 20, 22; 21, identifier:SET; 22, string:'UN'; 23, default_parameter; 23, 24; 23, 25; 24, identifier:keep_prev_subdivisions; 25, subscript; 25, 26; 25, 27; 26, identifier:SET; 27, string:'KS'; 28, default_parameter; 28, 29; 28, 30; 29, identifier:keep_end_subdivisions; 30, subscript; 30, 31; 30, 32; 31, identifier:SET; 32, string:'KS'; 33, default_parameter; 33, 34; 33, 35; 34, identifier:quick_print; 35, subscript; 35, 36; 35, 37; 36, identifier:SET; 37, string:'QP'; 38, block; 38, 39; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:TimedLoop; 42, argument_list; 42, 43; 42, 46; 42, 49; 42, 52; 42, 55; 42, 58; 42, 61; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:name; 45, identifier:name; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:rgstr_stamps; 48, identifier:rgstr_stamps; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:save_itrs; 51, identifier:save_itrs; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:loop_end_stamp; 54, identifier:loop_end_stamp; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:end_stamp_unique; 57, identifier:end_stamp_unique; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:keep_prev_subdivisions; 60, identifier:keep_prev_subdivisions; 61, keyword_argument; 61, 62; 61, 63; 62, identifier:keep_end_subdivisions; 63, identifier:keep_end_subdivisions | def timed_loop(name=None,
rgstr_stamps=None,
save_itrs=SET['SI'],
loop_end_stamp=None,
end_stamp_unique=SET['UN'],
keep_prev_subdivisions=SET['KS'],
keep_end_subdivisions=SET['KS'],
quick_print=SET['QP']):
return TimedLoop(name=name,
rgstr_stamps=rgstr_stamps,
save_itrs=save_itrs,
loop_end_stamp=loop_end_stamp,
end_stamp_unique=end_stamp_unique,
keep_prev_subdivisions=keep_prev_subdivisions,
keep_end_subdivisions=keep_end_subdivisions) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 39; 2, function_name:timed_for; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 16; 3, 19; 3, 24; 3, 29; 3, 34; 4, identifier:iterable; 5, default_parameter; 5, 6; 5, 7; 6, identifier:name; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:rgstr_stamps; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:save_itrs; 13, subscript; 13, 14; 13, 15; 14, identifier:SET; 15, string:'SI'; 16, default_parameter; 16, 17; 16, 18; 17, identifier:loop_end_stamp; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:end_stamp_unique; 21, subscript; 21, 22; 21, 23; 22, identifier:SET; 23, string:'UN'; 24, default_parameter; 24, 25; 24, 26; 25, identifier:keep_prev_subdivisions; 26, subscript; 26, 27; 26, 28; 27, identifier:SET; 28, string:'KS'; 29, default_parameter; 29, 30; 29, 31; 30, identifier:keep_end_subdivisions; 31, subscript; 31, 32; 31, 33; 32, identifier:SET; 33, string:'KS'; 34, default_parameter; 34, 35; 34, 36; 35, identifier:quick_print; 36, subscript; 36, 37; 36, 38; 37, identifier:SET; 38, string:'QP'; 39, block; 39, 40; 40, return_statement; 40, 41; 41, call; 41, 42; 41, 43; 42, identifier:TimedFor; 43, argument_list; 43, 44; 43, 45; 43, 48; 43, 51; 43, 54; 43, 57; 43, 60; 43, 63; 44, identifier:iterable; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:name; 47, identifier:name; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:rgstr_stamps; 50, identifier:rgstr_stamps; 51, keyword_argument; 51, 52; 51, 53; 52, identifier:save_itrs; 53, identifier:save_itrs; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:loop_end_stamp; 56, identifier:loop_end_stamp; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:end_stamp_unique; 59, identifier:end_stamp_unique; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:keep_prev_subdivisions; 62, identifier:keep_prev_subdivisions; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:keep_end_subdivisions; 65, identifier:keep_end_subdivisions | def timed_for(iterable,
name=None,
rgstr_stamps=None,
save_itrs=SET['SI'],
loop_end_stamp=None,
end_stamp_unique=SET['UN'],
keep_prev_subdivisions=SET['KS'],
keep_end_subdivisions=SET['KS'],
quick_print=SET['QP']):
return TimedFor(iterable,
name=name,
rgstr_stamps=rgstr_stamps,
save_itrs=save_itrs,
loop_end_stamp=loop_end_stamp,
end_stamp_unique=end_stamp_unique,
keep_prev_subdivisions=keep_prev_subdivisions,
keep_end_subdivisions=keep_end_subdivisions) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:format_gmeta; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:acl; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:identifier; 10, None; 11, block; 11, 12; 12, if_statement; 12, 13; 12, 18; 12, 122; 12, 152; 13, call; 13, 14; 13, 15; 14, identifier:isinstance; 15, argument_list; 15, 16; 15, 17; 16, identifier:data; 17, identifier:dict; 18, block; 18, 19; 18, 33; 18, 45; 18, 49; 18, 105; 19, if_statement; 19, 20; 19, 27; 20, boolean_operator:or; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:acl; 23, None; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:identifier; 26, None; 27, block; 27, 28; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:ValueError; 31, argument_list; 31, 32; 32, string:"acl and identifier are required when formatting a GMetaEntry."; 33, if_statement; 33, 34; 33, 39; 34, call; 34, 35; 34, 36; 35, identifier:isinstance; 36, argument_list; 36, 37; 36, 38; 37, identifier:acl; 38, identifier:str; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:acl; 43, list:[acl]; 43, 44; 44, identifier:acl; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:prefixed_acl; 48, list:[]; 49, for_statement; 49, 50; 49, 51; 49, 52; 50, identifier:uuid; 51, identifier:acl; 52, block; 52, 53; 53, if_statement; 53, 54; 53, 69; 53, 96; 54, boolean_operator:and; 54, 55; 54, 58; 55, comparison_operator:!=; 55, 56; 55, 57; 56, identifier:uuid; 57, string:"public"; 58, not_operator; 58, 59; 59, call; 59, 60; 59, 67; 60, attribute; 60, 61; 60, 66; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:uuid; 64, identifier:lower; 65, argument_list; 66, identifier:startswith; 67, argument_list; 67, 68; 68, string:"urn:"; 69, block; 69, 70; 69, 83; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:prefixed_acl; 74, identifier:append; 75, argument_list; 75, 76; 76, binary_operator:+; 76, 77; 76, 78; 77, string:"urn:globus:auth:identity:"; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:uuid; 81, identifier:lower; 82, argument_list; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:prefixed_acl; 87, identifier:append; 88, argument_list; 88, 89; 89, binary_operator:+; 89, 90; 89, 91; 90, string:"urn:globus:groups:id:"; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:uuid; 94, identifier:lower; 95, argument_list; 96, else_clause; 96, 97; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:prefixed_acl; 102, identifier:append; 103, argument_list; 103, 104; 104, identifier:uuid; 105, return_statement; 105, 106; 106, dictionary; 106, 107; 106, 110; 106, 113; 106, 116; 106, 119; 107, pair; 107, 108; 107, 109; 108, string:"@datatype"; 109, string:"GMetaEntry"; 110, pair; 110, 111; 110, 112; 111, string:"@version"; 112, string:"2016-11-09"; 113, pair; 113, 114; 113, 115; 114, string:"subject"; 115, identifier:identifier; 116, pair; 116, 117; 116, 118; 117, string:"visible_to"; 118, identifier:prefixed_acl; 119, pair; 119, 120; 119, 121; 120, string:"content"; 121, identifier:data; 122, elif_clause; 122, 123; 122, 128; 123, call; 123, 124; 123, 125; 124, identifier:isinstance; 125, argument_list; 125, 126; 125, 127; 126, identifier:data; 127, identifier:list; 128, block; 128, 129; 129, return_statement; 129, 130; 130, dictionary; 130, 131; 130, 134; 130, 137; 130, 140; 131, pair; 131, 132; 131, 133; 132, string:"@datatype"; 133, string:"GIngest"; 134, pair; 134, 135; 134, 136; 135, string:"@version"; 136, string:"2016-11-09"; 137, pair; 137, 138; 137, 139; 138, string:"ingest_type"; 139, string:"GMetaList"; 140, pair; 140, 141; 140, 142; 141, string:"ingest_data"; 142, dictionary; 142, 143; 142, 146; 142, 149; 143, pair; 143, 144; 143, 145; 144, string:"@datatype"; 145, string:"GMetaList"; 146, pair; 146, 147; 146, 148; 147, string:"@version"; 148, string:"2016-11-09"; 149, pair; 149, 150; 149, 151; 150, string:"gmeta"; 151, identifier:data; 152, else_clause; 152, 153; 153, block; 153, 154; 154, raise_statement; 154, 155; 155, call; 155, 156; 155, 157; 156, identifier:TypeError; 157, argument_list; 157, 158; 158, binary_operator:+; 158, 159; 158, 168; 159, binary_operator:+; 159, 160; 159, 161; 160, string:"Cannot format '"; 161, call; 161, 162; 161, 163; 162, identifier:str; 163, argument_list; 163, 164; 164, call; 164, 165; 164, 166; 165, identifier:type; 166, argument_list; 166, 167; 167, identifier:data; 168, string:"' into GMeta." | def format_gmeta(data, acl=None, identifier=None):
if isinstance(data, dict):
if acl is None or identifier is None:
raise ValueError("acl and identifier are required when formatting a GMetaEntry.")
if isinstance(acl, str):
acl = [acl]
prefixed_acl = []
for uuid in acl:
if uuid != "public" and not uuid.lower().startswith("urn:"):
prefixed_acl.append("urn:globus:auth:identity:"+uuid.lower())
prefixed_acl.append("urn:globus:groups:id:"+uuid.lower())
else:
prefixed_acl.append(uuid)
return {
"@datatype": "GMetaEntry",
"@version": "2016-11-09",
"subject": identifier,
"visible_to": prefixed_acl,
"content": data
}
elif isinstance(data, list):
return {
"@datatype": "GIngest",
"@version": "2016-11-09",
"ingest_type": "GMetaList",
"ingest_data": {
"@datatype": "GMetaList",
"@version": "2016-11-09",
"gmeta": data
}
}
else:
raise TypeError("Cannot format '" + str(type(data)) + "' into GMeta.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:insensitive_comparison; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:item1; 5, identifier:item2; 6, default_parameter; 6, 7; 6, 8; 7, identifier:type_insensitive; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:string_insensitive; 11, False; 12, block; 12, 13; 12, 29; 13, if_statement; 13, 14; 13, 26; 14, boolean_operator:and; 14, 15; 14, 17; 15, not_operator; 15, 16; 16, identifier:type_insensitive; 17, comparison_operator:!=; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:type; 20, argument_list; 20, 21; 21, identifier:item1; 22, call; 22, 23; 22, 24; 23, identifier:type; 24, argument_list; 24, 25; 25, identifier:item2; 26, block; 26, 27; 27, return_statement; 27, 28; 28, False; 29, if_statement; 29, 30; 29, 35; 29, 119; 29, 232; 29, 393; 30, call; 30, 31; 30, 32; 31, identifier:isinstance; 32, argument_list; 32, 33; 32, 34; 33, identifier:item1; 34, identifier:Mapping; 35, block; 35, 36; 35, 46; 35, 60; 35, 87; 35, 117; 36, if_statement; 36, 37; 36, 43; 37, not_operator; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:isinstance; 40, argument_list; 40, 41; 40, 42; 41, identifier:item2; 42, identifier:Mapping; 43, block; 43, 44; 44, return_statement; 44, 45; 45, False; 46, if_statement; 46, 47; 46, 57; 47, not_operator; 47, 48; 48, comparison_operator:==; 48, 49; 48, 53; 49, call; 49, 50; 49, 51; 50, identifier:len; 51, argument_list; 51, 52; 52, identifier:item1; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:item2; 57, block; 57, 58; 58, return_statement; 58, 59; 59, False; 60, if_statement; 60, 61; 60, 84; 61, not_operator; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:insensitive_comparison; 64, argument_list; 64, 65; 64, 73; 64, 81; 65, call; 65, 66; 65, 67; 66, identifier:list; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:item1; 71, identifier:keys; 72, argument_list; 73, call; 73, 74; 73, 75; 74, identifier:list; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:item2; 79, identifier:keys; 80, argument_list; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:type_insensitive; 83, True; 84, block; 84, 85; 85, return_statement; 85, 86; 86, False; 87, for_statement; 87, 88; 87, 91; 87, 96; 88, pattern_list; 88, 89; 88, 90; 89, identifier:key; 90, identifier:val; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:item1; 94, identifier:items; 95, argument_list; 96, block; 96, 97; 97, if_statement; 97, 98; 97, 114; 98, not_operator; 98, 99; 99, call; 99, 100; 99, 101; 100, identifier:insensitive_comparison; 101, argument_list; 101, 102; 101, 105; 101, 108; 101, 111; 102, subscript; 102, 103; 102, 104; 103, identifier:item1; 104, identifier:key; 105, subscript; 105, 106; 105, 107; 106, identifier:item2; 107, identifier:key; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:type_insensitive; 110, identifier:type_insensitive; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:string_insensitive; 113, identifier:string_insensitive; 114, block; 114, 115; 115, return_statement; 115, 116; 116, False; 117, return_statement; 117, 118; 118, True; 119, elif_clause; 119, 120; 119, 125; 120, call; 120, 121; 120, 122; 121, identifier:isinstance; 122, argument_list; 122, 123; 122, 124; 123, identifier:item1; 124, identifier:str; 125, block; 125, 126; 125, 136; 125, 153; 126, if_statement; 126, 127; 126, 133; 127, not_operator; 127, 128; 128, call; 128, 129; 128, 130; 129, identifier:isinstance; 130, argument_list; 130, 131; 130, 132; 131, identifier:item2; 132, identifier:str; 133, block; 133, 134; 134, return_statement; 134, 135; 135, False; 136, if_statement; 136, 137; 136, 150; 137, boolean_operator:and; 137, 138; 137, 148; 138, not_operator; 138, 139; 139, comparison_operator:==; 139, 140; 139, 144; 140, call; 140, 141; 140, 142; 141, identifier:len; 142, argument_list; 142, 143; 143, identifier:item1; 144, call; 144, 145; 144, 146; 145, identifier:len; 146, argument_list; 146, 147; 147, identifier:item2; 148, not_operator; 148, 149; 149, identifier:string_insensitive; 150, block; 150, 151; 151, return_statement; 151, 152; 152, False; 153, if_statement; 153, 154; 153, 155; 153, 226; 154, identifier:string_insensitive; 155, block; 155, 156; 155, 176; 155, 195; 155, 214; 156, if_statement; 156, 157; 156, 163; 157, comparison_operator:<=; 157, 158; 157, 162; 158, call; 158, 159; 158, 160; 159, identifier:len; 160, argument_list; 160, 161; 161, identifier:item1; 162, integer:1; 163, block; 163, 164; 164, return_statement; 164, 165; 165, comparison_operator:==; 165, 166; 165, 171; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:item1; 169, identifier:lower; 170, argument_list; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:item2; 174, identifier:lower; 175, argument_list; 176, expression_statement; 176, 177; 177, assignment; 177, 178; 177, 179; 178, identifier:item1_list; 179, list_comprehension; 179, 180; 179, 181; 179, 188; 180, identifier:c; 181, for_in_clause; 181, 182; 181, 183; 182, identifier:c; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:item1; 186, identifier:lower; 187, argument_list; 188, if_clause; 188, 189; 189, not_operator; 189, 190; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:c; 193, identifier:isspace; 194, argument_list; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:item2_list; 198, list_comprehension; 198, 199; 198, 200; 198, 207; 199, identifier:c; 200, for_in_clause; 200, 201; 200, 202; 201, identifier:c; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:item2; 205, identifier:lower; 206, argument_list; 207, if_clause; 207, 208; 208, not_operator; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:c; 212, identifier:isspace; 213, argument_list; 214, return_statement; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:insensitive_comparison; 217, argument_list; 217, 218; 217, 219; 217, 220; 217, 223; 218, identifier:item1_list; 219, identifier:item2_list; 220, keyword_argument; 220, 221; 220, 222; 221, identifier:type_insensitive; 222, identifier:type_insensitive; 223, keyword_argument; 223, 224; 223, 225; 224, identifier:string_insensitive; 225, identifier:string_insensitive; 226, else_clause; 226, 227; 227, block; 227, 228; 228, return_statement; 228, 229; 229, comparison_operator:==; 229, 230; 229, 231; 230, identifier:item1; 231, identifier:item2; 232, elif_clause; 232, 233; 232, 244; 233, boolean_operator:and; 233, 234; 233, 239; 234, call; 234, 235; 234, 236; 235, identifier:isinstance; 236, argument_list; 236, 237; 236, 238; 237, identifier:item1; 238, identifier:Container; 239, call; 239, 240; 239, 241; 240, identifier:isinstance; 241, argument_list; 241, 242; 241, 243; 242, identifier:item1; 243, identifier:Iterable; 244, block; 244, 245; 244, 262; 244, 276; 244, 286; 244, 290; 244, 342; 245, if_statement; 245, 246; 245, 259; 246, boolean_operator:or; 246, 247; 246, 253; 247, not_operator; 247, 248; 248, call; 248, 249; 248, 250; 249, identifier:isinstance; 250, argument_list; 250, 251; 250, 252; 251, identifier:item2; 252, identifier:Container; 253, not_operator; 253, 254; 254, call; 254, 255; 254, 256; 255, identifier:isinstance; 256, argument_list; 256, 257; 256, 258; 257, identifier:item2; 258, identifier:Iterable; 259, block; 259, 260; 260, return_statement; 260, 261; 261, False; 262, if_statement; 262, 263; 262, 273; 263, not_operator; 263, 264; 264, comparison_operator:==; 264, 265; 264, 269; 265, call; 265, 266; 265, 267; 266, identifier:len; 267, argument_list; 267, 268; 268, identifier:item1; 269, call; 269, 270; 269, 271; 270, identifier:len; 271, argument_list; 271, 272; 272, identifier:item2; 273, block; 273, 274; 274, return_statement; 274, 275; 275, False; 276, expression_statement; 276, 277; 277, assignment; 277, 278; 277, 279; 278, identifier:item2_copy; 279, call; 279, 280; 279, 281; 280, identifier:list; 281, argument_list; 281, 282; 282, call; 282, 283; 282, 284; 283, identifier:deepcopy; 284, argument_list; 284, 285; 285, identifier:item2; 286, expression_statement; 286, 287; 287, assignment; 287, 288; 287, 289; 288, identifier:remove_failed; 289, False; 290, for_statement; 290, 291; 290, 292; 290, 293; 291, identifier:elem; 292, identifier:item1; 293, block; 293, 294; 293, 298; 293, 336; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:matched; 297, False; 298, for_statement; 298, 299; 298, 300; 298, 301; 299, identifier:candidate; 300, identifier:item2; 301, block; 301, 302; 302, if_statement; 302, 303; 302, 314; 303, call; 303, 304; 303, 305; 304, identifier:insensitive_comparison; 305, argument_list; 305, 306; 305, 307; 305, 308; 305, 311; 306, identifier:elem; 307, identifier:candidate; 308, keyword_argument; 308, 309; 308, 310; 309, identifier:type_insensitive; 310, identifier:type_insensitive; 311, keyword_argument; 311, 312; 311, 313; 312, identifier:string_insensitive; 313, identifier:string_insensitive; 314, block; 314, 315; 314, 319; 314, 335; 315, expression_statement; 315, 316; 316, assignment; 316, 317; 316, 318; 317, identifier:matched; 318, True; 319, try_statement; 319, 320; 319, 328; 320, block; 320, 321; 321, expression_statement; 321, 322; 322, call; 322, 323; 322, 326; 323, attribute; 323, 324; 323, 325; 324, identifier:item2_copy; 325, identifier:remove; 326, argument_list; 326, 327; 327, identifier:candidate; 328, except_clause; 328, 329; 328, 330; 329, identifier:ValueError; 330, block; 330, 331; 331, expression_statement; 331, 332; 332, assignment; 332, 333; 332, 334; 333, identifier:remove_failed; 334, True; 335, break_statement; 336, if_statement; 336, 337; 336, 339; 337, not_operator; 337, 338; 338, identifier:matched; 339, block; 339, 340; 340, return_statement; 340, 341; 341, False; 342, if_statement; 342, 343; 342, 345; 342, 353; 343, not_operator; 343, 344; 344, identifier:remove_failed; 345, block; 345, 346; 346, return_statement; 346, 347; 347, comparison_operator:==; 347, 348; 347, 352; 348, call; 348, 349; 348, 350; 349, identifier:len; 350, argument_list; 350, 351; 351, identifier:item2_copy; 352, integer:0; 353, else_clause; 353, 354; 354, block; 354, 355; 354, 391; 355, for_statement; 355, 356; 355, 357; 355, 358; 356, identifier:elem; 357, identifier:item2; 358, block; 358, 359; 358, 363; 358, 385; 359, expression_statement; 359, 360; 360, assignment; 360, 361; 360, 362; 361, identifier:matched; 362, False; 363, for_statement; 363, 364; 363, 365; 363, 366; 364, identifier:candidate; 365, identifier:item1; 366, block; 366, 367; 367, if_statement; 367, 368; 367, 379; 368, call; 368, 369; 368, 370; 369, identifier:insensitive_comparison; 370, argument_list; 370, 371; 370, 372; 370, 373; 370, 376; 371, identifier:elem; 372, identifier:candidate; 373, keyword_argument; 373, 374; 373, 375; 374, identifier:type_insensitive; 375, identifier:type_insensitive; 376, keyword_argument; 376, 377; 376, 378; 377, identifier:string_insensitive; 378, identifier:string_insensitive; 379, block; 379, 380; 379, 384; 380, expression_statement; 380, 381; 381, assignment; 381, 382; 381, 383; 382, identifier:matched; 383, True; 384, break_statement; 385, if_statement; 385, 386; 385, 388; 386, not_operator; 386, 387; 387, identifier:matched; 388, block; 388, 389; 389, return_statement; 389, 390; 390, False; 391, return_statement; 391, 392; 392, True; 393, else_clause; 393, 394; 394, block; 394, 395; 395, return_statement; 395, 396; 396, comparison_operator:==; 396, 397; 396, 398; 397, identifier:item1; 398, identifier:item2 | def insensitive_comparison(item1, item2, type_insensitive=False, string_insensitive=False):
if not type_insensitive and type(item1) != type(item2):
return False
if isinstance(item1, Mapping):
if not isinstance(item2, Mapping):
return False
if not len(item1) == len(item2):
return False
if not insensitive_comparison(list(item1.keys()), list(item2.keys()),
type_insensitive=True):
return False
for key, val in item1.items():
if not insensitive_comparison(item1[key], item2[key],
type_insensitive=type_insensitive,
string_insensitive=string_insensitive):
return False
return True
elif isinstance(item1, str):
if not isinstance(item2, str):
return False
if not len(item1) == len(item2) and not string_insensitive:
return False
if string_insensitive:
if len(item1) <= 1:
return item1.lower() == item2.lower()
item1_list = [c for c in item1.lower() if not c.isspace()]
item2_list = [c for c in item2.lower() if not c.isspace()]
return insensitive_comparison(item1_list, item2_list,
type_insensitive=type_insensitive,
string_insensitive=string_insensitive)
else:
return item1 == item2
elif isinstance(item1, Container) and isinstance(item1, Iterable):
if not isinstance(item2, Container) or not isinstance(item2, Iterable):
return False
if not len(item1) == len(item2):
return False
item2_copy = list(deepcopy(item2))
remove_failed = False
for elem in item1:
matched = False
for candidate in item2:
if insensitive_comparison(elem, candidate,
type_insensitive=type_insensitive,
string_insensitive=string_insensitive):
matched = True
try:
item2_copy.remove(candidate)
except ValueError:
remove_failed = True
break
if not matched:
return False
if not remove_failed:
return len(item2_copy) == 0
else:
for elem in item2:
matched = False
for candidate in item1:
if insensitive_comparison(elem, candidate,
type_insensitive=type_insensitive,
string_insensitive=string_insensitive):
matched = True
break
if not matched:
return False
return True
else:
return item1 == item2 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:template_to_filepath; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:template; 5, identifier:metadata; 6, default_parameter; 6, 7; 6, 8; 7, identifier:template_patterns; 8, None; 9, block; 9, 10; 9, 17; 9, 26; 9, 33; 9, 289; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:path; 13, call; 13, 14; 13, 15; 14, identifier:Path; 15, argument_list; 15, 16; 16, identifier:template; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:template_patterns; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:template_patterns; 25, identifier:TEMPLATE_PATTERNS; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:suggested_filename; 29, call; 29, 30; 29, 31; 30, identifier:suggest_filename; 31, argument_list; 31, 32; 32, identifier:metadata; 33, if_statement; 33, 34; 33, 49; 33, 57; 33, 249; 33, 267; 33, 283; 34, parenthesized_expression; 34, 35; 35, boolean_operator:or; 35, 36; 35, 43; 36, comparison_operator:==; 36, 37; 36, 38; 37, identifier:path; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:Path; 41, identifier:cwd; 42, argument_list; 43, comparison_operator:==; 43, 44; 43, 45; 44, identifier:path; 45, call; 45, 46; 45, 47; 46, identifier:Path; 47, argument_list; 47, 48; 48, string:'%suggested%'; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:filepath; 53, call; 53, 54; 53, 55; 54, identifier:Path; 55, argument_list; 55, 56; 56, identifier:suggested_filename; 57, elif_clause; 57, 58; 57, 69; 58, call; 58, 59; 58, 60; 59, identifier:any; 60, generator_expression; 60, 61; 60, 66; 61, comparison_operator:in; 61, 62; 61, 63; 62, identifier:template_pattern; 63, attribute; 63, 64; 63, 65; 64, identifier:path; 65, identifier:parts; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:template_pattern; 68, identifier:template_patterns; 69, block; 69, 70; 69, 84; 69, 97; 69, 101; 69, 241; 70, if_statement; 70, 71; 70, 79; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:template; 74, identifier:endswith; 75, argument_list; 75, 76; 76, tuple; 76, 77; 76, 78; 77, string:'/'; 78, string:'\\'; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, augmented_assignment:+=; 81, 82; 81, 83; 82, identifier:template; 83, identifier:suggested_filename; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:path; 87, call; 87, 88; 87, 89; 88, identifier:Path; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:template; 93, identifier:replace; 94, argument_list; 94, 95; 94, 96; 95, string:'%suggested%'; 96, identifier:suggested_filename; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:parts; 100, list:[]; 101, for_statement; 101, 102; 101, 103; 101, 106; 102, identifier:part; 103, attribute; 103, 104; 103, 105; 104, identifier:path; 105, identifier:parts; 106, block; 106, 107; 107, if_statement; 107, 108; 107, 113; 107, 121; 108, comparison_operator:==; 108, 109; 108, 110; 109, identifier:part; 110, attribute; 110, 111; 110, 112; 111, identifier:path; 112, identifier:anchor; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:parts; 118, identifier:append; 119, argument_list; 119, 120; 120, identifier:part; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 231; 123, for_statement; 123, 124; 123, 125; 123, 126; 124, identifier:key; 125, identifier:template_patterns; 126, block; 126, 127; 127, if_statement; 127, 128; 127, 144; 128, parenthesized_expression; 128, 129; 129, boolean_operator:and; 129, 130; 129, 133; 130, comparison_operator:in; 130, 131; 130, 132; 131, identifier:key; 132, identifier:part; 133, call; 133, 134; 133, 135; 134, identifier:any; 135, generator_expression; 135, 136; 135, 139; 136, comparison_operator:in; 136, 137; 136, 138; 137, identifier:field; 138, identifier:metadata; 139, for_in_clause; 139, 140; 139, 141; 140, identifier:field; 141, subscript; 141, 142; 141, 143; 142, identifier:template_patterns; 143, identifier:key; 144, block; 144, 145; 144, 164; 144, 216; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 148; 147, identifier:field; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:more_itertools; 151, identifier:first_true; 152, argument_list; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:template_patterns; 155, identifier:key; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:pred; 158, lambda; 158, 159; 158, 161; 159, lambda_parameters; 159, 160; 160, identifier:k; 161, comparison_operator:in; 161, 162; 161, 163; 162, identifier:k; 163, identifier:metadata; 164, if_statement; 164, 165; 164, 173; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:key; 168, identifier:startswith; 169, argument_list; 169, 170; 170, tuple; 170, 171; 170, 172; 171, string:'%disc'; 172, string:'%track'; 173, block; 173, 174; 173, 189; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:number; 177, call; 177, 178; 177, 179; 178, identifier:_split_number_field; 179, argument_list; 179, 180; 180, call; 180, 181; 180, 182; 181, identifier:str; 182, argument_list; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:list_to_single_value; 185, argument_list; 185, 186; 186, subscript; 186, 187; 186, 188; 187, identifier:metadata; 188, identifier:field; 189, if_statement; 189, 190; 189, 196; 189, 208; 190, call; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:key; 193, identifier:endswith; 194, argument_list; 194, 195; 195, string:'2%'; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 202; 199, subscript; 199, 200; 199, 201; 200, identifier:metadata; 201, identifier:field; 202, call; 202, 203; 202, 206; 203, attribute; 203, 204; 203, 205; 204, identifier:number; 205, identifier:zfill; 206, argument_list; 206, 207; 207, integer:2; 208, else_clause; 208, 209; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, assignment; 211, 212; 211, 215; 212, subscript; 212, 213; 212, 214; 213, identifier:metadata; 214, identifier:field; 215, identifier:number; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:part; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:part; 222, identifier:replace; 223, argument_list; 223, 224; 223, 225; 224, identifier:key; 225, call; 225, 226; 225, 227; 226, identifier:list_to_single_value; 227, argument_list; 227, 228; 228, subscript; 228, 229; 228, 230; 229, identifier:metadata; 230, identifier:field; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:parts; 235, identifier:append; 236, argument_list; 236, 237; 237, call; 237, 238; 237, 239; 238, identifier:_replace_invalid_characters; 239, argument_list; 239, 240; 240, identifier:part; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:filepath; 244, call; 244, 245; 244, 246; 245, identifier:Path; 246, argument_list; 246, 247; 247, list_splat; 247, 248; 248, identifier:parts; 249, elif_clause; 249, 250; 249, 253; 250, comparison_operator:in; 250, 251; 250, 252; 251, string:'%suggested%'; 252, identifier:template; 253, block; 253, 254; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:filepath; 257, call; 257, 258; 257, 259; 258, identifier:Path; 259, argument_list; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:template; 263, identifier:replace; 264, argument_list; 264, 265; 264, 266; 265, string:'%suggested%'; 266, identifier:suggested_filename; 267, elif_clause; 267, 268; 267, 276; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:template; 271, identifier:endswith; 272, argument_list; 272, 273; 273, tuple; 273, 274; 273, 275; 274, string:'/'; 275, string:'\\'; 276, block; 276, 277; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:filepath; 280, binary_operator:/; 280, 281; 280, 282; 281, identifier:path; 282, identifier:suggested_filename; 283, else_clause; 283, 284; 284, block; 284, 285; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:filepath; 288, identifier:path; 289, return_statement; 289, 290; 290, identifier:filepath | def template_to_filepath(template, metadata, template_patterns=None):
path = Path(template)
if template_patterns is None:
template_patterns = TEMPLATE_PATTERNS
suggested_filename = suggest_filename(metadata)
if (
path == Path.cwd()
or path == Path('%suggested%')
):
filepath = Path(suggested_filename)
elif any(template_pattern in path.parts for template_pattern in template_patterns):
if template.endswith(('/', '\\')):
template += suggested_filename
path = Path(template.replace('%suggested%', suggested_filename))
parts = []
for part in path.parts:
if part == path.anchor:
parts.append(part)
else:
for key in template_patterns:
if (
key in part
and any(field in metadata for field in template_patterns[key])
):
field = more_itertools.first_true(
template_patterns[key],
pred=lambda k: k in metadata
)
if key.startswith(('%disc', '%track')):
number = _split_number_field(
str(
list_to_single_value(
metadata[field]
)
)
)
if key.endswith('2%'):
metadata[field] = number.zfill(2)
else:
metadata[field] = number
part = part.replace(
key,
list_to_single_value(
metadata[field]
)
)
parts.append(_replace_invalid_characters(part))
filepath = Path(*parts)
elif '%suggested%' in template:
filepath = Path(template.replace('%suggested%', suggested_filename))
elif template.endswith(('/', '\\')):
filepath = path / suggested_filename
else:
filepath = path
return filepath |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_get_station_codes; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:force; 7, False; 8, block; 8, 9; 8, 23; 8, 31; 8, 35; 8, 96; 8, 102; 8, 150; 8, 246; 9, if_statement; 9, 10; 9, 18; 10, boolean_operator:and; 10, 11; 10, 13; 11, not_operator; 11, 12; 12, identifier:force; 13, comparison_operator:is; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:station_codes; 17, None; 18, block; 18, 19; 19, return_statement; 19, 20; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:station_codes; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:state_urls; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_get_state_urls; 30, argument_list; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:state_matches; 34, None; 35, if_statement; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:bbox; 39, block; 39, 40; 40, with_statement; 40, 41; 40, 59; 41, with_clause; 41, 42; 42, with_item; 42, 43; 43, as_pattern; 43, 44; 43, 57; 44, call; 44, 45; 44, 46; 45, identifier:collection; 46, argument_list; 46, 47; 46, 56; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:os; 51, identifier:path; 52, identifier:join; 53, argument_list; 53, 54; 53, 55; 54, string:"resources"; 55, string:"ne_50m_admin_1_states_provinces_lakes_shp.shp"; 56, string:"r"; 57, as_pattern_target; 57, 58; 58, identifier:c; 59, block; 59, 60; 59, 79; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:geom_matches; 63, list_comprehension; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:x; 66, string:"properties"; 67, for_in_clause; 67, 68; 67, 69; 68, identifier:x; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:c; 72, identifier:filter; 73, argument_list; 73, 74; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:bbox; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:bbox; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:state_matches; 82, list_comprehension; 82, 83; 82, 93; 83, conditional_expression:if; 83, 84; 83, 87; 83, 92; 84, subscript; 84, 85; 84, 86; 85, identifier:x; 86, string:"postal"; 87, comparison_operator:!=; 87, 88; 87, 91; 88, subscript; 88, 89; 88, 90; 89, identifier:x; 90, string:"admin"; 91, string:"Canada"; 92, string:"CN"; 93, for_in_clause; 93, 94; 93, 95; 94, identifier:x; 95, identifier:geom_matches; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:station_codes; 101, list:[]; 102, for_statement; 102, 103; 102, 104; 102, 105; 103, identifier:state_url; 104, identifier:state_urls; 105, block; 105, 106; 105, 136; 106, if_statement; 106, 107; 106, 110; 107, comparison_operator:is; 107, 108; 107, 109; 108, identifier:state_matches; 109, None; 110, block; 110, 111; 110, 130; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:state_abbr; 114, subscript; 114, 115; 114, 129; 115, call; 115, 116; 115, 127; 116, attribute; 116, 117; 116, 126; 117, subscript; 117, 118; 117, 124; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:state_url; 121, identifier:split; 122, argument_list; 122, 123; 123, string:"/"; 124, unary_operator:-; 124, 125; 125, integer:1; 126, identifier:split; 127, argument_list; 127, 128; 128, string:"."; 129, integer:0; 130, if_statement; 130, 131; 130, 134; 131, comparison_operator:not; 131, 132; 131, 133; 132, identifier:state_abbr; 133, identifier:state_matches; 134, block; 134, 135; 135, continue_statement; 136, expression_statement; 136, 137; 137, call; 137, 138; 137, 143; 138, attribute; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:self; 141, identifier:station_codes; 142, identifier:extend; 143, argument_list; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:_get_stations_for_state; 148, argument_list; 148, 149; 149, identifier:state_url; 150, if_statement; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:bbox; 154, block; 154, 155; 154, 166; 154, 177; 154, 231; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:metadata; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:_get_metadata; 162, argument_list; 162, 163; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:station_codes; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:parsed_metadata; 169, call; 169, 170; 169, 175; 170, attribute; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:parser; 174, identifier:_parse_metadata; 175, argument_list; 175, 176; 176, identifier:metadata; 177, function_definition; 177, 178; 177, 179; 177, 181; 178, function_name:in_bbox; 179, parameters; 179, 180; 180, identifier:code; 181, block; 181, 182; 181, 190; 181, 198; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:lat; 185, subscript; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:parsed_metadata; 188, identifier:code; 189, string:"latitude"; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:lon; 193, subscript; 193, 194; 193, 197; 194, subscript; 194, 195; 194, 196; 195, identifier:parsed_metadata; 196, identifier:code; 197, string:"longitude"; 198, return_statement; 198, 199; 199, parenthesized_expression; 199, 200; 200, boolean_operator:and; 200, 201; 200, 224; 201, boolean_operator:and; 201, 202; 201, 217; 202, boolean_operator:and; 202, 203; 202, 210; 203, comparison_operator:>=; 203, 204; 203, 205; 204, identifier:lon; 205, subscript; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:bbox; 209, integer:0; 210, comparison_operator:<=; 210, 211; 210, 212; 211, identifier:lon; 212, subscript; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:self; 215, identifier:bbox; 216, integer:2; 217, comparison_operator:>=; 217, 218; 217, 219; 218, identifier:lat; 219, subscript; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:bbox; 223, integer:1; 224, comparison_operator:<=; 224, 225; 224, 226; 225, identifier:lat; 226, subscript; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:self; 229, identifier:bbox; 230, integer:3; 231, expression_statement; 231, 232; 232, assignment; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:self; 235, identifier:station_codes; 236, call; 236, 237; 236, 238; 237, identifier:list; 238, argument_list; 238, 239; 239, call; 239, 240; 239, 241; 240, identifier:filter; 241, argument_list; 241, 242; 241, 243; 242, identifier:in_bbox; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:station_codes; 246, return_statement; 246, 247; 247, attribute; 247, 248; 247, 249; 248, identifier:self; 249, identifier:station_codes | def _get_station_codes(self, force=False):
if not force and self.station_codes is not None:
return self.station_codes
state_urls = self._get_state_urls()
state_matches = None
if self.bbox:
with collection(
os.path.join(
"resources",
"ne_50m_admin_1_states_provinces_lakes_shp.shp",
),
"r",
) as c:
geom_matches = [
x["properties"] for x in c.filter(bbox=self.bbox)
]
state_matches = [
x["postal"] if x["admin"] != "Canada" else "CN"
for x in geom_matches
]
self.station_codes = []
for state_url in state_urls:
if state_matches is not None:
state_abbr = state_url.split("/")[-1].split(".")[0]
if state_abbr not in state_matches:
continue
self.station_codes.extend(self._get_stations_for_state(state_url))
if self.bbox:
metadata = self._get_metadata(self.station_codes)
parsed_metadata = self.parser._parse_metadata(metadata)
def in_bbox(code):
lat = parsed_metadata[code]["latitude"]
lon = parsed_metadata[code]["longitude"]
return (
lon >= self.bbox[0]
and lon <= self.bbox[2]
and lat >= self.bbox[1]
and lat <= self.bbox[3]
)
self.station_codes = list(filter(in_bbox, self.station_codes))
return self.station_codes |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_validate_query; 3, parameters; 3, 4; 4, identifier:query; 5, block; 5, 6; 5, 13; 5, 27; 5, 38; 5, 85; 5, 116; 5, 136; 5, 147; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:query; 9, call; 9, 10; 9, 11; 10, identifier:deepcopy; 11, argument_list; 11, 12; 12, identifier:query; 13, if_statement; 13, 14; 13, 21; 14, comparison_operator:==; 14, 15; 14, 18; 15, subscript; 15, 16; 15, 17; 16, identifier:query; 17, string:"q"; 18, subscript; 18, 19; 18, 20; 19, identifier:BLANK_QUERY; 20, string:"q"; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, string:"No query specified."; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:query; 31, string:"q"; 32, call; 32, 33; 32, 34; 33, identifier:_clean_query_string; 34, argument_list; 34, 35; 35, subscript; 35, 36; 35, 37; 36, identifier:query; 37, string:"q"; 38, if_statement; 38, 39; 38, 44; 38, 56; 39, comparison_operator:is; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:query; 42, string:"limit"; 43, None; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:query; 49, string:"limit"; 50, conditional_expression:if; 50, 51; 50, 52; 50, 55; 51, identifier:SEARCH_LIMIT; 52, subscript; 52, 53; 52, 54; 53, identifier:query; 54, string:"advanced"; 55, identifier:NONADVANCED_LIMIT; 56, elif_clause; 56, 57; 56, 62; 57, comparison_operator:>; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:query; 60, string:"limit"; 61, identifier:SEARCH_LIMIT; 62, block; 62, 63; 62, 79; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:warnings; 67, identifier:warn; 68, argument_list; 68, 69; 68, 78; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, string:'Reduced result limit from {} to the Search maximum: {}'; 72, identifier:format; 73, argument_list; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:query; 76, string:"limit"; 77, identifier:SEARCH_LIMIT; 78, identifier:RuntimeWarning; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:query; 83, string:"limit"; 84, identifier:SEARCH_LIMIT; 85, for_statement; 85, 86; 85, 89; 85, 94; 86, pattern_list; 86, 87; 86, 88; 87, identifier:key; 88, identifier:val; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:BLANK_QUERY; 92, identifier:items; 93, argument_list; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 108; 96, comparison_operator:==; 96, 97; 96, 107; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:query; 100, identifier:get; 101, argument_list; 101, 102; 101, 103; 102, identifier:key; 103, call; 103, 104; 103, 105; 104, identifier:float; 105, argument_list; 105, 106; 106, string:'nan'; 107, identifier:val; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:query; 113, identifier:pop; 114, argument_list; 114, 115; 115, identifier:key; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:to_remove; 119, list_comprehension; 119, 120; 119, 121; 119, 128; 120, identifier:field; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:field; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:query; 126, identifier:keys; 127, argument_list; 128, if_clause; 128, 129; 129, comparison_operator:not; 129, 130; 129, 131; 130, identifier:field; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:BLANK_QUERY; 134, identifier:keys; 135, argument_list; 136, expression_statement; 136, 137; 137, list_comprehension; 137, 138; 137, 144; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:query; 141, identifier:pop; 142, argument_list; 142, 143; 143, identifier:field; 144, for_in_clause; 144, 145; 144, 146; 145, identifier:field; 146, identifier:to_remove; 147, return_statement; 147, 148; 148, identifier:query | def _validate_query(query):
query = deepcopy(query)
if query["q"] == BLANK_QUERY["q"]:
raise ValueError("No query specified.")
query["q"] = _clean_query_string(query["q"])
if query["limit"] is None:
query["limit"] = SEARCH_LIMIT if query["advanced"] else NONADVANCED_LIMIT
elif query["limit"] > SEARCH_LIMIT:
warnings.warn('Reduced result limit from {} to the Search maximum: {}'
.format(query["limit"], SEARCH_LIMIT), RuntimeWarning)
query["limit"] = SEARCH_LIMIT
for key, val in BLANK_QUERY.items():
if query.get(key, float('nan')) == val:
query.pop(key)
to_remove = [field for field in query.keys() if field not in BLANK_QUERY.keys()]
[query.pop(field) for field in to_remove]
return query |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:show_fields; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:block; 7, None; 8, block; 8, 9; 8, 17; 8, 101; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:mapping; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_mapping; 16, argument_list; 17, if_statement; 17, 18; 17, 21; 17, 24; 17, 71; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:block; 20, None; 21, block; 21, 22; 22, return_statement; 22, 23; 23, identifier:mapping; 24, elif_clause; 24, 25; 24, 28; 25, comparison_operator:==; 25, 26; 25, 27; 26, identifier:block; 27, string:"top"; 28, block; 28, 29; 28, 35; 28, 57; 28, 61; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:blocks; 32, call; 32, 33; 32, 34; 33, identifier:set; 34, argument_list; 35, for_statement; 35, 36; 35, 37; 35, 42; 36, identifier:key; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:mapping; 40, identifier:keys; 41, argument_list; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:blocks; 47, identifier:add; 48, argument_list; 48, 49; 49, subscript; 49, 50; 49, 56; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:key; 53, identifier:split; 54, argument_list; 54, 55; 55, string:"."; 56, integer:0; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:block_map; 60, dictionary; 61, for_statement; 61, 62; 61, 63; 61, 64; 62, identifier:b; 63, identifier:blocks; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:block_map; 69, identifier:b; 70, string:"object"; 71, else_clause; 71, 72; 72, block; 72, 73; 72, 77; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:block_map; 76, dictionary; 77, for_statement; 77, 78; 77, 81; 77, 86; 78, pattern_list; 78, 79; 78, 80; 79, identifier:key; 80, identifier:value; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:mapping; 84, identifier:items; 85, argument_list; 86, block; 86, 87; 87, if_statement; 87, 88; 87, 94; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:key; 91, identifier:startswith; 92, argument_list; 92, 93; 93, identifier:block; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:block_map; 99, identifier:key; 100, identifier:value; 101, return_statement; 101, 102; 102, identifier:block_map | def show_fields(self, block=None):
mapping = self._mapping()
if block is None:
return mapping
elif block == "top":
blocks = set()
for key in mapping.keys():
blocks.add(key.split(".")[0])
block_map = {}
for b in blocks:
block_map[b] = "object"
else:
block_map = {}
for key, value in mapping.items():
if key.startswith(block):
block_map[key] = value
return block_map |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sorted; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:by; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 22; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sort_idc; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:np; 15, identifier:argsort; 16, argument_list; 16, 17; 16, 20; 17, subscript; 17, 18; 17, 19; 18, identifier:self; 19, identifier:by; 20, dictionary_splat; 20, 21; 21, identifier:kwargs; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:__class__; 27, argument_list; 27, 28; 27, 31; 27, 36; 27, 41; 28, subscript; 28, 29; 28, 30; 29, identifier:self; 30, identifier:sort_idc; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:h5loc; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:h5loc; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:split_h5; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:split_h5; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:name; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:name | def sorted(self, by, **kwargs):
sort_idc = np.argsort(self[by], **kwargs)
return self.__class__(
self[sort_idc],
h5loc=self.h5loc,
split_h5=self.split_h5,
name=self.name
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:create_multi_output_factor; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:tool; 6, identifier:source; 7, identifier:splitting_node; 8, identifier:sink; 9, block; 9, 10; 9, 33; 9, 54; 9, 75; 9, 84; 9, 90; 9, 100; 9, 113; 9, 331; 9, 338; 10, if_statement; 10, 11; 10, 19; 11, boolean_operator:and; 11, 12; 11, 13; 12, identifier:source; 13, not_operator; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:isinstance; 16, argument_list; 16, 17; 16, 18; 17, identifier:source; 18, identifier:Node; 19, block; 19, 20; 20, raise_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:ValueError; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, string:"Expected Node, got {}"; 27, identifier:format; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:type; 31, argument_list; 31, 32; 32, identifier:source; 33, if_statement; 33, 34; 33, 40; 34, not_operator; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:isinstance; 37, argument_list; 37, 38; 37, 39; 38, identifier:sink; 39, identifier:Node; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:ValueError; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, string:"Expected Node, got {}"; 48, identifier:format; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:type; 52, argument_list; 52, 53; 53, identifier:sink; 54, if_statement; 54, 55; 54, 61; 55, not_operator; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:isinstance; 58, argument_list; 58, 59; 58, 60; 59, identifier:tool; 60, identifier:MultiOutputTool; 61, block; 61, 62; 62, raise_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:ValueError; 65, argument_list; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, string:"Expected MultiOutputTool, got {}"; 69, identifier:format; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:type; 73, argument_list; 73, 74; 74, identifier:tool; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:input_plates; 78, conditional_expression:if; 78, 79; 78, 82; 78, 83; 79, attribute; 79, 80; 79, 81; 80, identifier:source; 81, identifier:plates; 82, identifier:source; 83, list:[]; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:output_plates; 87, attribute; 87, 88; 87, 89; 88, identifier:sink; 89, identifier:plates; 90, if_statement; 90, 91; 90, 97; 91, comparison_operator:>; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:len; 94, argument_list; 94, 95; 95, identifier:input_plates; 96, integer:1; 97, block; 97, 98; 98, raise_statement; 98, 99; 99, identifier:NotImplementedError; 100, if_statement; 100, 101; 100, 107; 101, comparison_operator:==; 101, 102; 101, 106; 102, call; 102, 103; 102, 104; 103, identifier:len; 104, argument_list; 104, 105; 105, identifier:output_plates; 106, integer:0; 107, block; 107, 108; 108, raise_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:ValueError; 111, argument_list; 111, 112; 112, string:"No output plate found"; 113, if_statement; 113, 114; 113, 120; 113, 169; 114, comparison_operator:==; 114, 115; 114, 119; 115, call; 115, 116; 115, 117; 116, identifier:len; 117, argument_list; 117, 118; 118, identifier:output_plates; 119, integer:1; 120, block; 120, 121; 120, 138; 121, if_statement; 121, 122; 121, 132; 122, not_operator; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:check_multi_output_plate_compatibility; 127, argument_list; 127, 128; 127, 129; 128, identifier:input_plates; 129, subscript; 129, 130; 129, 131; 130, identifier:output_plates; 131, integer:0; 132, block; 132, 133; 133, raise_statement; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:IncompatiblePlatesError; 136, argument_list; 136, 137; 137, string:"Parent plate does not match input plate"; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:factor; 141, call; 141, 142; 141, 143; 142, identifier:MultiOutputFactor; 143, argument_list; 143, 144; 143, 147; 143, 150; 143, 153; 143, 156; 143, 164; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:tool; 146, identifier:tool; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:source_node; 149, identifier:source; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:splitting_node; 152, identifier:splitting_node; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:sink_node; 155, identifier:sink; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:input_plate; 158, conditional_expression:if; 158, 159; 158, 162; 158, 163; 159, subscript; 159, 160; 159, 161; 160, identifier:input_plates; 161, integer:0; 162, identifier:input_plates; 163, None; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:output_plates; 166, subscript; 166, 167; 166, 168; 167, identifier:output_plates; 168, integer:0; 169, else_clause; 169, 170; 170, block; 170, 171; 170, 181; 170, 194; 170, 251; 170, 305; 171, if_statement; 171, 172; 171, 178; 172, comparison_operator:>; 172, 173; 172, 177; 173, call; 173, 174; 173, 175; 174, identifier:len; 175, argument_list; 175, 176; 176, identifier:output_plates; 177, integer:2; 178, block; 178, 179; 179, raise_statement; 179, 180; 180, identifier:NotImplementedError; 181, if_statement; 181, 182; 181, 188; 182, comparison_operator:!=; 182, 183; 182, 187; 183, call; 183, 184; 183, 185; 184, identifier:len; 185, argument_list; 185, 186; 186, identifier:input_plates; 187, integer:1; 188, block; 188, 189; 189, raise_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:IncompatiblePlatesError; 192, argument_list; 192, 193; 193, string:"Require an input plate to match all but one of the output plates"; 194, if_statement; 194, 195; 194, 202; 194, 209; 195, comparison_operator:==; 195, 196; 195, 199; 196, subscript; 196, 197; 196, 198; 197, identifier:output_plates; 198, integer:0; 199, subscript; 199, 200; 199, 201; 200, identifier:input_plates; 201, integer:0; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:output_plate; 206, subscript; 206, 207; 206, 208; 207, identifier:output_plates; 208, integer:1; 209, else_clause; 209, 210; 210, block; 210, 211; 210, 229; 210, 235; 211, if_statement; 211, 212; 211, 223; 212, comparison_operator:!=; 212, 213; 212, 218; 213, attribute; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:output_plates; 216, integer:1; 217, identifier:plate_id; 218, attribute; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:input_plates; 221, integer:0; 222, identifier:plate_id; 223, block; 223, 224; 224, raise_statement; 224, 225; 225, call; 225, 226; 225, 227; 226, identifier:IncompatiblePlatesError; 227, argument_list; 227, 228; 228, string:"Require an input plate to match all but one of the output plates"; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:output_plate; 232, subscript; 232, 233; 232, 234; 233, identifier:output_plates; 234, integer:0; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 244; 237, pattern_list; 237, 238; 237, 241; 238, subscript; 238, 239; 238, 240; 239, identifier:output_plates; 240, integer:1; 241, subscript; 241, 242; 241, 243; 242, identifier:output_plates; 243, integer:0; 244, expression_list; 244, 245; 244, 248; 245, subscript; 245, 246; 245, 247; 246, identifier:output_plates; 247, integer:0; 248, subscript; 248, 249; 248, 250; 249, identifier:output_plates; 250, integer:1; 251, if_statement; 251, 252; 251, 256; 252, not_operator; 252, 253; 253, attribute; 253, 254; 253, 255; 254, identifier:output_plate; 255, identifier:is_root; 256, block; 256, 257; 256, 261; 256, 269; 256, 296; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:match; 260, False; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 264; 263, identifier:parent; 264, attribute; 264, 265; 264, 268; 265, subscript; 265, 266; 265, 267; 266, identifier:input_plates; 267, integer:0; 268, identifier:parent; 269, while_statement; 269, 270; 269, 273; 270, comparison_operator:is; 270, 271; 270, 272; 271, identifier:parent; 272, None; 273, block; 273, 274; 273, 290; 274, if_statement; 274, 275; 274, 284; 275, comparison_operator:==; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:parent; 278, identifier:plate_id; 279, attribute; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:output_plate; 282, identifier:parent; 283, identifier:plate_id; 284, block; 284, 285; 284, 289; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:match; 288, True; 289, break_statement; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:parent; 293, attribute; 293, 294; 293, 295; 294, identifier:parent; 295, identifier:parent; 296, if_statement; 296, 297; 296, 299; 297, not_operator; 297, 298; 298, identifier:match; 299, block; 299, 300; 300, raise_statement; 300, 301; 301, call; 301, 302; 301, 303; 302, identifier:IncompatiblePlatesError; 303, argument_list; 303, 304; 304, string:"Require an input plate to match all but one of the output plates"; 305, expression_statement; 305, 306; 306, assignment; 306, 307; 306, 308; 307, identifier:factor; 308, call; 308, 309; 308, 310; 309, identifier:MultiOutputFactor; 310, argument_list; 310, 311; 310, 314; 310, 317; 310, 320; 310, 323; 310, 328; 311, keyword_argument; 311, 312; 311, 313; 312, identifier:tool; 313, identifier:tool; 314, keyword_argument; 314, 315; 314, 316; 315, identifier:source_node; 316, identifier:source; 317, keyword_argument; 317, 318; 317, 319; 318, identifier:sink_node; 319, identifier:sink; 320, keyword_argument; 320, 321; 320, 322; 321, identifier:splitting_node; 322, identifier:splitting_node; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:input_plate; 325, subscript; 325, 326; 325, 327; 326, identifier:input_plates; 327, integer:0; 328, keyword_argument; 328, 329; 328, 330; 329, identifier:output_plates; 330, identifier:output_plates; 331, expression_statement; 331, 332; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:self; 335, identifier:_add_factor; 336, argument_list; 336, 337; 337, identifier:factor; 338, return_statement; 338, 339; 339, identifier:factor | def create_multi_output_factor(self, tool, source, splitting_node, sink):
if source and not isinstance(source, Node):
raise ValueError("Expected Node, got {}".format(type(source)))
if not isinstance(sink, Node):
raise ValueError("Expected Node, got {}".format(type(sink)))
if not isinstance(tool, MultiOutputTool):
raise ValueError("Expected MultiOutputTool, got {}".format(type(tool)))
input_plates = source.plates if source else []
output_plates = sink.plates
if len(input_plates) > 1:
raise NotImplementedError
if len(output_plates) == 0:
raise ValueError("No output plate found")
if len(output_plates) == 1:
if not self.check_multi_output_plate_compatibility(input_plates, output_plates[0]):
raise IncompatiblePlatesError("Parent plate does not match input plate")
factor = MultiOutputFactor(tool=tool, source_node=source, splitting_node=splitting_node, sink_node=sink,
input_plate=input_plates[0] if input_plates else None,
output_plates=output_plates[0])
else:
if len(output_plates) > 2:
raise NotImplementedError
if len(input_plates) != 1:
raise IncompatiblePlatesError("Require an input plate to match all but one of the output plates")
if output_plates[0] == input_plates[0]:
output_plate = output_plates[1]
else:
if output_plates[1].plate_id != input_plates[0].plate_id:
raise IncompatiblePlatesError("Require an input plate to match all but one of the output plates")
output_plate = output_plates[0]
output_plates[1], output_plates[0] = output_plates[0], output_plates[1]
if not output_plate.is_root:
match = False
parent = input_plates[0].parent
while parent is not None:
if parent.plate_id == output_plate.parent.plate_id:
match = True
break
parent = parent.parent
if not match:
raise IncompatiblePlatesError("Require an input plate to match all but one of the output plates")
factor = MultiOutputFactor(
tool=tool, source_node=source, sink_node=sink,
splitting_node=splitting_node, input_plate=input_plates[0], output_plates=output_plates)
self._add_factor(factor)
return factor |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:to_dict; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:tool_long_names; 7, True; 8, block; 8, 9; 8, 27; 8, 82; 8, 218; 8, 229; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:d; 12, call; 12, 13; 12, 14; 13, identifier:dict; 14, argument_list; 14, 15; 14, 18; 14, 21; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:nodes; 17, list:[]; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:factors; 20, list:[]; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:plates; 23, call; 23, 24; 23, 25; 24, identifier:defaultdict; 25, argument_list; 25, 26; 26, identifier:list; 27, for_statement; 27, 28; 27, 29; 27, 32; 28, identifier:node; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:nodes; 32, block; 32, 33; 32, 43; 32, 55; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:node_id; 36, attribute; 36, 37; 36, 42; 37, subscript; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:nodes; 41, identifier:node; 42, identifier:node_id; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 50; 45, attribute; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:d; 48, string:'nodes'; 49, identifier:append; 50, argument_list; 50, 51; 51, dictionary; 51, 52; 52, pair; 52, 53; 52, 54; 53, string:'id'; 54, identifier:node_id; 55, for_statement; 55, 56; 55, 57; 55, 64; 56, identifier:plate_id; 57, attribute; 57, 58; 57, 63; 58, subscript; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:nodes; 62, identifier:node; 63, identifier:plate_ids; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 74; 67, attribute; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:d; 71, string:'plates'; 72, identifier:plate_id; 73, identifier:append; 74, argument_list; 74, 75; 75, dictionary; 75, 76; 75, 79; 76, pair; 76, 77; 76, 78; 77, string:'id'; 78, identifier:node_id; 79, pair; 79, 80; 79, 81; 80, string:'type'; 81, string:'node'; 82, for_statement; 82, 83; 82, 84; 82, 87; 83, identifier:factor; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:factors; 87, block; 87, 88; 87, 104; 87, 141; 87, 163; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:tool; 91, conditional_expression:if; 91, 92; 91, 98; 91, 99; 92, call; 92, 93; 92, 94; 93, identifier:str; 94, argument_list; 94, 95; 95, attribute; 95, 96; 95, 97; 96, identifier:factor; 97, identifier:tool; 98, identifier:tool_long_names; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:factor; 102, identifier:tool; 103, identifier:name; 104, try_statement; 104, 105; 104, 118; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:sources; 109, list_comprehension; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:s; 112, identifier:node_id; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:s; 115, attribute; 115, 116; 115, 117; 116, identifier:factor; 117, identifier:sources; 118, except_clause; 118, 119; 118, 120; 119, identifier:AttributeError; 120, block; 120, 121; 121, if_statement; 121, 122; 121, 125; 121, 135; 122, attribute; 122, 123; 122, 124; 123, identifier:factor; 124, identifier:source; 125, block; 125, 126; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 129; 128, identifier:sources; 129, list:[factor.source.node_id]; 129, 130; 130, attribute; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:factor; 133, identifier:source; 134, identifier:node_id; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:sources; 140, list:[]; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:d; 146, string:'factors'; 147, identifier:append; 148, argument_list; 148, 149; 149, dictionary; 149, 150; 149, 153; 149, 156; 150, pair; 150, 151; 150, 152; 151, string:'id'; 152, identifier:tool; 153, pair; 153, 154; 153, 155; 154, string:'sources'; 155, identifier:sources; 156, pair; 156, 157; 156, 158; 157, string:'sink'; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:factor; 161, identifier:sink; 162, identifier:node_id; 163, try_statement; 163, 164; 163, 214; 164, block; 164, 165; 165, if_statement; 165, 166; 165, 169; 165, 195; 166, attribute; 166, 167; 166, 168; 167, identifier:factor; 168, identifier:plates; 169, block; 169, 170; 170, for_statement; 170, 171; 170, 172; 170, 175; 171, identifier:plate; 172, attribute; 172, 173; 172, 174; 173, identifier:factor; 174, identifier:plates; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 187; 178, attribute; 178, 179; 178, 186; 179, subscript; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:d; 182, string:'plates'; 183, attribute; 183, 184; 183, 185; 184, identifier:plate; 185, identifier:plate_id; 186, identifier:append; 187, argument_list; 187, 188; 188, dictionary; 188, 189; 188, 192; 189, pair; 189, 190; 189, 191; 190, string:'id'; 191, identifier:tool; 192, pair; 192, 193; 192, 194; 193, string:'type'; 194, string:'factor'; 195, else_clause; 195, 196; 196, block; 196, 197; 197, expression_statement; 197, 198; 198, call; 198, 199; 198, 206; 199, attribute; 199, 200; 199, 205; 200, subscript; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:d; 203, string:'plates'; 204, string:'root'; 205, identifier:append; 206, argument_list; 206, 207; 207, dictionary; 207, 208; 207, 211; 208, pair; 208, 209; 208, 210; 209, string:'id'; 210, identifier:tool; 211, pair; 211, 212; 211, 213; 212, string:'type'; 213, string:'factor'; 214, except_clause; 214, 215; 214, 216; 215, identifier:AttributeError; 216, block; 216, 217; 217, pass_statement; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 223; 220, subscript; 220, 221; 220, 222; 221, identifier:d; 222, string:'plates'; 223, call; 223, 224; 223, 225; 224, identifier:dict; 225, argument_list; 225, 226; 226, subscript; 226, 227; 226, 228; 227, identifier:d; 228, string:'plates'; 229, return_statement; 229, 230; 230, identifier:d | def to_dict(self, tool_long_names=True):
d = dict(nodes=[], factors=[], plates=defaultdict(list))
for node in self.nodes:
node_id = self.nodes[node].node_id
d['nodes'].append({'id': node_id})
for plate_id in self.nodes[node].plate_ids:
d['plates'][plate_id].append({'id': node_id, 'type': 'node'})
for factor in self.factors:
tool = str(factor.tool) if tool_long_names else factor.tool.name
try:
sources = [s.node_id for s in factor.sources]
except AttributeError:
if factor.source:
sources = [factor.source.node_id]
else:
sources = []
d['factors'].append({
'id': tool,
'sources': sources,
'sink': factor.sink.node_id})
try:
if factor.plates:
for plate in factor.plates:
d['plates'][plate.plate_id].append({'id': tool, 'type': 'factor'})
else:
d['plates']['root'].append({'id': tool, 'type': 'factor'})
except AttributeError:
pass
d['plates'] = dict(d['plates'])
return d |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:GenericPump; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:filenames; 5, default_parameter; 5, 6; 5, 7; 6, identifier:use_jppy; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:name; 10, string:"GenericPump"; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 13, 26; 13, 48; 13, 67; 13, 87; 13, 96; 13, 118; 13, 140; 13, 158; 13, 207; 13, 219; 14, if_statement; 14, 15; 14, 20; 15, call; 15, 16; 15, 17; 16, identifier:isinstance; 17, argument_list; 17, 18; 17, 19; 18, identifier:filenames; 19, identifier:str; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:filenames; 24, list:[filenames]; 24, 25; 25, identifier:filenames; 26, try_statement; 26, 27; 26, 33; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:iter; 31, argument_list; 31, 32; 32, identifier:filenames; 33, except_clause; 33, 34; 33, 35; 34, identifier:TypeError; 35, block; 35, 36; 35, 43; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:log; 40, identifier:critical; 41, argument_list; 41, 42; 42, string:"Don't know how to iterate through filenames."; 43, raise_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:TypeError; 46, argument_list; 46, 47; 47, string:"Invalid filenames."; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:extensions; 51, call; 51, 52; 51, 53; 52, identifier:set; 53, generator_expression; 53, 54; 53, 64; 54, subscript; 54, 55; 54, 63; 55, call; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:os; 59, identifier:path; 60, identifier:splitext; 61, argument_list; 61, 62; 62, identifier:fn; 63, integer:1; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:fn; 66, identifier:filenames; 67, if_statement; 67, 68; 67, 74; 68, comparison_operator:>; 68, 69; 68, 73; 69, call; 69, 70; 69, 71; 70, identifier:len; 71, argument_list; 71, 72; 72, identifier:extensions; 73, integer:1; 74, block; 74, 75; 74, 82; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:log; 79, identifier:critical; 80, argument_list; 80, 81; 81, string:"Mixed filetypes, please use only files of the same type"; 82, raise_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:IOError; 85, argument_list; 85, 86; 86, string:"Mixed filetypes."; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:extension; 90, subscript; 90, 91; 90, 95; 91, call; 91, 92; 91, 93; 92, identifier:list; 93, argument_list; 93, 94; 94, identifier:extensions; 95, integer:0; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:io; 99, dictionary; 99, 100; 99, 103; 99, 106; 99, 112; 99, 115; 100, pair; 100, 101; 100, 102; 101, string:'.evt'; 102, identifier:EvtPump; 103, pair; 103, 104; 103, 105; 104, string:'.h5'; 105, identifier:HDF5Pump; 106, pair; 106, 107; 106, 108; 107, string:'.root'; 108, conditional_expression:if; 108, 109; 108, 110; 108, 111; 109, identifier:EventPump; 110, identifier:use_jppy; 111, identifier:AanetPump; 112, pair; 112, 113; 112, 114; 113, string:'.dat'; 114, identifier:DAQPump; 115, pair; 115, 116; 115, 117; 116, string:'.dqd'; 117, identifier:CLBPump; 118, if_statement; 118, 119; 118, 122; 119, comparison_operator:not; 119, 120; 119, 121; 120, identifier:extension; 121, identifier:io; 122, block; 122, 123; 122, 135; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:log; 127, identifier:critical; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, string:"No pump found for file extension '{0}'"; 132, identifier:format; 133, argument_list; 133, 134; 134, identifier:extension; 135, raise_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:ValueError; 138, argument_list; 138, 139; 139, string:"Unknown filetype"; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:missing_files; 143, list_comprehension; 143, 144; 143, 145; 143, 148; 144, identifier:fn; 145, for_in_clause; 145, 146; 145, 147; 146, identifier:fn; 147, identifier:filenames; 148, if_clause; 148, 149; 149, not_operator; 149, 150; 150, call; 150, 151; 150, 156; 151, attribute; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:os; 154, identifier:path; 155, identifier:exists; 156, argument_list; 156, 157; 157, identifier:fn; 158, if_statement; 158, 159; 158, 160; 159, identifier:missing_files; 160, block; 160, 161; 161, if_statement; 161, 162; 161, 171; 161, 188; 162, comparison_operator:==; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:len; 165, argument_list; 165, 166; 166, identifier:missing_files; 167, call; 167, 168; 167, 169; 168, identifier:len; 169, argument_list; 169, 170; 170, identifier:filenames; 171, block; 171, 172; 171, 176; 171, 183; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:message; 175, string:"None of the given files could be found."; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:log; 180, identifier:critical; 181, argument_list; 181, 182; 182, identifier:message; 183, raise_statement; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:SystemExit; 186, argument_list; 186, 187; 187, identifier:message; 188, else_clause; 188, 189; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:log; 194, identifier:warning; 195, argument_list; 195, 196; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, string:"The following files are missing and ignored: {}"; 199, identifier:format; 200, argument_list; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, string:', '; 204, identifier:join; 205, argument_list; 205, 206; 206, identifier:missing_files; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:input_files; 210, binary_operator:-; 210, 211; 210, 215; 211, call; 211, 212; 211, 213; 212, identifier:set; 213, argument_list; 213, 214; 214, identifier:filenames; 215, call; 215, 216; 215, 217; 216, identifier:set; 217, argument_list; 217, 218; 218, identifier:missing_files; 219, if_statement; 219, 220; 219, 226; 219, 243; 220, comparison_operator:==; 220, 221; 220, 225; 221, call; 221, 222; 221, 223; 222, identifier:len; 223, argument_list; 223, 224; 224, identifier:input_files; 225, integer:1; 226, block; 226, 227; 227, return_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, subscript; 229, 230; 229, 231; 230, identifier:io; 231, identifier:extension; 232, argument_list; 232, 233; 232, 238; 232, 241; 233, keyword_argument; 233, 234; 233, 235; 234, identifier:filename; 235, subscript; 235, 236; 235, 237; 236, identifier:filenames; 237, integer:0; 238, keyword_argument; 238, 239; 238, 240; 239, identifier:name; 240, identifier:name; 241, dictionary_splat; 241, 242; 242, identifier:kwargs; 243, else_clause; 243, 244; 244, block; 244, 245; 245, return_statement; 245, 246; 246, call; 246, 247; 246, 250; 247, subscript; 247, 248; 247, 249; 248, identifier:io; 249, identifier:extension; 250, argument_list; 250, 251; 250, 254; 250, 257; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:filenames; 253, identifier:filenames; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:name; 256, identifier:name; 257, dictionary_splat; 257, 258; 258, identifier:kwargs | def GenericPump(filenames, use_jppy=False, name="GenericPump", **kwargs):
if isinstance(filenames, str):
filenames = [filenames]
try:
iter(filenames)
except TypeError:
log.critical("Don't know how to iterate through filenames.")
raise TypeError("Invalid filenames.")
extensions = set(os.path.splitext(fn)[1] for fn in filenames)
if len(extensions) > 1:
log.critical("Mixed filetypes, please use only files of the same type")
raise IOError("Mixed filetypes.")
extension = list(extensions)[0]
io = {
'.evt': EvtPump,
'.h5': HDF5Pump,
'.root': EventPump if use_jppy else AanetPump,
'.dat': DAQPump,
'.dqd': CLBPump,
}
if extension not in io:
log.critical(
"No pump found for file extension '{0}'".format(extension)
)
raise ValueError("Unknown filetype")
missing_files = [fn for fn in filenames if not os.path.exists(fn)]
if missing_files:
if len(missing_files) == len(filenames):
message = "None of the given files could be found."
log.critical(message)
raise SystemExit(message)
else:
log.warning(
"The following files are missing and ignored: {}".format(
', '.join(missing_files)
)
)
input_files = set(filenames) - set(missing_files)
if len(input_files) == 1:
return io[extension](filename=filenames[0], name=name, **kwargs)
else:
return io[extension](filenames=filenames, name=name, **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_sources; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:plate; 6, identifier:plate_value; 7, default_parameter; 7, 8; 7, 9; 8, identifier:sources; 9, None; 10, block; 10, 11; 10, 20; 10, 84; 10, 121; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:sources; 14, None; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:sources; 19, list:[]; 20, if_statement; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:sources; 24, block; 24, 25; 25, for_statement; 25, 26; 25, 29; 25, 35; 26, pattern_list; 26, 27; 26, 28; 27, identifier:si; 28, identifier:source; 29, call; 29, 30; 29, 31; 30, identifier:enumerate; 31, argument_list; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:sources; 35, block; 35, 36; 36, if_statement; 36, 37; 36, 51; 36, 63; 36, 81; 37, boolean_operator:and; 37, 38; 37, 46; 38, comparison_operator:==; 38, 39; 38, 45; 39, call; 39, 40; 39, 41; 40, identifier:len; 41, argument_list; 41, 42; 42, attribute; 42, 43; 42, 44; 43, identifier:source; 44, identifier:streams; 45, integer:1; 46, comparison_operator:in; 46, 47; 46, 48; 47, None; 48, attribute; 48, 49; 48, 50; 49, identifier:source; 50, identifier:streams; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:sources; 56, identifier:append; 57, argument_list; 57, 58; 58, subscript; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:source; 61, identifier:streams; 62, None; 63, elif_clause; 63, 64; 63, 69; 64, comparison_operator:in; 64, 65; 64, 66; 65, identifier:plate_value; 66, attribute; 66, 67; 66, 68; 67, identifier:source; 68, identifier:streams; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:sources; 74, identifier:append; 75, argument_list; 75, 76; 76, subscript; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:source; 79, identifier:streams; 80, identifier:plate_value; 81, else_clause; 81, 82; 82, block; 82, 83; 83, pass_statement; 84, if_statement; 84, 85; 84, 89; 85, not_operator; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:plate; 88, identifier:is_root; 89, block; 89, 90; 89, 108; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:parent_plate_value; 93, call; 93, 94; 93, 95; 94, identifier:tuple; 95, generator_expression; 95, 96; 95, 97; 95, 100; 96, identifier:pv; 97, for_in_clause; 97, 98; 97, 99; 98, identifier:pv; 99, identifier:plate_value; 100, if_clause; 100, 101; 101, comparison_operator:!=; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:pv; 104, integer:0; 105, attribute; 105, 106; 105, 107; 106, identifier:plate; 107, identifier:meta_data_id; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:sources; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:get_sources; 115, argument_list; 115, 116; 115, 119; 115, 120; 116, attribute; 116, 117; 116, 118; 117, identifier:plate; 118, identifier:parent; 119, identifier:parent_plate_value; 120, identifier:sources; 121, return_statement; 121, 122; 122, identifier:sources | def get_sources(self, plate, plate_value, sources=None):
if sources is None:
sources = []
if self.sources:
for si, source in enumerate(self.sources):
if len(source.streams) == 1 and None in source.streams:
sources.append(source.streams[None])
elif plate_value in source.streams:
sources.append(source.streams[plate_value])
else:
pass
if not plate.is_root:
parent_plate_value = tuple(pv for pv in plate_value if pv[0] != plate.meta_data_id)
sources = self.get_sources(plate.parent, parent_plate_value, sources)
return sources |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_splitting_stream; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:input_plate_value; 6, block; 6, 7; 6, 15; 6, 35; 6, 59; 6, 81; 6, 91; 6, 252; 7, if_statement; 7, 8; 7, 12; 8, not_operator; 8, 9; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:splitting_node; 12, block; 12, 13; 13, return_statement; 13, 14; 14, None; 15, if_statement; 15, 16; 15, 26; 16, comparison_operator:==; 16, 17; 16, 25; 17, call; 17, 18; 17, 19; 18, identifier:len; 19, argument_list; 19, 20; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:splitting_node; 24, identifier:plates; 25, integer:0; 26, block; 26, 27; 27, return_statement; 27, 28; 28, subscript; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:splitting_node; 33, identifier:streams; 34, None; 35, if_statement; 35, 36; 35, 46; 36, comparison_operator:>; 36, 37; 36, 45; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:splitting_node; 44, identifier:plates; 45, integer:1; 46, block; 46, 47; 47, raise_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:ValueError; 50, argument_list; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, string:"Splitting node cannot live on multiple plates for factor {}"; 54, identifier:format; 55, argument_list; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:factor_id; 59, if_statement; 59, 60; 59, 75; 60, boolean_operator:and; 60, 61; 60, 65; 61, not_operator; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:input_plate; 65, comparison_operator:>; 65, 66; 65, 74; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:splitting_node; 73, identifier:plates; 74, integer:0; 75, block; 75, 76; 76, raise_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:ValueError; 79, argument_list; 79, 80; 80, string:"Splitting node cannot live on a plate if there is no input plate"; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:splitting_plate; 84, subscript; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:splitting_node; 89, identifier:plates; 90, integer:0; 91, if_statement; 91, 92; 91, 97; 91, 108; 92, comparison_operator:==; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:input_plate; 96, identifier:splitting_plate; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:splitting_stream; 101, subscript; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:splitting_node; 106, identifier:streams; 107, identifier:input_plate_value; 108, else_clause; 108, 109; 109, block; 109, 110; 110, if_statement; 110, 111; 110, 119; 110, 170; 110, 228; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:splitting_plate; 114, identifier:is_child; 115, argument_list; 115, 116; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:input_plate; 119, block; 119, 120; 119, 145; 119, 158; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:ppv; 123, call; 123, 124; 123, 125; 124, identifier:filter; 125, argument_list; 125, 126; 125, 138; 126, lambda; 126, 127; 126, 129; 127, lambda_parameters; 127, 128; 128, identifier:x; 129, call; 129, 130; 129, 131; 130, identifier:all; 131, generator_expression; 131, 132; 131, 135; 132, comparison_operator:in; 132, 133; 132, 134; 133, identifier:p; 134, identifier:input_plate_value; 135, for_in_clause; 135, 136; 135, 137; 136, identifier:p; 137, identifier:x; 138, attribute; 138, 139; 138, 144; 139, attribute; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:self; 142, identifier:input_plate; 143, identifier:parent; 144, identifier:values; 145, if_statement; 145, 146; 145, 152; 146, comparison_operator:!=; 146, 147; 146, 151; 147, call; 147, 148; 147, 149; 148, identifier:len; 149, argument_list; 149, 150; 150, identifier:ppv; 151, integer:1; 152, block; 152, 153; 153, raise_statement; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:ValueError; 156, argument_list; 156, 157; 157, string:"Parent plate value not found"; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:splitting_stream; 161, subscript; 161, 162; 161, 167; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:splitting_node; 166, identifier:streams; 167, subscript; 167, 168; 167, 169; 168, identifier:ppv; 169, integer:0; 170, elif_clause; 170, 171; 170, 179; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:splitting_plate; 174, identifier:is_descendant; 175, argument_list; 175, 176; 176, attribute; 176, 177; 176, 178; 177, identifier:self; 178, identifier:input_plate; 179, block; 179, 180; 179, 205; 179, 218; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:ppv; 183, call; 183, 184; 183, 185; 184, identifier:filter; 185, argument_list; 185, 186; 185, 198; 186, lambda; 186, 187; 186, 189; 187, lambda_parameters; 187, 188; 188, identifier:x; 189, call; 189, 190; 189, 191; 190, identifier:all; 191, generator_expression; 191, 192; 191, 195; 192, comparison_operator:in; 192, 193; 192, 194; 193, identifier:p; 194, identifier:input_plate_value; 195, for_in_clause; 195, 196; 195, 197; 196, identifier:p; 197, identifier:x; 198, attribute; 198, 199; 198, 204; 199, attribute; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:input_plate; 203, identifier:parent; 204, identifier:values; 205, if_statement; 205, 206; 205, 212; 206, comparison_operator:!=; 206, 207; 206, 211; 207, call; 207, 208; 207, 209; 208, identifier:len; 209, argument_list; 209, 210; 210, identifier:ppv; 211, integer:1; 212, block; 212, 213; 213, raise_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:ValueError; 216, argument_list; 216, 217; 217, string:"Parent plate value not found"; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:splitting_stream; 221, subscript; 221, 222; 221, 227; 222, attribute; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:self; 225, identifier:splitting_node; 226, identifier:streams; 227, identifier:ppv; 228, else_clause; 228, 229; 229, block; 229, 230; 230, raise_statement; 230, 231; 231, call; 231, 232; 231, 233; 232, identifier:IncompatiblePlatesError; 233, argument_list; 233, 234; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, string:"Splitting node plate {} does not match input plate {} for factor {}"; 237, identifier:format; 238, argument_list; 238, 239; 238, 242; 238, 249; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:input_plate; 242, subscript; 242, 243; 242, 248; 243, attribute; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:self; 246, identifier:splitting_node; 247, identifier:plates; 248, integer:0; 249, attribute; 249, 250; 249, 251; 250, identifier:self; 251, identifier:factor_id; 252, return_statement; 252, 253; 253, identifier:splitting_stream | def get_splitting_stream(self, input_plate_value):
if not self.splitting_node:
return None
if len(self.splitting_node.plates) == 0:
return self.splitting_node.streams[None]
if len(self.splitting_node.plates) > 1:
raise ValueError("Splitting node cannot live on multiple plates for factor {}"
.format(self.factor_id))
if not self.input_plate and len(self.splitting_node.plates) > 0:
raise ValueError("Splitting node cannot live on a plate if there is no input plate")
splitting_plate = self.splitting_node.plates[0]
if self.input_plate == splitting_plate:
splitting_stream = self.splitting_node.streams[input_plate_value]
else:
if splitting_plate.is_child(self.input_plate):
ppv = filter(lambda x: all(p in input_plate_value for p in x), self.input_plate.parent.values)
if len(ppv) != 1:
raise ValueError("Parent plate value not found")
splitting_stream = self.splitting_node.streams[ppv[0]]
elif splitting_plate.is_descendant(self.input_plate):
ppv = filter(lambda x: all(p in input_plate_value for p in x), self.input_plate.parent.values)
if len(ppv) != 1:
raise ValueError("Parent plate value not found")
splitting_stream = self.splitting_node.streams[ppv]
else:
raise IncompatiblePlatesError(
"Splitting node plate {} does not match input plate {} for factor {}"
.format(self.input_plate, self.splitting_node.plates[0], self.factor_id))
return splitting_stream |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:iter_cognates; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:dataset; 5, default_parameter; 5, 6; 5, 7; 6, identifier:column; 7, string:'Segments'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:method; 10, string:'turchin'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:threshold; 13, float:0.5; 14, dictionary_splat_pattern; 14, 15; 15, identifier:kw; 16, block; 16, 17; 16, 121; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:==; 18, 19; 18, 20; 19, identifier:method; 20, string:'turchin'; 21, block; 21, 22; 22, for_statement; 22, 23; 22, 24; 22, 29; 23, identifier:row; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:dataset; 27, identifier:objects; 28, string:'FormTable'; 29, block; 29, 30; 29, 47; 29, 61; 29, 82; 29, 95; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:sounds; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, string:''; 36, identifier:join; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:lingpy; 41, identifier:tokens2class; 42, argument_list; 42, 43; 42, 46; 43, subscript; 43, 44; 43, 45; 44, identifier:row; 45, identifier:column; 46, string:'dolgo'; 47, if_statement; 47, 48; 47, 54; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:sounds; 51, identifier:startswith; 52, argument_list; 52, 53; 53, string:'V'; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:sounds; 58, binary_operator:+; 58, 59; 58, 60; 59, string:'H'; 60, identifier:sounds; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:sounds; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, string:'-'; 67, identifier:join; 68, argument_list; 68, 69; 69, subscript; 69, 70; 69, 79; 70, list_comprehension; 70, 71; 70, 72; 70, 75; 71, identifier:s; 72, for_in_clause; 72, 73; 72, 74; 73, identifier:s; 74, identifier:sounds; 75, if_clause; 75, 76; 76, comparison_operator:!=; 76, 77; 76, 78; 77, identifier:s; 78, string:'V'; 79, slice; 79, 80; 79, 81; 80, colon; 81, integer:2; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:cogid; 85, binary_operator:+; 85, 86; 85, 94; 86, binary_operator:+; 86, 87; 86, 93; 87, call; 87, 88; 87, 89; 88, identifier:slug; 89, argument_list; 89, 90; 90, subscript; 90, 91; 90, 92; 91, identifier:row; 92, string:'Parameter_ID'; 93, string:'-'; 94, identifier:sounds; 95, if_statement; 95, 96; 95, 99; 96, comparison_operator:not; 96, 97; 96, 98; 97, string:'0'; 98, identifier:sounds; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, yield; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:dict; 104, argument_list; 104, 105; 104, 110; 104, 115; 104, 118; 105, keyword_argument; 105, 106; 105, 107; 106, identifier:Form_ID; 107, subscript; 107, 108; 107, 109; 108, identifier:row; 109, string:'ID'; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:Form; 112, subscript; 112, 113; 112, 114; 113, identifier:row; 114, string:'Value'; 115, keyword_argument; 115, 116; 115, 117; 116, identifier:Cognateset_ID; 117, identifier:cogid; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:Cognate_Detection_Method; 120, string:'CMM'; 121, if_statement; 121, 122; 121, 127; 122, comparison_operator:in; 122, 123; 122, 124; 123, identifier:method; 124, list:['sca', 'lexstat']; 124, 125; 124, 126; 125, string:'sca'; 126, string:'lexstat'; 127, block; 127, 128; 127, 135; 127, 148; 127, 163; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:lex; 131, call; 131, 132; 131, 133; 132, identifier:_cldf2lexstat; 133, argument_list; 133, 134; 134, identifier:dataset; 135, if_statement; 135, 136; 135, 139; 136, comparison_operator:==; 136, 137; 136, 138; 137, identifier:method; 138, string:'lexstat'; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:lex; 144, identifier:get_scorer; 145, argument_list; 145, 146; 146, dictionary_splat; 146, 147; 147, identifier:kw; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:lex; 152, identifier:cluster; 153, argument_list; 153, 154; 153, 157; 153, 160; 154, keyword_argument; 154, 155; 154, 156; 155, identifier:method; 156, identifier:method; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:threshold; 159, identifier:threshold; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:ref; 162, string:'cogid'; 163, for_statement; 163, 164; 163, 165; 163, 166; 164, identifier:k; 165, identifier:lex; 166, block; 166, 167; 167, expression_statement; 167, 168; 168, yield; 168, 169; 169, call; 169, 170; 169, 171; 170, identifier:Cognate; 171, argument_list; 171, 172; 171, 178; 171, 184; 171, 190; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:Form_ID; 174, subscript; 174, 175; 174, 176; 174, 177; 175, identifier:lex; 176, identifier:k; 177, string:'lid'; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:Form; 180, subscript; 180, 181; 180, 182; 180, 183; 181, identifier:lex; 182, identifier:k; 183, string:'value'; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:Cognateset_ID; 186, subscript; 186, 187; 186, 188; 186, 189; 187, identifier:lex; 188, identifier:k; 189, string:'cogid'; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:Cognate_Detection_Method; 192, binary_operator:+; 192, 193; 192, 194; 193, identifier:method; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, string:'-t{0:.2f}'; 197, identifier:format; 198, argument_list; 198, 199; 199, identifier:threshold | def iter_cognates(dataset, column='Segments', method='turchin', threshold=0.5, **kw):
if method == 'turchin':
for row in dataset.objects['FormTable']:
sounds = ''.join(lingpy.tokens2class(row[column], 'dolgo'))
if sounds.startswith('V'):
sounds = 'H' + sounds
sounds = '-'.join([s for s in sounds if s != 'V'][:2])
cogid = slug(row['Parameter_ID']) + '-' + sounds
if '0' not in sounds:
yield dict(
Form_ID=row['ID'],
Form=row['Value'],
Cognateset_ID=cogid,
Cognate_Detection_Method='CMM')
if method in ['sca', 'lexstat']:
lex = _cldf2lexstat(dataset)
if method == 'lexstat':
lex.get_scorer(**kw)
lex.cluster(method=method, threshold=threshold, ref='cogid')
for k in lex:
yield Cognate(
Form_ID=lex[k, 'lid'],
Form=lex[k, 'value'],
Cognateset_ID=lex[k, 'cogid'],
Cognate_Detection_Method=method + '-t{0:.2f}'.format(threshold)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_tool_class; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:tool; 6, block; 6, 7; 6, 39; 6, 43; 6, 105; 6, 115; 6, 123; 6, 133; 7, if_statement; 7, 8; 7, 13; 7, 21; 7, 32; 8, call; 8, 9; 8, 10; 9, identifier:isinstance; 10, argument_list; 10, 11; 10, 12; 11, identifier:tool; 12, identifier:string_types; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:tool_id; 17, call; 17, 18; 17, 19; 18, identifier:StreamId; 19, argument_list; 19, 20; 20, identifier:tool; 21, elif_clause; 21, 22; 21, 27; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:tool; 26, identifier:StreamId; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:tool_id; 31, identifier:tool; 32, else_clause; 32, 33; 33, block; 33, 34; 34, raise_statement; 34, 35; 35, call; 35, 36; 35, 37; 36, identifier:TypeError; 37, argument_list; 37, 38; 38, identifier:tool; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:tool_stream_view; 42, None; 43, if_statement; 43, 44; 43, 49; 43, 69; 44, comparison_operator:in; 44, 45; 44, 46; 45, identifier:tool_id; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:tools; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:tool_stream_view; 53, call; 53, 54; 53, 61; 54, attribute; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:tools; 59, identifier:tool_id; 60, identifier:window; 61, argument_list; 61, 62; 62, tuple; 62, 63; 62, 64; 63, identifier:MIN_DATE; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:tools; 68, identifier:up_to_timestamp; 69, else_clause; 69, 70; 70, block; 70, 71; 71, for_statement; 71, 72; 71, 73; 71, 76; 72, identifier:tool_channel; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:tool_channels; 76, block; 76, 77; 76, 85; 77, if_statement; 77, 78; 77, 83; 78, comparison_operator:==; 78, 79; 78, 80; 79, identifier:tool_channel; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:tools; 83, block; 83, 84; 84, continue_statement; 85, if_statement; 85, 86; 85, 89; 86, comparison_operator:in; 86, 87; 86, 88; 87, identifier:tool_id; 88, identifier:tool_channel; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:tool_stream_view; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, subscript; 95, 96; 95, 97; 96, identifier:tool_channel; 97, identifier:tool_id; 98, identifier:window; 99, argument_list; 99, 100; 100, tuple; 100, 101; 100, 102; 101, identifier:MIN_DATE; 102, attribute; 102, 103; 102, 104; 103, identifier:tool_channel; 104, identifier:up_to_timestamp; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:tool_stream_view; 108, None; 109, block; 109, 110; 110, raise_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:ToolNotFoundError; 113, argument_list; 113, 114; 114, identifier:tool; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:last; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:tool_stream_view; 121, identifier:last; 122, argument_list; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:last; 126, None; 127, block; 127, 128; 128, raise_statement; 128, 129; 129, call; 129, 130; 129, 131; 130, identifier:ToolNotFoundError; 131, argument_list; 131, 132; 132, identifier:tool; 133, return_statement; 133, 134; 134, attribute; 134, 135; 134, 140; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:tool_stream_view; 138, identifier:last; 139, argument_list; 140, identifier:value | def get_tool_class(self, tool):
if isinstance(tool, string_types):
tool_id = StreamId(tool)
elif isinstance(tool, StreamId):
tool_id = tool
else:
raise TypeError(tool)
tool_stream_view = None
if tool_id in self.tools:
tool_stream_view = self.tools[tool_id].window((MIN_DATE, self.tools.up_to_timestamp))
else:
for tool_channel in self.tool_channels:
if tool_channel == self.tools:
continue
if tool_id in tool_channel:
tool_stream_view = tool_channel[tool_id].window((MIN_DATE, tool_channel.up_to_timestamp))
if tool_stream_view is None:
raise ToolNotFoundError(tool)
last = tool_stream_view.last()
if last is None:
raise ToolNotFoundError(tool)
return tool_stream_view.last().value |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:pmt_angles; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 45; 6, if_statement; 6, 7; 6, 12; 7, comparison_operator:==; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:_pmt_angles; 11, list:[]; 12, block; 12, 13; 12, 33; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:mask; 16, binary_operator:&; 16, 17; 16, 25; 17, parenthesized_expression; 17, 18; 18, comparison_operator:==; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:pmts; 23, identifier:du; 24, integer:1; 25, parenthesized_expression; 25, 26; 26, comparison_operator:==; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:pmts; 31, identifier:floor; 32, integer:1; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_pmt_angles; 38, subscript; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:pmts; 43, identifier:dir; 44, identifier:mask; 45, return_statement; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_pmt_angles | def pmt_angles(self):
if self._pmt_angles == []:
mask = (self.pmts.du == 1) & (self.pmts.floor == 1)
self._pmt_angles = self.pmts.dir[mask]
return self._pmt_angles |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_get_point; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:profile; 6, identifier:point; 7, block; 7, 8; 7, 22; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:cur_points_z; 11, list_comprehension; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:p; 15, identifier:location; 16, identifier:z; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:p; 19, attribute; 19, 20; 19, 21; 20, identifier:profile; 21, identifier:elements; 22, try_statement; 22, 23; 22, 41; 23, block; 23, 24; 23, 35; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:cur_idx; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:cur_points_z; 30, identifier:index; 31, argument_list; 31, 32; 32, attribute; 32, 33; 32, 34; 33, identifier:point; 34, identifier:z; 35, return_statement; 35, 36; 36, subscript; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:profile; 39, identifier:elements; 40, identifier:cur_idx; 41, except_clause; 41, 42; 41, 43; 42, identifier:ValueError; 43, block; 43, 44; 43, 54; 43, 60; 43, 69; 43, 77; 43, 87; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:new_idx; 47, call; 47, 48; 47, 49; 48, identifier:bisect_left; 49, argument_list; 49, 50; 49, 51; 50, identifier:cur_points_z; 51, attribute; 51, 52; 51, 53; 52, identifier:point; 53, identifier:z; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:new_point; 57, call; 57, 58; 57, 59; 58, identifier:Point; 59, argument_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:new_point; 64, identifier:location; 65, call; 65, 66; 65, 67; 66, identifier:sPoint; 67, argument_list; 67, 68; 68, identifier:point; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:new_point; 73, identifier:time; 74, attribute; 74, 75; 74, 76; 75, identifier:profile; 76, identifier:time; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:profile; 82, identifier:elements; 83, identifier:insert; 84, argument_list; 84, 85; 84, 86; 85, identifier:new_idx; 86, identifier:new_point; 87, return_statement; 87, 88; 88, identifier:new_point | def _get_point(self, profile, point):
cur_points_z = [p.location.z for p in profile.elements]
try:
cur_idx = cur_points_z.index(point.z)
return profile.elements[cur_idx]
except ValueError:
new_idx = bisect_left(cur_points_z, point.z)
new_point = Point()
new_point.location = sPoint(point)
new_point.time = profile.time
profile.elements.insert(new_idx, new_point)
return new_point |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:metadata_sorter; 3, parameters; 3, 4; 3, 5; 4, identifier:x; 5, identifier:y; 6, block; 6, 7; 6, 14; 7, if_statement; 7, 8; 7, 11; 8, comparison_operator:==; 8, 9; 8, 10; 9, identifier:x; 10, identifier:y; 11, block; 11, 12; 12, return_statement; 12, 13; 13, integer:0; 14, if_statement; 14, 15; 14, 22; 14, 41; 14, 49; 14, 56; 15, boolean_operator:and; 15, 16; 15, 19; 16, comparison_operator:in; 16, 17; 16, 18; 17, identifier:x; 18, identifier:METADATA_SORTER_FIRST; 19, comparison_operator:in; 19, 20; 19, 21; 20, identifier:y; 21, identifier:METADATA_SORTER_FIRST; 22, block; 22, 23; 23, return_statement; 23, 24; 24, conditional_expression:if; 24, 25; 24, 27; 24, 40; 25, unary_operator:-; 25, 26; 26, integer:1; 27, comparison_operator:<; 27, 28; 27, 34; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:METADATA_SORTER_FIRST; 31, identifier:index; 32, argument_list; 32, 33; 33, identifier:x; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:METADATA_SORTER_FIRST; 37, identifier:index; 38, argument_list; 38, 39; 39, identifier:y; 40, integer:1; 41, elif_clause; 41, 42; 41, 45; 42, comparison_operator:in; 42, 43; 42, 44; 43, identifier:x; 44, identifier:METADATA_SORTER_FIRST; 45, block; 45, 46; 46, return_statement; 46, 47; 47, unary_operator:-; 47, 48; 48, integer:1; 49, elif_clause; 49, 50; 49, 53; 50, comparison_operator:in; 50, 51; 50, 52; 51, identifier:y; 52, identifier:METADATA_SORTER_FIRST; 53, block; 53, 54; 54, return_statement; 54, 55; 55, integer:1; 56, else_clause; 56, 57; 57, block; 57, 58; 58, if_statement; 58, 59; 58, 72; 58, 87; 58, 97; 58, 108; 59, boolean_operator:and; 59, 60; 59, 66; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:x; 63, identifier:startswith; 64, argument_list; 64, 65; 65, string:'_'; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:y; 69, identifier:startswith; 70, argument_list; 70, 71; 71, string:'_'; 72, block; 72, 73; 73, return_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:cmp; 76, argument_list; 76, 77; 76, 82; 77, subscript; 77, 78; 77, 79; 78, identifier:x; 79, slice; 79, 80; 79, 81; 80, integer:1; 81, colon; 82, subscript; 82, 83; 82, 84; 83, identifier:y; 84, slice; 84, 85; 84, 86; 85, integer:1; 86, colon; 87, elif_clause; 87, 88; 87, 94; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:x; 91, identifier:startswith; 92, argument_list; 92, 93; 93, string:'_'; 94, block; 94, 95; 95, return_statement; 95, 96; 96, integer:1; 97, elif_clause; 97, 98; 97, 104; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:y; 101, identifier:startswith; 102, argument_list; 102, 103; 103, string:'_'; 104, block; 104, 105; 105, return_statement; 105, 106; 106, unary_operator:-; 106, 107; 107, integer:1; 108, else_clause; 108, 109; 109, block; 109, 110; 110, return_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:cmp; 113, argument_list; 113, 114; 113, 115; 114, identifier:x; 115, identifier:y | def metadata_sorter(x, y):
if x == y:
return 0
if x in METADATA_SORTER_FIRST and y in METADATA_SORTER_FIRST:
return -1 if METADATA_SORTER_FIRST.index(x) < METADATA_SORTER_FIRST.index(y) else 1
elif x in METADATA_SORTER_FIRST:
return -1
elif y in METADATA_SORTER_FIRST:
return 1
else:
if x.startswith('_') and y.startswith('_'):
return cmp(x[1:], y[1:])
elif x.startswith('_'):
return 1
elif y.startswith('_'):
return -1
else:
return cmp(x, y) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:computeStrongestPaths; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:profile; 6, identifier:pairwisePreferences; 7, block; 7, 8; 7, 18; 7, 25; 7, 31; 7, 43; 7, 105; 7, 181; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:cands; 11, call; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:profile; 15, identifier:candMap; 16, identifier:keys; 17, argument_list; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:numCands; 21, call; 21, 22; 21, 23; 22, identifier:len; 23, argument_list; 23, 24; 24, identifier:cands; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:strongestPaths; 28, call; 28, 29; 28, 30; 29, identifier:dict; 30, argument_list; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:cand; 33, identifier:cands; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:strongestPaths; 39, identifier:cand; 40, call; 40, 41; 40, 42; 41, identifier:dict; 42, argument_list; 43, for_statement; 43, 44; 43, 45; 43, 52; 44, identifier:i; 45, call; 45, 46; 45, 47; 46, identifier:range; 47, argument_list; 47, 48; 47, 49; 48, integer:1; 49, binary_operator:+; 49, 50; 49, 51; 50, identifier:numCands; 51, integer:1; 52, block; 52, 53; 53, for_statement; 53, 54; 53, 55; 53, 62; 54, identifier:j; 55, call; 55, 56; 55, 57; 56, identifier:range; 57, argument_list; 57, 58; 57, 59; 58, integer:1; 59, binary_operator:+; 59, 60; 59, 61; 60, identifier:numCands; 61, integer:1; 62, block; 62, 63; 62, 70; 63, if_statement; 63, 64; 63, 68; 64, parenthesized_expression; 64, 65; 65, comparison_operator:==; 65, 66; 65, 67; 66, identifier:i; 67, identifier:j; 68, block; 68, 69; 69, continue_statement; 70, if_statement; 70, 71; 70, 82; 70, 95; 71, comparison_operator:>; 71, 72; 71, 77; 72, subscript; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:pairwisePreferences; 75, identifier:i; 76, identifier:j; 77, subscript; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:pairwisePreferences; 80, identifier:j; 81, identifier:i; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 90; 85, subscript; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:strongestPaths; 88, identifier:i; 89, identifier:j; 90, subscript; 90, 91; 90, 94; 91, subscript; 91, 92; 91, 93; 92, identifier:pairwisePreferences; 93, identifier:i; 94, identifier:j; 95, else_clause; 95, 96; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 104; 99, subscript; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:strongestPaths; 102, identifier:i; 103, identifier:j; 104, integer:0; 105, for_statement; 105, 106; 105, 107; 105, 114; 106, identifier:i; 107, call; 107, 108; 107, 109; 108, identifier:range; 109, argument_list; 109, 110; 109, 111; 110, integer:1; 111, binary_operator:+; 111, 112; 111, 113; 112, identifier:numCands; 113, integer:1; 114, block; 114, 115; 115, for_statement; 115, 116; 115, 117; 115, 124; 116, identifier:j; 117, call; 117, 118; 117, 119; 118, identifier:range; 119, argument_list; 119, 120; 119, 121; 120, integer:1; 121, binary_operator:+; 121, 122; 121, 123; 122, identifier:numCands; 123, integer:1; 124, block; 124, 125; 124, 132; 125, if_statement; 125, 126; 125, 130; 126, parenthesized_expression; 126, 127; 127, comparison_operator:==; 127, 128; 127, 129; 128, identifier:i; 129, identifier:j; 130, block; 130, 131; 131, continue_statement; 132, for_statement; 132, 133; 132, 134; 132, 141; 133, identifier:k; 134, call; 134, 135; 134, 136; 135, identifier:range; 136, argument_list; 136, 137; 136, 138; 137, integer:1; 138, binary_operator:+; 138, 139; 138, 140; 139, identifier:numCands; 140, integer:1; 141, block; 141, 142; 141, 153; 142, if_statement; 142, 143; 142, 151; 143, parenthesized_expression; 143, 144; 144, boolean_operator:or; 144, 145; 144, 148; 145, comparison_operator:==; 145, 146; 145, 147; 146, identifier:i; 147, identifier:k; 148, comparison_operator:==; 148, 149; 148, 150; 149, identifier:j; 150, identifier:k; 151, block; 151, 152; 152, continue_statement; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 160; 155, subscript; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:strongestPaths; 158, identifier:j; 159, identifier:k; 160, call; 160, 161; 160, 162; 161, identifier:max; 162, argument_list; 162, 163; 162, 168; 163, subscript; 163, 164; 163, 167; 164, subscript; 164, 165; 164, 166; 165, identifier:strongestPaths; 166, identifier:j; 167, identifier:k; 168, call; 168, 169; 168, 170; 169, identifier:min; 170, argument_list; 170, 171; 170, 176; 171, subscript; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:strongestPaths; 174, identifier:j; 175, identifier:i; 176, subscript; 176, 177; 176, 180; 177, subscript; 177, 178; 177, 179; 178, identifier:strongestPaths; 179, identifier:i; 180, identifier:k; 181, return_statement; 181, 182; 182, identifier:strongestPaths | def computeStrongestPaths(self, profile, pairwisePreferences):
cands = profile.candMap.keys()
numCands = len(cands)
strongestPaths = dict()
for cand in cands:
strongestPaths[cand] = dict()
for i in range(1, numCands + 1):
for j in range(1, numCands + 1):
if (i == j):
continue
if pairwisePreferences[i][j] > pairwisePreferences[j][i]:
strongestPaths[i][j] = pairwisePreferences[i][j]
else:
strongestPaths[i][j] = 0
for i in range(1, numCands + 1):
for j in range(1, numCands + 1):
if (i == j):
continue
for k in range(1, numCands + 1):
if (i == k or j == k):
continue
strongestPaths[j][k] = max(strongestPaths[j][k], min(strongestPaths[j][i], strongestPaths[i][k]))
return strongestPaths |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:computePairwisePreferences; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:profile; 6, block; 6, 7; 6, 17; 6, 23; 6, 35; 6, 56; 6, 183; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:cands; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:profile; 14, identifier:candMap; 15, identifier:keys; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:pairwisePreferences; 20, call; 20, 21; 20, 22; 21, identifier:dict; 22, argument_list; 23, for_statement; 23, 24; 23, 25; 23, 26; 24, identifier:cand; 25, identifier:cands; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:pairwisePreferences; 31, identifier:cand; 32, call; 32, 33; 32, 34; 33, identifier:dict; 34, argument_list; 35, for_statement; 35, 36; 35, 37; 35, 38; 36, identifier:cand1; 37, identifier:cands; 38, block; 38, 39; 39, for_statement; 39, 40; 39, 41; 39, 42; 40, identifier:cand2; 41, identifier:cands; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 47; 44, comparison_operator:!=; 44, 45; 44, 46; 45, identifier:cand1; 46, identifier:cand2; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 55; 50, subscript; 50, 51; 50, 54; 51, subscript; 51, 52; 51, 53; 52, identifier:pairwisePreferences; 53, identifier:cand1; 54, identifier:cand2; 55, integer:0; 56, for_statement; 56, 57; 56, 58; 56, 61; 57, identifier:preference; 58, attribute; 58, 59; 58, 60; 59, identifier:profile; 60, identifier:preferences; 61, block; 61, 62; 61, 68; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:wmgMap; 65, attribute; 65, 66; 65, 67; 66, identifier:preference; 67, identifier:wmgMap; 68, for_statement; 68, 69; 68, 72; 68, 79; 69, pattern_list; 69, 70; 69, 71; 70, identifier:cand1; 71, identifier:cand2; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:itertools; 75, identifier:combinations; 76, argument_list; 76, 77; 76, 78; 77, identifier:cands; 78, integer:2; 79, block; 79, 80; 80, if_statement; 80, 81; 80, 88; 80, 110; 80, 140; 80, 161; 81, comparison_operator:not; 81, 82; 81, 83; 82, identifier:cand1; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:wmgMap; 86, identifier:keys; 87, argument_list; 88, block; 88, 89; 89, if_statement; 89, 90; 89, 97; 90, comparison_operator:in; 90, 91; 90, 92; 91, identifier:cand2; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:wmgMap; 95, identifier:keys; 96, argument_list; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, augmented_assignment:+=; 99, 100; 99, 105; 100, subscript; 100, 101; 100, 104; 101, subscript; 101, 102; 101, 103; 102, identifier:pairwisePreferences; 103, identifier:cand2; 104, identifier:cand1; 105, binary_operator:*; 105, 106; 105, 107; 106, integer:1; 107, attribute; 107, 108; 107, 109; 108, identifier:preference; 109, identifier:count; 110, elif_clause; 110, 111; 110, 118; 111, comparison_operator:not; 111, 112; 111, 113; 112, identifier:cand2; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:wmgMap; 116, identifier:keys; 117, argument_list; 118, block; 118, 119; 119, if_statement; 119, 120; 119, 127; 120, comparison_operator:in; 120, 121; 120, 122; 121, identifier:cand1; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:wmgMap; 125, identifier:keys; 126, argument_list; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, augmented_assignment:+=; 129, 130; 129, 135; 130, subscript; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:pairwisePreferences; 133, identifier:cand1; 134, identifier:cand2; 135, binary_operator:*; 135, 136; 135, 137; 136, integer:1; 137, attribute; 137, 138; 137, 139; 138, identifier:preference; 139, identifier:count; 140, elif_clause; 140, 141; 140, 148; 141, comparison_operator:==; 141, 142; 141, 147; 142, subscript; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:wmgMap; 145, identifier:cand1; 146, identifier:cand2; 147, integer:1; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, augmented_assignment:+=; 150, 151; 150, 156; 151, subscript; 151, 152; 151, 155; 152, subscript; 152, 153; 152, 154; 153, identifier:pairwisePreferences; 154, identifier:cand1; 155, identifier:cand2; 156, binary_operator:*; 156, 157; 156, 158; 157, integer:1; 158, attribute; 158, 159; 158, 160; 159, identifier:preference; 160, identifier:count; 161, elif_clause; 161, 162; 161, 170; 162, comparison_operator:==; 162, 163; 162, 168; 163, subscript; 163, 164; 163, 167; 164, subscript; 164, 165; 164, 166; 165, identifier:wmgMap; 166, identifier:cand1; 167, identifier:cand2; 168, unary_operator:-; 168, 169; 169, integer:1; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, augmented_assignment:+=; 172, 173; 172, 178; 173, subscript; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:pairwisePreferences; 176, identifier:cand2; 177, identifier:cand1; 178, binary_operator:*; 178, 179; 178, 180; 179, integer:1; 180, attribute; 180, 181; 180, 182; 181, identifier:preference; 182, identifier:count; 183, return_statement; 183, 184; 184, identifier:pairwisePreferences | def computePairwisePreferences(self, profile):
cands = profile.candMap.keys()
pairwisePreferences = dict()
for cand in cands:
pairwisePreferences[cand] = dict()
for cand1 in cands:
for cand2 in cands:
if cand1 != cand2:
pairwisePreferences[cand1][cand2] = 0
for preference in profile.preferences:
wmgMap = preference.wmgMap
for cand1, cand2 in itertools.combinations(cands, 2):
if cand1 not in wmgMap.keys():
if cand2 in wmgMap.keys():
pairwisePreferences[cand2][cand1] += 1 * preference.count
elif cand2 not in wmgMap.keys():
if cand1 in wmgMap.keys():
pairwisePreferences[cand1][cand2] += 1 * preference.count
elif wmgMap[cand1][cand2] == 1:
pairwisePreferences[cand1][cand2] += 1 * preference.count
elif wmgMap[cand1][cand2] == -1:
pairwisePreferences[cand2][cand1] += 1 * preference.count
return pairwisePreferences |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:STVsocwinners; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:profile; 6, block; 6, 7; 6, 15; 6, 23; 6, 29; 6, 64; 6, 78; 6, 85; 6, 91; 6, 97; 6, 106; 6, 110; 6, 117; 6, 264; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:ordering; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:profile; 13, identifier:getOrderVectors; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:prefcounts; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:profile; 21, identifier:getPreferenceCounts; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:m; 26, attribute; 26, 27; 26, 28; 27, identifier:profile; 28, identifier:numCands; 29, if_statement; 29, 30; 29, 38; 29, 49; 30, comparison_operator:==; 30, 31; 30, 37; 31, call; 31, 32; 31, 33; 32, identifier:min; 33, argument_list; 33, 34; 34, subscript; 34, 35; 34, 36; 35, identifier:ordering; 36, integer:0; 37, integer:0; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:startstate; 42, call; 42, 43; 42, 44; 43, identifier:set; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:range; 47, argument_list; 47, 48; 48, identifier:m; 49, else_clause; 49, 50; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:startstate; 54, call; 54, 55; 54, 56; 55, identifier:set; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:range; 59, argument_list; 59, 60; 59, 61; 60, integer:1; 61, binary_operator:+; 61, 62; 61, 63; 62, identifier:m; 63, integer:1; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, pattern_list; 66, 67; 66, 68; 67, identifier:ordering; 68, identifier:startstate; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:preprocessing; 73, argument_list; 73, 74; 73, 75; 73, 76; 73, 77; 74, identifier:ordering; 75, identifier:prefcounts; 76, identifier:m; 77, identifier:startstate; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:m_star; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:startstate; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:known_winners; 88, call; 88, 89; 88, 90; 89, identifier:set; 90, argument_list; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:hashtable2; 94, call; 94, 95; 94, 96; 95, identifier:set; 96, argument_list; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:root; 100, call; 100, 101; 100, 102; 101, identifier:Node; 102, argument_list; 102, 103; 103, keyword_argument; 103, 104; 103, 105; 104, identifier:value; 105, identifier:startstate; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:stackNode; 109, list:[]; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:stackNode; 114, identifier:append; 115, argument_list; 115, 116; 116, identifier:root; 117, while_statement; 117, 118; 117, 119; 118, identifier:stackNode; 119, block; 119, 120; 119, 128; 119, 138; 119, 168; 119, 174; 119, 186; 119, 197; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:node; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:stackNode; 126, identifier:pop; 127, argument_list; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:state; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:node; 135, identifier:value; 136, identifier:copy; 137, argument_list; 138, if_statement; 138, 139; 138, 154; 139, boolean_operator:and; 139, 140; 139, 146; 140, comparison_operator:==; 140, 141; 140, 145; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, identifier:state; 145, integer:1; 146, comparison_operator:not; 146, 147; 146, 153; 147, subscript; 147, 148; 147, 152; 148, call; 148, 149; 148, 150; 149, identifier:list; 150, argument_list; 150, 151; 151, identifier:state; 152, integer:0; 153, identifier:known_winners; 154, block; 154, 155; 154, 167; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:known_winners; 159, identifier:add; 160, argument_list; 160, 161; 161, subscript; 161, 162; 161, 166; 162, call; 162, 163; 162, 164; 163, identifier:list; 164, argument_list; 164, 165; 165, identifier:state; 166, integer:0; 167, continue_statement; 168, if_statement; 168, 169; 168, 172; 169, comparison_operator:<=; 169, 170; 169, 171; 170, identifier:state; 171, identifier:known_winners; 172, block; 172, 173; 173, continue_statement; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:plural_score; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:get_plurality_scores3; 181, argument_list; 181, 182; 181, 183; 181, 184; 181, 185; 182, identifier:prefcounts; 183, identifier:ordering; 184, identifier:state; 185, identifier:m_star; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:minscore; 189, call; 189, 190; 189, 191; 190, identifier:min; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:plural_score; 195, identifier:values; 196, argument_list; 197, for_statement; 197, 198; 197, 199; 197, 200; 198, identifier:to_be_deleted; 199, identifier:state; 200, block; 200, 201; 201, if_statement; 201, 202; 201, 207; 202, comparison_operator:==; 202, 203; 202, 206; 203, subscript; 203, 204; 203, 205; 204, identifier:plural_score; 205, identifier:to_be_deleted; 206, identifier:minscore; 207, block; 207, 208; 207, 216; 207, 223; 207, 233; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:child_state; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:state; 214, identifier:copy; 215, argument_list; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:child_state; 220, identifier:remove; 221, argument_list; 221, 222; 222, identifier:to_be_deleted; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:tpc; 226, call; 226, 227; 226, 228; 227, identifier:tuple; 228, argument_list; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:sorted; 231, argument_list; 231, 232; 232, identifier:child_state; 233, if_statement; 233, 234; 233, 237; 233, 239; 234, comparison_operator:in; 234, 235; 234, 236; 235, identifier:tpc; 236, identifier:hashtable2; 237, block; 237, 238; 238, continue_statement; 239, else_clause; 239, 240; 240, block; 240, 241; 240, 248; 240, 257; 241, expression_statement; 241, 242; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:hashtable2; 245, identifier:add; 246, argument_list; 246, 247; 247, identifier:tpc; 248, expression_statement; 248, 249; 249, assignment; 249, 250; 249, 251; 250, identifier:child_node; 251, call; 251, 252; 251, 253; 252, identifier:Node; 253, argument_list; 253, 254; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:value; 256, identifier:child_state; 257, expression_statement; 257, 258; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:stackNode; 261, identifier:append; 262, argument_list; 262, 263; 263, identifier:child_node; 264, return_statement; 264, 265; 265, call; 265, 266; 265, 267; 266, identifier:sorted; 267, argument_list; 267, 268; 268, identifier:known_winners | def STVsocwinners(self, profile):
ordering = profile.getOrderVectors()
prefcounts = profile.getPreferenceCounts()
m = profile.numCands
if min(ordering[0]) == 0:
startstate = set(range(m))
else:
startstate = set(range(1, m + 1))
ordering, startstate = self.preprocessing(ordering, prefcounts, m, startstate)
m_star = len(startstate)
known_winners = set()
hashtable2 = set()
root = Node(value=startstate)
stackNode = []
stackNode.append(root)
while stackNode:
node = stackNode.pop()
state = node.value.copy()
if len(state) == 1 and list(state)[0] not in known_winners:
known_winners.add(list(state)[0])
continue
if state <= known_winners:
continue
plural_score = self.get_plurality_scores3(prefcounts, ordering, state, m_star)
minscore = min(plural_score.values())
for to_be_deleted in state:
if plural_score[to_be_deleted] == minscore:
child_state = state.copy()
child_state.remove(to_be_deleted)
tpc = tuple(sorted(child_state))
if tpc in hashtable2:
continue
else:
hashtable2.add(tpc)
child_node = Node(value=child_state)
stackNode.append(child_node)
return sorted(known_winners) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:baldwinsoc_winners; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:profile; 6, block; 6, 7; 6, 15; 6, 21; 6, 29; 6, 64; 6, 78; 6, 84; 6, 90; 6, 99; 6, 103; 6, 110; 6, 283; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:ordering; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:profile; 13, identifier:getOrderVectors; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:m; 18, attribute; 18, 19; 18, 20; 19, identifier:profile; 20, identifier:numCands; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:prefcounts; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:profile; 27, identifier:getPreferenceCounts; 28, argument_list; 29, if_statement; 29, 30; 29, 38; 29, 49; 30, comparison_operator:==; 30, 31; 30, 37; 31, call; 31, 32; 31, 33; 32, identifier:min; 33, argument_list; 33, 34; 34, subscript; 34, 35; 34, 36; 35, identifier:ordering; 36, integer:0; 37, integer:0; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:startstate; 42, call; 42, 43; 42, 44; 43, identifier:set; 44, argument_list; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:range; 47, argument_list; 47, 48; 48, identifier:m; 49, else_clause; 49, 50; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:startstate; 54, call; 54, 55; 54, 56; 55, identifier:set; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:range; 59, argument_list; 59, 60; 59, 61; 60, integer:1; 61, binary_operator:+; 61, 62; 61, 63; 62, identifier:m; 63, integer:1; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:wmg; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:getWmg2; 71, argument_list; 71, 72; 71, 73; 71, 74; 71, 75; 72, identifier:prefcounts; 73, identifier:ordering; 74, identifier:startstate; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:normalize; 77, False; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:known_winners; 81, call; 81, 82; 81, 83; 82, identifier:set; 83, argument_list; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:hashtable2; 87, call; 87, 88; 87, 89; 88, identifier:set; 89, argument_list; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:root; 93, call; 93, 94; 93, 95; 94, identifier:Node; 95, argument_list; 95, 96; 96, keyword_argument; 96, 97; 96, 98; 97, identifier:value; 98, identifier:startstate; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:stackNode; 102, list:[]; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:stackNode; 107, identifier:append; 108, argument_list; 108, 109; 109, identifier:root; 110, while_statement; 110, 111; 110, 112; 111, identifier:stackNode; 112, block; 112, 113; 112, 121; 112, 131; 112, 161; 112, 167; 112, 173; 112, 183; 112, 205; 112, 216; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:node; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:stackNode; 119, identifier:pop; 120, argument_list; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:state; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:node; 128, identifier:value; 129, identifier:copy; 130, argument_list; 131, if_statement; 131, 132; 131, 147; 132, boolean_operator:and; 132, 133; 132, 139; 133, comparison_operator:==; 133, 134; 133, 138; 134, call; 134, 135; 134, 136; 135, identifier:len; 136, argument_list; 136, 137; 137, identifier:state; 138, integer:1; 139, comparison_operator:not; 139, 140; 139, 146; 140, subscript; 140, 141; 140, 145; 141, call; 141, 142; 141, 143; 142, identifier:list; 143, argument_list; 143, 144; 144, identifier:state; 145, integer:0; 146, identifier:known_winners; 147, block; 147, 148; 147, 160; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:known_winners; 152, identifier:add; 153, argument_list; 153, 154; 154, subscript; 154, 155; 154, 159; 155, call; 155, 156; 155, 157; 156, identifier:list; 157, argument_list; 157, 158; 158, identifier:state; 159, integer:0; 160, continue_statement; 161, if_statement; 161, 162; 161, 165; 162, comparison_operator:<=; 162, 163; 162, 164; 163, identifier:state; 164, identifier:known_winners; 165, block; 165, 166; 166, continue_statement; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:plural_score; 170, call; 170, 171; 170, 172; 171, identifier:dict; 172, argument_list; 173, for_statement; 173, 174; 173, 175; 173, 176; 174, identifier:cand; 175, identifier:state; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:plural_score; 181, identifier:cand; 182, integer:0; 183, for_statement; 183, 184; 183, 187; 183, 194; 184, pattern_list; 184, 185; 184, 186; 185, identifier:cand1; 186, identifier:cand2; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:itertools; 190, identifier:permutations; 191, argument_list; 191, 192; 191, 193; 192, identifier:state; 193, integer:2; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, augmented_assignment:+=; 196, 197; 196, 200; 197, subscript; 197, 198; 197, 199; 198, identifier:plural_score; 199, identifier:cand1; 200, subscript; 200, 201; 200, 204; 201, subscript; 201, 202; 201, 203; 202, identifier:wmg; 203, identifier:cand1; 204, identifier:cand2; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:minscore; 208, call; 208, 209; 208, 210; 209, identifier:min; 210, argument_list; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:plural_score; 214, identifier:values; 215, argument_list; 216, for_statement; 216, 217; 216, 218; 216, 219; 217, identifier:to_be_deleted; 218, identifier:state; 219, block; 219, 220; 220, if_statement; 220, 221; 220, 226; 221, comparison_operator:==; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:plural_score; 224, identifier:to_be_deleted; 225, identifier:minscore; 226, block; 226, 227; 226, 235; 226, 242; 226, 252; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:child_state; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:state; 233, identifier:copy; 234, argument_list; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:child_state; 239, identifier:remove; 240, argument_list; 240, 241; 241, identifier:to_be_deleted; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 245; 244, identifier:tpc; 245, call; 245, 246; 245, 247; 246, identifier:tuple; 247, argument_list; 247, 248; 248, call; 248, 249; 248, 250; 249, identifier:sorted; 250, argument_list; 250, 251; 251, identifier:child_state; 252, if_statement; 252, 253; 252, 256; 252, 258; 253, comparison_operator:in; 253, 254; 253, 255; 254, identifier:tpc; 255, identifier:hashtable2; 256, block; 256, 257; 257, continue_statement; 258, else_clause; 258, 259; 259, block; 259, 260; 259, 267; 259, 276; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:hashtable2; 264, identifier:add; 265, argument_list; 265, 266; 266, identifier:tpc; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:child_node; 270, call; 270, 271; 270, 272; 271, identifier:Node; 272, argument_list; 272, 273; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:value; 275, identifier:child_state; 276, expression_statement; 276, 277; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:stackNode; 280, identifier:append; 281, argument_list; 281, 282; 282, identifier:child_node; 283, return_statement; 283, 284; 284, call; 284, 285; 284, 286; 285, identifier:sorted; 286, argument_list; 286, 287; 287, identifier:known_winners | def baldwinsoc_winners(self, profile):
ordering = profile.getOrderVectors()
m = profile.numCands
prefcounts = profile.getPreferenceCounts()
if min(ordering[0]) == 0:
startstate = set(range(m))
else:
startstate = set(range(1, m + 1))
wmg = self.getWmg2(prefcounts, ordering, startstate, normalize=False)
known_winners = set()
hashtable2 = set()
root = Node(value=startstate)
stackNode = []
stackNode.append(root)
while stackNode:
node = stackNode.pop()
state = node.value.copy()
if len(state) == 1 and list(state)[0] not in known_winners:
known_winners.add(list(state)[0])
continue
if state <= known_winners:
continue
plural_score = dict()
for cand in state:
plural_score[cand] = 0
for cand1, cand2 in itertools.permutations(state, 2):
plural_score[cand1] += wmg[cand1][cand2]
minscore = min(plural_score.values())
for to_be_deleted in state:
if plural_score[to_be_deleted] == minscore:
child_state = state.copy()
child_state.remove(to_be_deleted)
tpc = tuple(sorted(child_state))
if tpc in hashtable2:
continue
else:
hashtable2.add(tpc)
child_node = Node(value=child_state)
stackNode.append(child_node)
return sorted(known_winners) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:getWmg2; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:prefcounts; 6, identifier:ordering; 7, identifier:state; 8, default_parameter; 8, 9; 8, 10; 9, identifier:normalize; 10, False; 11, block; 11, 12; 11, 18; 11, 30; 11, 58; 11, 93; 11, 165; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:wmgMap; 15, call; 15, 16; 15, 17; 16, identifier:dict; 17, argument_list; 18, for_statement; 18, 19; 18, 20; 18, 21; 19, identifier:cand; 20, identifier:state; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:wmgMap; 26, identifier:cand; 27, call; 27, 28; 27, 29; 28, identifier:dict; 29, argument_list; 30, for_statement; 30, 31; 30, 34; 30, 41; 31, pattern_list; 31, 32; 31, 33; 32, identifier:cand1; 33, identifier:cand2; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:itertools; 37, identifier:combinations; 38, argument_list; 38, 39; 38, 40; 39, identifier:state; 40, integer:2; 41, block; 41, 42; 41, 50; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 49; 44, subscript; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:wmgMap; 47, identifier:cand1; 48, identifier:cand2; 49, integer:0; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 57; 52, subscript; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:wmgMap; 55, identifier:cand2; 56, identifier:cand1; 57, integer:0; 58, for_statement; 58, 59; 58, 60; 58, 68; 59, identifier:i; 60, call; 60, 61; 60, 62; 61, identifier:range; 62, argument_list; 62, 63; 62, 64; 63, integer:0; 64, call; 64, 65; 64, 66; 65, identifier:len; 66, argument_list; 66, 67; 67, identifier:prefcounts; 68, block; 68, 69; 69, for_statement; 69, 70; 69, 73; 69, 82; 70, pattern_list; 70, 71; 70, 72; 71, identifier:cand1; 72, identifier:cand2; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:itertools; 76, identifier:combinations; 77, argument_list; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:ordering; 80, identifier:i; 81, integer:2; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, augmented_assignment:+=; 84, 85; 84, 90; 85, subscript; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:wmgMap; 88, identifier:cand1; 89, identifier:cand2; 90, subscript; 90, 91; 90, 92; 91, identifier:prefcounts; 92, identifier:i; 93, if_statement; 93, 94; 93, 97; 94, comparison_operator:==; 94, 95; 94, 96; 95, identifier:normalize; 96, True; 97, block; 97, 98; 97, 105; 97, 130; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:maxEdge; 101, call; 101, 102; 101, 103; 102, identifier:float; 103, argument_list; 103, 104; 104, string:'-inf'; 105, for_statement; 105, 106; 105, 107; 105, 112; 106, identifier:cand; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:wmgMap; 110, identifier:keys; 111, argument_list; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:maxEdge; 116, call; 116, 117; 116, 118; 117, identifier:max; 118, argument_list; 118, 119; 118, 120; 119, identifier:maxEdge; 120, call; 120, 121; 120, 122; 121, identifier:max; 122, argument_list; 122, 123; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:wmgMap; 127, identifier:cand; 128, identifier:values; 129, argument_list; 130, for_statement; 130, 131; 130, 132; 130, 137; 131, identifier:cand1; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:wmgMap; 135, identifier:keys; 136, argument_list; 137, block; 137, 138; 138, for_statement; 138, 139; 138, 140; 138, 147; 139, identifier:cand2; 140, call; 140, 141; 140, 146; 141, attribute; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:wmgMap; 144, identifier:cand1; 145, identifier:keys; 146, argument_list; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 155; 150, subscript; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:wmgMap; 153, identifier:cand1; 154, identifier:cand2; 155, binary_operator:/; 155, 156; 155, 164; 156, call; 156, 157; 156, 158; 157, identifier:float; 158, argument_list; 158, 159; 159, subscript; 159, 160; 159, 163; 160, subscript; 160, 161; 160, 162; 161, identifier:wmgMap; 162, identifier:cand1; 163, identifier:cand2; 164, identifier:maxEdge; 165, return_statement; 165, 166; 166, identifier:wmgMap | def getWmg2(self, prefcounts, ordering, state, normalize=False):
wmgMap = dict()
for cand in state:
wmgMap[cand] = dict()
for cand1, cand2 in itertools.combinations(state, 2):
wmgMap[cand1][cand2] = 0
wmgMap[cand2][cand1] = 0
for i in range(0, len(prefcounts)):
for cand1, cand2 in itertools.combinations(ordering[i], 2):
wmgMap[cand1][cand2] += prefcounts[i]
if normalize == True:
maxEdge = float('-inf')
for cand in wmgMap.keys():
maxEdge = max(maxEdge, max(wmgMap[cand].values()))
for cand1 in wmgMap.keys():
for cand2 in wmgMap[cand1].keys():
wmgMap[cand1][cand2] = float(wmgMap[cand1][cand2]) / maxEdge
return wmgMap |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:PluRunOff_cowinners; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:profile; 6, block; 6, 7; 6, 15; 6, 37; 6, 45; 6, 52; 6, 60; 6, 71; 6, 77; 6, 81; 6, 180; 6, 306; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:elecType; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:profile; 13, identifier:getElecType; 14, argument_list; 15, if_statement; 15, 16; 15, 27; 16, boolean_operator:and; 16, 17; 16, 24; 17, boolean_operator:and; 17, 18; 17, 21; 18, comparison_operator:!=; 18, 19; 18, 20; 19, identifier:elecType; 20, string:"soc"; 21, comparison_operator:!=; 21, 22; 21, 23; 22, identifier:elecType; 23, string:"toc"; 24, comparison_operator:!=; 24, 25; 24, 26; 25, identifier:elecType; 26, string:"csv"; 27, block; 27, 28; 27, 33; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:print; 31, argument_list; 31, 32; 32, string:"ERROR: unsupported election type"; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:exit; 36, argument_list; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:prefcounts; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:profile; 43, identifier:getPreferenceCounts; 44, argument_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:len_prefcounts; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, identifier:prefcounts; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:rankmaps; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:profile; 58, identifier:getRankMaps; 59, argument_list; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:ranking; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, call; 65, 66; 65, 67; 66, identifier:MechanismPlurality; 67, argument_list; 68, identifier:getRanking; 69, argument_list; 69, 70; 70, identifier:profile; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:known_winners; 74, call; 74, 75; 74, 76; 75, identifier:set; 76, argument_list; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:top_2_combinations; 80, list:[]; 81, if_statement; 81, 82; 81, 92; 81, 118; 82, comparison_operator:>; 82, 83; 82, 91; 83, call; 83, 84; 83, 85; 84, identifier:len; 85, argument_list; 85, 86; 86, subscript; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:ranking; 89, integer:0; 90, integer:0; 91, integer:1; 92, block; 92, 93; 93, for_statement; 93, 94; 93, 97; 93, 108; 94, pattern_list; 94, 95; 94, 96; 95, identifier:cand1; 96, identifier:cand2; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:itertools; 100, identifier:combinations; 101, argument_list; 101, 102; 101, 107; 102, subscript; 102, 103; 102, 106; 103, subscript; 103, 104; 103, 105; 104, identifier:ranking; 105, integer:0; 106, integer:0; 107, integer:2; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:top_2_combinations; 113, identifier:append; 114, argument_list; 114, 115; 115, list:[cand1, cand2]; 115, 116; 115, 117; 116, identifier:cand1; 117, identifier:cand2; 118, else_clause; 118, 119; 119, block; 119, 120; 119, 130; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:max_cand; 123, subscript; 123, 124; 123, 129; 124, subscript; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:ranking; 127, integer:0; 128, integer:0; 129, integer:0; 130, if_statement; 130, 131; 130, 141; 130, 159; 131, comparison_operator:>; 131, 132; 131, 140; 132, call; 132, 133; 132, 134; 133, identifier:len; 134, argument_list; 134, 135; 135, subscript; 135, 136; 135, 139; 136, subscript; 136, 137; 136, 138; 137, identifier:ranking; 138, integer:0; 139, integer:1; 140, integer:1; 141, block; 141, 142; 142, for_statement; 142, 143; 142, 144; 142, 149; 143, identifier:second_max_cand; 144, subscript; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:ranking; 147, integer:0; 148, integer:1; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:top_2_combinations; 154, identifier:append; 155, argument_list; 155, 156; 156, list:[max_cand, second_max_cand]; 156, 157; 156, 158; 157, identifier:max_cand; 158, identifier:second_max_cand; 159, else_clause; 159, 160; 160, block; 160, 161; 160, 171; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:second_max_cand; 164, subscript; 164, 165; 164, 170; 165, subscript; 165, 166; 165, 169; 166, subscript; 166, 167; 166, 168; 167, identifier:ranking; 168, integer:0; 169, integer:1; 170, integer:0; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:top_2_combinations; 175, identifier:append; 176, argument_list; 176, 177; 177, list:[max_cand, second_max_cand]; 177, 178; 177, 179; 178, identifier:max_cand; 179, identifier:second_max_cand; 180, for_statement; 180, 181; 180, 182; 180, 183; 181, identifier:top_2; 182, identifier:top_2_combinations; 183, block; 183, 184; 183, 198; 183, 268; 183, 279; 183, 297; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:dict_top2; 187, dictionary; 187, 188; 187, 193; 188, pair; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:top_2; 191, integer:0; 192, integer:0; 193, pair; 193, 194; 193, 197; 194, subscript; 194, 195; 194, 196; 195, identifier:top_2; 196, integer:1; 197, integer:0; 198, for_statement; 198, 199; 198, 200; 198, 204; 199, identifier:i; 200, call; 200, 201; 200, 202; 201, identifier:range; 202, argument_list; 202, 203; 203, identifier:len_prefcounts; 204, block; 204, 205; 204, 227; 204, 238; 204, 256; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:vote_top2; 208, dictionary_comprehension; 208, 209; 208, 212; 208, 223; 209, pair; 209, 210; 209, 211; 210, identifier:key; 211, identifier:value; 212, for_in_clause; 212, 213; 212, 216; 213, pattern_list; 213, 214; 213, 215; 214, identifier:key; 215, identifier:value; 216, call; 216, 217; 216, 222; 217, attribute; 217, 218; 217, 221; 218, subscript; 218, 219; 218, 220; 219, identifier:rankmaps; 220, identifier:i; 221, identifier:items; 222, argument_list; 223, if_clause; 223, 224; 224, comparison_operator:in; 224, 225; 224, 226; 225, identifier:key; 226, identifier:top_2; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:top_position; 230, call; 230, 231; 230, 232; 231, identifier:min; 232, argument_list; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:vote_top2; 236, identifier:values; 237, argument_list; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:keys; 241, list_comprehension; 241, 242; 241, 243; 241, 250; 242, identifier:x; 243, for_in_clause; 243, 244; 243, 245; 244, identifier:x; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:vote_top2; 248, identifier:keys; 249, argument_list; 250, if_clause; 250, 251; 251, comparison_operator:==; 251, 252; 251, 255; 252, subscript; 252, 253; 252, 254; 253, identifier:vote_top2; 254, identifier:x; 255, identifier:top_position; 256, for_statement; 256, 257; 256, 258; 256, 259; 257, identifier:key; 258, identifier:keys; 259, block; 259, 260; 260, expression_statement; 260, 261; 261, augmented_assignment:+=; 261, 262; 261, 265; 262, subscript; 262, 263; 262, 264; 263, identifier:dict_top2; 264, identifier:key; 265, subscript; 265, 266; 265, 267; 266, identifier:prefcounts; 267, identifier:i; 268, expression_statement; 268, 269; 269, assignment; 269, 270; 269, 271; 270, identifier:max_value; 271, call; 271, 272; 271, 273; 272, identifier:max; 273, argument_list; 273, 274; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:dict_top2; 277, identifier:values; 278, argument_list; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:winners; 282, list_comprehension; 282, 283; 282, 284; 282, 291; 283, identifier:y; 284, for_in_clause; 284, 285; 284, 286; 285, identifier:y; 286, call; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:dict_top2; 289, identifier:keys; 290, argument_list; 291, if_clause; 291, 292; 292, comparison_operator:==; 292, 293; 292, 296; 293, subscript; 293, 294; 293, 295; 294, identifier:dict_top2; 295, identifier:y; 296, identifier:max_value; 297, expression_statement; 297, 298; 298, assignment; 298, 299; 298, 300; 299, identifier:known_winners; 300, binary_operator:|; 300, 301; 300, 302; 301, identifier:known_winners; 302, call; 302, 303; 302, 304; 303, identifier:set; 304, argument_list; 304, 305; 305, identifier:winners; 306, return_statement; 306, 307; 307, call; 307, 308; 307, 309; 308, identifier:sorted; 309, argument_list; 309, 310; 310, identifier:known_winners | def PluRunOff_cowinners(self, profile):
elecType = profile.getElecType()
if elecType != "soc" and elecType != "toc" and elecType != "csv":
print("ERROR: unsupported election type")
exit()
prefcounts = profile.getPreferenceCounts()
len_prefcounts = len(prefcounts)
rankmaps = profile.getRankMaps()
ranking = MechanismPlurality().getRanking(profile)
known_winners = set()
top_2_combinations = []
if len(ranking[0][0]) > 1:
for cand1, cand2 in itertools.combinations(ranking[0][0], 2):
top_2_combinations.append([cand1, cand2])
else:
max_cand = ranking[0][0][0]
if len(ranking[0][1]) > 1:
for second_max_cand in ranking[0][1]:
top_2_combinations.append([max_cand, second_max_cand])
else:
second_max_cand = ranking[0][1][0]
top_2_combinations.append([max_cand, second_max_cand])
for top_2 in top_2_combinations:
dict_top2 = {top_2[0]: 0, top_2[1]: 0}
for i in range(len_prefcounts):
vote_top2 = {key: value for key, value in rankmaps[i].items() if key in top_2}
top_position = min(vote_top2.values())
keys = [x for x in vote_top2.keys() if vote_top2[x] == top_position]
for key in keys:
dict_top2[key] += prefcounts[i]
max_value = max(dict_top2.values())
winners = [y for y in dict_top2.keys() if dict_top2[y] == max_value]
known_winners = known_winners | set(winners)
return sorted(known_winners) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:_cache_offsets; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:up_to_index; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:verbose; 10, True; 11, block; 11, 12; 11, 74; 11, 153; 11, 161; 11, 171; 12, if_statement; 12, 13; 12, 15; 12, 57; 13, not_operator; 13, 14; 14, identifier:up_to_index; 15, block; 15, 16; 15, 26; 15, 36; 15, 42; 16, if_statement; 16, 17; 16, 18; 17, identifier:verbose; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:print; 24, argument_list; 24, 25; 25, string:"Caching event file offsets, this may take a bit."; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:blob_file; 32, identifier:seek; 33, argument_list; 33, 34; 33, 35; 34, integer:0; 35, integer:0; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:event_offsets; 41, list:[]; 42, if_statement; 42, 43; 42, 47; 43, not_operator; 43, 44; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:raw_header; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:event_offsets; 54, identifier:append; 55, argument_list; 55, 56; 56, integer:0; 57, else_clause; 57, 58; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:blob_file; 65, identifier:seek; 66, argument_list; 66, 67; 66, 73; 67, subscript; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:event_offsets; 71, unary_operator:-; 71, 72; 72, integer:1; 73, integer:0; 74, for_statement; 74, 75; 74, 76; 74, 85; 75, identifier:line; 76, call; 76, 77; 76, 78; 77, identifier:iter; 78, argument_list; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:blob_file; 83, identifier:readline; 84, string:''; 85, block; 85, 86; 85, 93; 85, 138; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:line; 89, call; 89, 90; 89, 91; 90, identifier:try_decode_string; 91, argument_list; 91, 92; 92, identifier:line; 93, if_statement; 93, 94; 93, 100; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:line; 97, identifier:startswith; 98, argument_list; 98, 99; 99, string:'end_event:'; 100, block; 100, 101; 100, 107; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:self; 105, identifier:_record_offset; 106, argument_list; 107, if_statement; 107, 108; 107, 118; 108, comparison_operator:==; 108, 109; 108, 117; 109, binary_operator:%; 109, 110; 109, 116; 110, call; 110, 111; 110, 112; 111, identifier:len; 112, argument_list; 112, 113; 113, attribute; 113, 114; 113, 115; 114, identifier:self; 115, identifier:event_offsets; 116, integer:100; 117, integer:0; 118, block; 118, 119; 118, 130; 119, if_statement; 119, 120; 119, 121; 120, identifier:verbose; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, call; 123, 124; 123, 125; 124, identifier:print; 125, argument_list; 125, 126; 125, 127; 126, string:'.'; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:end; 129, string:''; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 137; 132, attribute; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:sys; 135, identifier:stdout; 136, identifier:flush; 137, argument_list; 138, if_statement; 138, 139; 138, 151; 139, boolean_operator:and; 139, 140; 139, 141; 140, identifier:up_to_index; 141, comparison_operator:>=; 141, 142; 141, 148; 142, call; 142, 143; 142, 144; 143, identifier:len; 144, argument_list; 144, 145; 145, attribute; 145, 146; 145, 147; 146, identifier:self; 147, identifier:event_offsets; 148, binary_operator:+; 148, 149; 148, 150; 149, identifier:up_to_index; 150, integer:1; 151, block; 151, 152; 152, return_statement; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:event_offsets; 159, identifier:pop; 160, argument_list; 161, if_statement; 161, 162; 161, 164; 162, not_operator; 162, 163; 163, identifier:up_to_index; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:whole_file_cached; 170, True; 171, expression_statement; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:print; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, string:"\n{0} events indexed."; 180, identifier:format; 181, argument_list; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:len; 184, argument_list; 184, 185; 185, attribute; 185, 186; 185, 187; 186, identifier:self; 187, identifier:event_offsets | def _cache_offsets(self, up_to_index=None, verbose=True):
if not up_to_index:
if verbose:
self.print("Caching event file offsets, this may take a bit.")
self.blob_file.seek(0, 0)
self.event_offsets = []
if not self.raw_header:
self.event_offsets.append(0)
else:
self.blob_file.seek(self.event_offsets[-1], 0)
for line in iter(self.blob_file.readline, ''):
line = try_decode_string(line)
if line.startswith('end_event:'):
self._record_offset()
if len(self.event_offsets) % 100 == 0:
if verbose:
print('.', end='')
sys.stdout.flush()
if up_to_index and len(self.event_offsets) >= up_to_index + 1:
return
self.event_offsets.pop()
if not up_to_index:
self.whole_file_cached = True
self.print("\n{0} events indexed.".format(len(self.event_offsets))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:getUtilities; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:decision; 6, identifier:binaryRelations; 7, block; 7, 8; 7, 15; 7, 19; 7, 134; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:m; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:binaryRelations; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:utilities; 18, list:[]; 19, for_statement; 19, 20; 19, 21; 19, 22; 20, identifier:cand; 21, identifier:decision; 22, block; 22, 23; 22, 30; 22, 34; 22, 86; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:tops; 26, list:[cand-1]; 26, 27; 27, binary_operator:-; 27, 28; 27, 29; 28, identifier:cand; 29, integer:1; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:index; 33, integer:0; 34, while_statement; 34, 35; 34, 41; 35, comparison_operator:<; 35, 36; 35, 37; 36, identifier:index; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:tops; 41, block; 41, 42; 41, 48; 41, 82; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:s; 45, subscript; 45, 46; 45, 47; 46, identifier:tops; 47, identifier:index; 48, for_statement; 48, 49; 48, 50; 48, 54; 49, identifier:j; 50, call; 50, 51; 50, 52; 51, identifier:range; 52, argument_list; 52, 53; 53, identifier:m; 54, block; 54, 55; 54, 61; 55, if_statement; 55, 56; 55, 59; 56, comparison_operator:==; 56, 57; 56, 58; 57, identifier:j; 58, identifier:s; 59, block; 59, 60; 60, continue_statement; 61, if_statement; 61, 62; 61, 69; 62, comparison_operator:>; 62, 63; 62, 68; 63, subscript; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:binaryRelations; 66, identifier:j; 67, identifier:s; 68, integer:0; 69, block; 69, 70; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:not; 71, 72; 71, 73; 72, identifier:j; 73, identifier:tops; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:tops; 79, identifier:append; 80, argument_list; 80, 81; 81, identifier:j; 82, expression_statement; 82, 83; 83, augmented_assignment:+=; 83, 84; 83, 85; 84, identifier:index; 85, integer:1; 86, if_statement; 86, 87; 86, 95; 86, 125; 87, comparison_operator:<=; 87, 88; 87, 92; 88, call; 88, 89; 88, 90; 89, identifier:len; 90, argument_list; 90, 91; 91, identifier:tops; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:k; 95, block; 95, 96; 96, if_statement; 96, 97; 96, 102; 96, 110; 97, comparison_operator:==; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:self; 100, identifier:isLoss; 101, False; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:utilities; 107, identifier:append; 108, argument_list; 108, 109; 109, float:1.0; 110, elif_clause; 110, 111; 110, 116; 111, comparison_operator:==; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:isLoss; 115, True; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:utilities; 121, identifier:append; 122, argument_list; 122, 123; 123, unary_operator:-; 123, 124; 124, float:1.0; 125, else_clause; 125, 126; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:utilities; 131, identifier:append; 132, argument_list; 132, 133; 133, float:0.0; 134, return_statement; 134, 135; 135, identifier:utilities | def getUtilities(self, decision, binaryRelations):
m = len(binaryRelations)
utilities = []
for cand in decision:
tops = [cand-1]
index = 0
while index < len(tops):
s = tops[index]
for j in range(m):
if j == s:
continue
if binaryRelations[j][s] > 0:
if j not in tops:
tops.append(j)
index += 1
if len(tops) <= self.k:
if self.isLoss == False:
utilities.append(1.0)
elif self.isLoss == True:
utilities.append(-1.0)
else:
utilities.append(0.0)
return utilities |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:execute; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:sources; 6, identifier:sink; 7, identifier:interval; 8, default_parameter; 8, 9; 8, 10; 9, identifier:alignment_stream; 10, None; 11, block; 11, 12; 11, 33; 11, 53; 11, 65; 12, if_statement; 12, 13; 12, 19; 13, not_operator; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:isinstance; 16, argument_list; 16, 17; 16, 18; 17, identifier:interval; 18, identifier:TimeInterval; 19, block; 19, 20; 20, raise_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:TypeError; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, string:'Expected TimeInterval, got {}'; 27, identifier:format; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:type; 31, argument_list; 31, 32; 32, identifier:interval; 33, if_statement; 33, 34; 33, 43; 34, comparison_operator:>; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:interval; 37, identifier:end; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:sink; 41, identifier:channel; 42, identifier:up_to_timestamp; 43, block; 43, 44; 44, raise_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:StreamNotAvailableError; 47, argument_list; 47, 48; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:sink; 51, identifier:channel; 52, identifier:up_to_timestamp; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:required_intervals; 56, binary_operator:-; 56, 57; 56, 62; 57, call; 57, 58; 57, 59; 58, identifier:TimeIntervals; 59, argument_list; 59, 60; 60, list:[interval]; 60, 61; 61, identifier:interval; 62, attribute; 62, 63; 62, 64; 63, identifier:sink; 64, identifier:calculated_intervals; 65, if_statement; 65, 66; 65, 70; 66, not_operator; 66, 67; 67, attribute; 67, 68; 67, 69; 68, identifier:required_intervals; 69, identifier:is_empty; 70, block; 70, 71; 70, 75; 70, 113; 70, 125; 70, 147; 70, 167; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:document_count; 74, integer:0; 75, for_statement; 75, 76; 75, 77; 75, 78; 76, identifier:interval; 77, identifier:required_intervals; 78, block; 78, 79; 78, 107; 79, for_statement; 79, 80; 79, 81; 79, 95; 80, identifier:stream_instance; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:self; 84, identifier:_execute; 85, argument_list; 85, 86; 85, 89; 85, 92; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:sources; 88, identifier:sources; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:alignment_stream; 91, identifier:alignment_stream; 92, keyword_argument; 92, 93; 92, 94; 93, identifier:interval; 94, identifier:interval; 95, block; 95, 96; 95, 103; 96, expression_statement; 96, 97; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:sink; 100, identifier:writer; 101, argument_list; 101, 102; 102, identifier:stream_instance; 103, expression_statement; 103, 104; 104, augmented_assignment:+=; 104, 105; 104, 106; 105, identifier:document_count; 106, integer:1; 107, expression_statement; 107, 108; 108, augmented_assignment:+=; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:sink; 111, identifier:calculated_intervals; 112, identifier:interval; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:required_intervals; 116, binary_operator:-; 116, 117; 116, 122; 117, call; 117, 118; 117, 119; 118, identifier:TimeIntervals; 119, argument_list; 119, 120; 120, list:[interval]; 120, 121; 121, identifier:interval; 122, attribute; 122, 123; 122, 124; 123, identifier:sink; 124, identifier:calculated_intervals; 125, if_statement; 125, 126; 125, 130; 126, not_operator; 126, 127; 127, attribute; 127, 128; 127, 129; 128, identifier:required_intervals; 129, identifier:is_empty; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:logging; 135, identifier:error; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, string:"{} execution error for time interval {} on stream {}"; 140, identifier:format; 141, argument_list; 141, 142; 141, 145; 141, 146; 142, attribute; 142, 143; 142, 144; 143, identifier:self; 144, identifier:name; 145, identifier:interval; 146, identifier:sink; 147, if_statement; 147, 148; 147, 150; 148, not_operator; 148, 149; 149, identifier:document_count; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:logging; 155, identifier:debug; 156, argument_list; 156, 157; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, string:"{} did not produce any data for time interval {} on stream {}"; 160, identifier:format; 161, argument_list; 161, 162; 161, 165; 161, 166; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:name; 165, identifier:interval; 166, identifier:sink; 167, expression_statement; 167, 168; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:self; 171, identifier:write_to_history; 172, argument_list; 172, 173; 172, 176; 172, 181; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:interval; 175, identifier:interval; 176, keyword_argument; 176, 177; 176, 178; 177, identifier:tool; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:name; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:document_count; 183, identifier:document_count | def execute(self, sources, sink, interval, alignment_stream=None):
if not isinstance(interval, TimeInterval):
raise TypeError('Expected TimeInterval, got {}'.format(type(interval)))
if interval.end > sink.channel.up_to_timestamp:
raise StreamNotAvailableError(sink.channel.up_to_timestamp)
required_intervals = TimeIntervals([interval]) - sink.calculated_intervals
if not required_intervals.is_empty:
document_count = 0
for interval in required_intervals:
for stream_instance in self._execute(
sources=sources, alignment_stream=alignment_stream, interval=interval):
sink.writer(stream_instance)
document_count += 1
sink.calculated_intervals += interval
required_intervals = TimeIntervals([interval]) - sink.calculated_intervals
if not required_intervals.is_empty:
logging.error("{} execution error for time interval {} on stream {}".format(
self.name, interval, sink))
if not document_count:
logging.debug("{} did not produce any data for time interval {} on stream {}".format(
self.name, interval, sink))
self.write_to_history(
interval=interval,
tool=self.name,
document_count=document_count
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:upload_runsummary; 3, parameters; 3, 4; 3, 5; 4, identifier:csv_filename; 5, default_parameter; 5, 6; 5, 7; 6, identifier:dryrun; 7, False; 8, block; 8, 9; 8, 19; 8, 43; 8, 75; 8, 84; 8, 119; 8, 125; 8, 141; 8, 157; 8, 178; 8, 183; 8, 203; 8, 213; 8, 230; 8, 235; 8, 245; 8, 286; 8, 298; 8, 309; 8, 314; 8, 335; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:print; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, string:"Checking '{}' for consistency."; 16, identifier:format; 17, argument_list; 17, 18; 18, identifier:csv_filename; 19, if_statement; 19, 20; 19, 29; 20, not_operator; 20, 21; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:os; 25, identifier:path; 26, identifier:exists; 27, argument_list; 27, 28; 28, identifier:csv_filename; 29, block; 29, 30; 29, 42; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:log; 34, identifier:critical; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, string:"{} -> file not found."; 39, identifier:format; 40, argument_list; 40, 41; 41, identifier:csv_filename; 42, return_statement; 43, try_statement; 43, 44; 43, 57; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:df; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:pd; 51, identifier:read_csv; 52, argument_list; 52, 53; 52, 54; 53, identifier:csv_filename; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:sep; 56, string:'\t'; 57, except_clause; 57, 58; 57, 66; 58, as_pattern; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:pd; 62, identifier:errors; 63, identifier:EmptyDataError; 64, as_pattern_target; 64, 65; 65, identifier:e; 66, block; 66, 67; 66, 74; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:log; 71, identifier:error; 72, argument_list; 72, 73; 73, identifier:e; 74, return_statement; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:cols; 78, call; 78, 79; 78, 80; 79, identifier:set; 80, argument_list; 80, 81; 81, attribute; 81, 82; 81, 83; 82, identifier:df; 83, identifier:columns; 84, if_statement; 84, 85; 84, 92; 85, not_operator; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:REQUIRED_COLUMNS; 89, identifier:issubset; 90, argument_list; 90, 91; 91, identifier:cols; 92, block; 92, 93; 92, 118; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:log; 97, identifier:error; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, string:"Missing columns: {}."; 102, identifier:format; 103, argument_list; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, string:', '; 107, identifier:join; 108, generator_expression; 108, 109; 108, 113; 109, call; 109, 110; 109, 111; 110, identifier:str; 111, argument_list; 111, 112; 112, identifier:c; 113, for_in_clause; 113, 114; 113, 115; 114, identifier:c; 115, binary_operator:-; 115, 116; 115, 117; 116, identifier:REQUIRED_COLUMNS; 117, identifier:cols; 118, return_statement; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:parameters; 122, binary_operator:-; 122, 123; 122, 124; 123, identifier:cols; 124, identifier:REQUIRED_COLUMNS; 125, if_statement; 125, 126; 125, 132; 126, comparison_operator:<; 126, 127; 126, 131; 127, call; 127, 128; 127, 129; 128, identifier:len; 129, argument_list; 129, 130; 130, identifier:parameters; 131, integer:1; 132, block; 132, 133; 132, 140; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:log; 137, identifier:error; 138, argument_list; 138, 139; 139, string:"No parameter columns found."; 140, return_statement; 141, if_statement; 141, 142; 141, 148; 142, comparison_operator:==; 142, 143; 142, 147; 143, call; 143, 144; 143, 145; 144, identifier:len; 145, argument_list; 145, 146; 146, identifier:df; 147, integer:0; 148, block; 148, 149; 148, 156; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:log; 153, identifier:critical; 154, argument_list; 154, 155; 155, string:"Empty dataset."; 156, return_statement; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:print; 160, argument_list; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, string:"Found data for parameters: {}."; 164, identifier:format; 165, argument_list; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, string:', '; 169, identifier:join; 170, generator_expression; 170, 171; 170, 175; 171, call; 171, 172; 171, 173; 172, identifier:str; 173, argument_list; 173, 174; 174, identifier:c; 175, for_in_clause; 175, 176; 175, 177; 176, identifier:c; 177, identifier:parameters; 178, expression_statement; 178, 179; 179, call; 179, 180; 179, 181; 180, identifier:print; 181, argument_list; 181, 182; 182, string:"Converting CSV data into JSON"; 183, if_statement; 183, 184; 183, 185; 183, 197; 184, identifier:dryrun; 185, block; 185, 186; 185, 193; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:log; 190, identifier:warn; 191, argument_list; 191, 192; 192, string:"Dryrun: adding 'TEST_' prefix to parameter names"; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:prefix; 196, string:"TEST_"; 197, else_clause; 197, 198; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:prefix; 202, string:""; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:data; 206, call; 206, 207; 206, 208; 207, identifier:convert_runsummary_to_json; 208, argument_list; 208, 209; 208, 210; 209, identifier:df; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:prefix; 212, identifier:prefix; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:print; 216, argument_list; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, string:"We have {:.3f} MB to upload."; 220, identifier:format; 221, argument_list; 221, 222; 222, binary_operator:/; 222, 223; 222, 227; 223, call; 223, 224; 223, 225; 224, identifier:len; 225, argument_list; 225, 226; 226, identifier:data; 227, binary_operator:**; 227, 228; 227, 229; 228, integer:1024; 229, integer:2; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 233; 232, identifier:print; 233, argument_list; 233, 234; 234, string:"Requesting database session."; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 238; 237, identifier:db; 238, call; 238, 239; 238, 244; 239, attribute; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:kp; 242, identifier:db; 243, identifier:DBManager; 244, argument_list; 245, if_statement; 245, 246; 245, 253; 245, 258; 246, call; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:kp; 250, identifier:db; 251, identifier:we_are_in_lyon; 252, argument_list; 253, block; 253, 254; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:session_cookie; 257, string:"sid=_kmcprod_134.158_lyo7783844001343100343mcprod1223user"; 258, else_clause; 258, 259; 259, block; 259, 260; 259, 276; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:session_cookie; 263, call; 263, 264; 263, 273; 264, attribute; 264, 265; 264, 272; 265, call; 265, 266; 265, 271; 266, attribute; 266, 267; 266, 270; 267, attribute; 267, 268; 267, 269; 268, identifier:kp; 269, identifier:config; 270, identifier:Config; 271, argument_list; 272, identifier:get; 273, argument_list; 273, 274; 273, 275; 274, string:'DB'; 275, string:'session_cookie'; 276, if_statement; 276, 277; 276, 280; 277, comparison_operator:is; 277, 278; 277, 279; 278, identifier:session_cookie; 279, None; 280, block; 280, 281; 281, raise_statement; 281, 282; 282, call; 282, 283; 282, 284; 283, identifier:SystemExit; 284, argument_list; 284, 285; 285, string:"Could not restore DB session."; 286, expression_statement; 286, 287; 287, call; 287, 288; 287, 291; 288, attribute; 288, 289; 288, 290; 289, identifier:log; 290, identifier:debug; 291, argument_list; 291, 292; 292, call; 292, 293; 292, 296; 293, attribute; 293, 294; 293, 295; 294, string:"Using the session cookie: {}"; 295, identifier:format; 296, argument_list; 296, 297; 297, identifier:session_cookie; 298, expression_statement; 298, 299; 299, assignment; 299, 300; 299, 303; 300, pattern_list; 300, 301; 300, 302; 301, identifier:cookie_key; 302, identifier:sid; 303, call; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:session_cookie; 306, identifier:split; 307, argument_list; 307, 308; 308, string:'='; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 312; 311, identifier:print; 312, argument_list; 312, 313; 313, string:"Uploading the data to the database."; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:r; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:requests; 320, identifier:post; 321, argument_list; 321, 322; 321, 323; 321, 329; 322, identifier:RUNSUMMARY_URL; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:cookies; 325, dictionary; 325, 326; 326, pair; 326, 327; 326, 328; 327, identifier:cookie_key; 328, identifier:sid; 329, keyword_argument; 329, 330; 329, 331; 330, identifier:files; 331, dictionary; 331, 332; 332, pair; 332, 333; 332, 334; 333, string:'datafile'; 334, identifier:data; 335, if_statement; 335, 336; 335, 341; 335, 414; 336, comparison_operator:==; 336, 337; 336, 340; 337, attribute; 337, 338; 337, 339; 338, identifier:r; 339, identifier:status_code; 340, integer:200; 341, block; 341, 342; 341, 356; 341, 361; 341, 372; 341, 393; 342, expression_statement; 342, 343; 343, call; 343, 344; 343, 347; 344, attribute; 344, 345; 344, 346; 345, identifier:log; 346, identifier:debug; 347, argument_list; 347, 348; 348, call; 348, 349; 348, 352; 349, attribute; 349, 350; 349, 351; 350, string:"POST request status code: {}"; 351, identifier:format; 352, argument_list; 352, 353; 353, attribute; 353, 354; 353, 355; 354, identifier:r; 355, identifier:status_code; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 359; 358, identifier:print; 359, argument_list; 359, 360; 360, string:"Database response:"; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 364; 363, identifier:db_answer; 364, call; 364, 365; 364, 368; 365, attribute; 365, 366; 365, 367; 366, identifier:json; 367, identifier:loads; 368, argument_list; 368, 369; 369, attribute; 369, 370; 369, 371; 370, identifier:r; 371, identifier:text; 372, for_statement; 372, 373; 372, 376; 372, 381; 373, pattern_list; 373, 374; 373, 375; 374, identifier:key; 375, identifier:value; 376, call; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:db_answer; 379, identifier:items; 380, argument_list; 381, block; 381, 382; 382, expression_statement; 382, 383; 383, call; 383, 384; 383, 385; 384, identifier:print; 385, argument_list; 385, 386; 386, call; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, string:" -> {}: {}"; 389, identifier:format; 390, argument_list; 390, 391; 390, 392; 391, identifier:key; 392, identifier:value; 393, if_statement; 393, 394; 393, 399; 393, 405; 394, comparison_operator:==; 394, 395; 394, 398; 395, subscript; 395, 396; 395, 397; 396, identifier:db_answer; 397, string:'Result'; 398, string:'OK'; 399, block; 399, 400; 400, expression_statement; 400, 401; 401, call; 401, 402; 401, 403; 402, identifier:print; 403, argument_list; 403, 404; 404, string:"Upload successful."; 405, else_clause; 405, 406; 406, block; 406, 407; 407, expression_statement; 407, 408; 408, call; 408, 409; 408, 412; 409, attribute; 409, 410; 409, 411; 410, identifier:log; 411, identifier:critical; 412, argument_list; 412, 413; 413, string:"Something went wrong."; 414, else_clause; 414, 415; 415, block; 415, 416; 415, 430; 415, 437; 416, expression_statement; 416, 417; 417, call; 417, 418; 417, 421; 418, attribute; 418, 419; 418, 420; 419, identifier:log; 420, identifier:error; 421, argument_list; 421, 422; 422, call; 422, 423; 422, 426; 423, attribute; 423, 424; 423, 425; 424, string:"POST request status code: {}"; 425, identifier:format; 426, argument_list; 426, 427; 427, attribute; 427, 428; 427, 429; 428, identifier:r; 429, identifier:status_code; 430, expression_statement; 430, 431; 431, call; 431, 432; 431, 435; 432, attribute; 432, 433; 432, 434; 433, identifier:log; 434, identifier:critical; 435, argument_list; 435, 436; 436, string:"Something went wrong..."; 437, return_statement | def upload_runsummary(csv_filename, dryrun=False):
print("Checking '{}' for consistency.".format(csv_filename))
if not os.path.exists(csv_filename):
log.critical("{} -> file not found.".format(csv_filename))
return
try:
df = pd.read_csv(csv_filename, sep='\t')
except pd.errors.EmptyDataError as e:
log.error(e)
return
cols = set(df.columns)
if not REQUIRED_COLUMNS.issubset(cols):
log.error(
"Missing columns: {}.".format(
', '.join(str(c) for c in REQUIRED_COLUMNS - cols)
)
)
return
parameters = cols - REQUIRED_COLUMNS
if len(parameters) < 1:
log.error("No parameter columns found.")
return
if len(df) == 0:
log.critical("Empty dataset.")
return
print(
"Found data for parameters: {}.".format(
', '.join(str(c) for c in parameters)
)
)
print("Converting CSV data into JSON")
if dryrun:
log.warn("Dryrun: adding 'TEST_' prefix to parameter names")
prefix = "TEST_"
else:
prefix = ""
data = convert_runsummary_to_json(df, prefix=prefix)
print("We have {:.3f} MB to upload.".format(len(data) / 1024**2))
print("Requesting database session.")
db = kp.db.DBManager()
if kp.db.we_are_in_lyon():
session_cookie = "sid=_kmcprod_134.158_lyo7783844001343100343mcprod1223user"
else:
session_cookie = kp.config.Config().get('DB', 'session_cookie')
if session_cookie is None:
raise SystemExit("Could not restore DB session.")
log.debug("Using the session cookie: {}".format(session_cookie))
cookie_key, sid = session_cookie.split('=')
print("Uploading the data to the database.")
r = requests.post(
RUNSUMMARY_URL, cookies={cookie_key: sid}, files={'datafile': data}
)
if r.status_code == 200:
log.debug("POST request status code: {}".format(r.status_code))
print("Database response:")
db_answer = json.loads(r.text)
for key, value in db_answer.items():
print(" -> {}: {}".format(key, value))
if db_answer['Result'] == 'OK':
print("Upload successful.")
else:
log.critical("Something went wrong.")
else:
log.error("POST request status code: {}".format(r.status_code))
log.critical("Something went wrong...")
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_movie; 3, parameters; 3, 4; 4, identifier:tmdb_id; 5, block; 5, 6; 5, 12; 5, 21; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:redis_key; 9, binary_operator:%; 9, 10; 9, 11; 10, string:'m_%s'; 11, identifier:tmdb_id; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:cached; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:redis_ro_conn; 18, identifier:get; 19, argument_list; 19, 20; 20, identifier:redis_key; 21, if_statement; 21, 22; 21, 23; 21, 29; 22, identifier:cached; 23, block; 23, 24; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:Response; 27, argument_list; 27, 28; 28, identifier:cached; 29, else_clause; 29, 30; 30, block; 30, 31; 30, 85; 30, 192; 30, 216; 30, 234; 30, 256; 30, 268; 30, 281; 31, try_statement; 31, 32; 31, 60; 32, block; 32, 33; 32, 42; 32, 51; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:details; 36, call; 36, 37; 36, 38; 37, identifier:get_on_tmdb; 38, argument_list; 38, 39; 39, binary_operator:%; 39, 40; 39, 41; 40, string:u'/movie/%d'; 41, identifier:tmdb_id; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:cast; 45, call; 45, 46; 45, 47; 46, identifier:get_on_tmdb; 47, argument_list; 47, 48; 48, binary_operator:%; 48, 49; 48, 50; 49, string:u'/movie/%d/casts'; 50, identifier:tmdb_id; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:alternative; 54, call; 54, 55; 54, 56; 55, identifier:get_on_tmdb; 56, argument_list; 56, 57; 57, binary_operator:%; 57, 58; 57, 59; 58, string:u'/movie/%d/alternative_titles'; 59, identifier:tmdb_id; 60, except_clause; 60, 61; 60, 67; 61, as_pattern; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:requests; 64, identifier:HTTPError; 65, as_pattern_target; 65, 66; 66, identifier:err; 67, block; 67, 68; 68, return_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:Response; 71, argument_list; 71, 72; 71, 78; 72, binary_operator:%; 72, 73; 72, 74; 73, string:'TMDB API error: %s'; 74, call; 74, 75; 74, 76; 75, identifier:str; 76, argument_list; 76, 77; 77, identifier:err; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:status; 80, attribute; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:err; 83, identifier:response; 84, identifier:status_code; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:movie; 88, dictionary; 88, 89; 88, 94; 88, 99; 88, 122; 88, 139; 88, 150; 88, 161; 88, 172; 88, 189; 89, pair; 89, 90; 89, 91; 90, string:'title'; 91, subscript; 91, 92; 91, 93; 92, identifier:details; 93, string:'original_title'; 94, pair; 94, 95; 94, 96; 95, string:'score'; 96, subscript; 96, 97; 96, 98; 97, identifier:details; 98, string:'popularity'; 99, pair; 99, 100; 99, 101; 100, string:'directors'; 101, list_comprehension; 101, 102; 101, 105; 101, 110; 102, subscript; 102, 103; 102, 104; 103, identifier:x; 104, string:'name'; 105, for_in_clause; 105, 106; 105, 107; 106, identifier:x; 107, subscript; 107, 108; 107, 109; 108, identifier:cast; 109, string:'crew'; 110, if_clause; 110, 111; 111, boolean_operator:and; 111, 112; 111, 117; 112, comparison_operator:==; 112, 113; 112, 116; 113, subscript; 113, 114; 113, 115; 114, identifier:x; 115, string:'department'; 116, string:'Directing'; 117, comparison_operator:==; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:x; 120, string:'job'; 121, string:'Director'; 122, pair; 122, 123; 122, 124; 123, string:'writers'; 124, list_comprehension; 124, 125; 124, 128; 124, 133; 125, subscript; 125, 126; 125, 127; 126, identifier:x; 127, string:'name'; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:x; 130, subscript; 130, 131; 130, 132; 131, identifier:cast; 132, string:'crew'; 133, if_clause; 133, 134; 134, comparison_operator:==; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:x; 137, string:'department'; 138, string:'Writing'; 139, pair; 139, 140; 139, 141; 140, string:'cast'; 141, list_comprehension; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:x; 144, string:'name'; 145, for_in_clause; 145, 146; 145, 147; 146, identifier:x; 147, subscript; 147, 148; 147, 149; 148, identifier:cast; 149, string:'cast'; 150, pair; 150, 151; 150, 152; 151, string:'genres'; 152, list_comprehension; 152, 153; 152, 156; 153, subscript; 153, 154; 153, 155; 154, identifier:x; 155, string:'name'; 156, for_in_clause; 156, 157; 156, 158; 157, identifier:x; 158, subscript; 158, 159; 158, 160; 159, identifier:details; 160, string:'genres'; 161, pair; 161, 162; 161, 163; 162, string:'countries'; 163, list_comprehension; 163, 164; 163, 167; 164, subscript; 164, 165; 164, 166; 165, identifier:x; 166, string:'name'; 167, for_in_clause; 167, 168; 167, 169; 168, identifier:x; 169, subscript; 169, 170; 169, 171; 170, identifier:details; 171, string:'production_countries'; 172, pair; 172, 173; 172, 174; 173, string:'tmdb_votes'; 174, call; 174, 175; 174, 176; 175, identifier:int; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:round; 179, argument_list; 179, 180; 180, binary_operator:*; 180, 181; 180, 188; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:details; 184, identifier:get; 185, argument_list; 185, 186; 185, 187; 186, string:'vote_average'; 187, integer:0; 188, float:0.5; 189, pair; 189, 190; 189, 191; 190, string:'_tmdb_id'; 191, identifier:tmdb_id; 192, if_statement; 192, 193; 192, 199; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:details; 196, identifier:get; 197, argument_list; 197, 198; 198, string:'release_date'; 199, block; 199, 200; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 205; 202, subscript; 202, 203; 202, 204; 203, identifier:movie; 204, string:'year'; 205, attribute; 205, 206; 205, 215; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:datetime; 209, identifier:strptime; 210, argument_list; 210, 211; 210, 214; 211, subscript; 211, 212; 211, 213; 212, identifier:details; 213, string:'release_date'; 214, string:'%Y-%m-%d'; 215, identifier:year; 216, if_statement; 216, 217; 216, 223; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:details; 220, identifier:get; 221, argument_list; 221, 222; 222, string:'belongs_to_collection'; 223, block; 223, 224; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 229; 226, subscript; 226, 227; 226, 228; 227, identifier:movie; 228, string:'collection'; 229, subscript; 229, 230; 229, 233; 230, subscript; 230, 231; 230, 232; 231, identifier:details; 232, string:'belongs_to_collection'; 233, string:'name'; 234, for_statement; 234, 235; 234, 236; 234, 239; 235, identifier:alt; 236, subscript; 236, 237; 236, 238; 237, identifier:alternative; 238, string:'titles'; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 253; 242, subscript; 242, 243; 242, 244; 243, identifier:movie; 244, binary_operator:%; 244, 245; 244, 246; 245, string:'title_%s'; 246, call; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, subscript; 248, 249; 248, 250; 249, identifier:alt; 250, string:'iso_3166_1'; 251, identifier:lower; 252, argument_list; 253, subscript; 253, 254; 253, 255; 254, identifier:alt; 255, string:'title'; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:json_response; 259, call; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:json; 262, identifier:dumps; 263, argument_list; 263, 264; 264, dictionary; 264, 265; 265, pair; 265, 266; 265, 267; 266, string:'movie'; 267, identifier:movie; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:redis_conn; 272, identifier:setex; 273, argument_list; 273, 274; 273, 275; 273, 280; 274, identifier:redis_key; 275, subscript; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:app; 278, identifier:config; 279, string:'CACHE_TTL'; 280, identifier:json_response; 281, return_statement; 281, 282; 282, call; 282, 283; 282, 284; 283, identifier:Response; 284, argument_list; 284, 285; 285, identifier:json_response | def get_movie(tmdb_id):
redis_key = 'm_%s' % tmdb_id
cached = redis_ro_conn.get(redis_key)
if cached:
return Response(cached)
else:
try:
details = get_on_tmdb(u'/movie/%d' % tmdb_id)
cast = get_on_tmdb(u'/movie/%d/casts' % tmdb_id)
alternative = get_on_tmdb(u'/movie/%d/alternative_titles' % tmdb_id)
except requests.HTTPError as err:
return Response('TMDB API error: %s' % str(err), status=err.response.status_code)
movie = {'title': details['original_title'],
'score': details['popularity'],
'directors': [x['name'] for x in cast['crew'] if x['department'] == 'Directing' and x['job'] == 'Director'],
'writers': [x['name'] for x in cast['crew'] if x['department'] == 'Writing'],
'cast': [x['name'] for x in cast['cast']],
'genres': [x['name'] for x in details['genres']],
'countries': [x['name'] for x in details['production_countries']],
'tmdb_votes': int(round(details.get('vote_average', 0) * 0.5)),
'_tmdb_id': tmdb_id}
if details.get('release_date'):
movie['year'] = datetime.strptime(details['release_date'], '%Y-%m-%d').year
if details.get('belongs_to_collection'):
movie['collection'] = details['belongs_to_collection']['name']
for alt in alternative['titles']:
movie['title_%s' % alt['iso_3166_1'].lower()] = alt['title']
json_response = json.dumps({'movie': movie})
redis_conn.setex(redis_key, app.config['CACHE_TTL'], json_response)
return Response(json_response) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:parse_pattern; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:format_string; 5, identifier:env; 6, default_parameter; 6, 7; 6, 8; 7, identifier:wrapper; 8, lambda; 8, 9; 8, 12; 9, lambda_parameters; 9, 10; 9, 11; 10, identifier:x; 11, identifier:y; 12, identifier:y; 13, block; 13, 14; 13, 20; 13, 41; 13, 45; 13, 136; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:formatter; 17, call; 17, 18; 17, 19; 18, identifier:Formatter; 19, argument_list; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:fields; 23, list_comprehension; 23, 24; 23, 27; 23, 35; 24, subscript; 24, 25; 24, 26; 25, identifier:x; 26, integer:1; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:x; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:formatter; 32, identifier:parse; 33, argument_list; 33, 34; 34, identifier:format_string; 35, if_clause; 35, 36; 36, comparison_operator:is; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:x; 39, integer:1; 40, None; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:prepared_env; 44, dictionary; 45, for_statement; 45, 46; 45, 47; 45, 48; 46, identifier:field; 47, identifier:fields; 48, block; 48, 49; 48, 113; 48, 126; 49, for_statement; 49, 50; 49, 51; 49, 65; 49, 107; 50, identifier:field_alt; 51, generator_expression; 51, 52; 51, 57; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:x; 55, identifier:strip; 56, argument_list; 57, for_in_clause; 57, 58; 57, 59; 58, identifier:x; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:field; 62, identifier:split; 63, argument_list; 63, 64; 64, string:'|'; 65, block; 65, 66; 65, 101; 66, if_statement; 66, 67; 66, 79; 66, 90; 67, boolean_operator:and; 67, 68; 67, 73; 68, comparison_operator:in; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:field_alt; 71, integer:0; 72, string:'\'"'; 73, comparison_operator:in; 73, 74; 73, 78; 74, subscript; 74, 75; 74, 76; 75, identifier:field_alt; 76, unary_operator:-; 76, 77; 77, integer:1; 78, string:'\'"'; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:field_values; 83, subscript; 83, 84; 83, 85; 84, identifier:field_alt; 85, slice; 85, 86; 85, 87; 85, 88; 86, integer:1; 87, colon; 88, unary_operator:-; 88, 89; 89, integer:1; 90, else_clause; 90, 91; 91, block; 91, 92; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:field_values; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:env; 98, identifier:get; 99, argument_list; 99, 100; 100, identifier:field_alt; 101, if_statement; 101, 102; 101, 105; 102, comparison_operator:is; 102, 103; 102, 104; 103, identifier:field_values; 104, None; 105, block; 105, 106; 106, break_statement; 107, else_clause; 107, 108; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:field_values; 112, list:[]; 113, if_statement; 113, 114; 113, 120; 114, not_operator; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:isinstance; 117, argument_list; 117, 118; 117, 119; 118, identifier:field_values; 119, identifier:list; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:field_values; 124, list:[field_values]; 124, 125; 125, identifier:field_values; 126, expression_statement; 126, 127; 127, assignment; 127, 128; 127, 131; 128, subscript; 128, 129; 128, 130; 129, identifier:prepared_env; 130, identifier:field; 131, call; 131, 132; 131, 133; 132, identifier:wrapper; 133, argument_list; 133, 134; 133, 135; 134, identifier:field_alt; 135, identifier:field_values; 136, return_statement; 136, 137; 137, identifier:prepared_env | def parse_pattern(format_string, env, wrapper=lambda x, y: y):
formatter = Formatter()
fields = [x[1] for x in formatter.parse(format_string) if x[1] is not None]
prepared_env = {}
for field in fields:
for field_alt in (x.strip() for x in field.split('|')):
if field_alt[0] in '\'"' and field_alt[-1] in '\'"':
field_values = field_alt[1:-1]
else:
field_values = env.get(field_alt)
if field_values is not None:
break
else:
field_values = []
if not isinstance(field_values, list):
field_values = [field_values]
prepared_env[field] = wrapper(field_alt, field_values)
return prepared_env |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:calibrate_dom; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, identifier:dom_id; 5, identifier:data; 6, identifier:detector; 7, default_parameter; 7, 8; 7, 9; 8, identifier:livetime; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:fit_ang_dist; 12, False; 13, default_parameter; 13, 14; 13, 15; 14, identifier:scale_mc_to_data; 15, True; 16, default_parameter; 16, 17; 16, 18; 17, identifier:ad_fit_shape; 18, string:'pexp'; 19, default_parameter; 19, 20; 19, 21; 20, identifier:fit_background; 21, True; 22, default_parameter; 22, 23; 22, 24; 23, identifier:ctmin; 24, unary_operator:-; 24, 25; 25, float:1.; 26, block; 26, 27; 26, 89; 26, 108; 26, 116; 26, 125; 26, 133; 26, 141; 26, 149; 26, 175; 26, 195; 26, 199; 26, 290; 26, 308; 26, 317; 26, 326; 26, 336; 26, 347; 26, 358; 26, 368; 26, 379; 26, 388; 26, 455; 27, if_statement; 27, 28; 27, 33; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:data; 32, identifier:str; 33, block; 33, 34; 33, 38; 33, 48; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:filename; 37, identifier:data; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:loaders; 41, dictionary; 41, 42; 41, 45; 42, pair; 42, 43; 42, 44; 43, string:'.h5'; 44, identifier:load_k40_coincidences_from_hdf5; 45, pair; 45, 46; 45, 47; 46, string:'.root'; 47, identifier:load_k40_coincidences_from_rootfile; 48, try_statement; 48, 49; 48, 65; 48, 77; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:loader; 53, subscript; 53, 54; 53, 55; 54, identifier:loaders; 55, subscript; 55, 56; 55, 64; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:os; 60, identifier:path; 61, identifier:splitext; 62, argument_list; 62, 63; 63, identifier:filename; 64, integer:1; 65, except_clause; 65, 66; 65, 67; 66, identifier:KeyError; 67, block; 67, 68; 67, 75; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:log; 72, identifier:critical; 73, argument_list; 73, 74; 74, string:'File format not supported.'; 75, raise_statement; 75, 76; 76, identifier:IOError; 77, else_clause; 77, 78; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, pattern_list; 81, 82; 81, 83; 82, identifier:data; 83, identifier:livetime; 84, call; 84, 85; 84, 86; 85, identifier:loader; 86, argument_list; 86, 87; 86, 88; 87, identifier:filename; 88, identifier:dom_id; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:combs; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:np; 95, identifier:array; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:list; 99, argument_list; 99, 100; 100, call; 100, 101; 100, 102; 101, identifier:combinations; 102, argument_list; 102, 103; 102, 107; 103, call; 103, 104; 103, 105; 104, identifier:range; 105, argument_list; 105, 106; 106, integer:31; 107, integer:2; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:angles; 111, call; 111, 112; 111, 113; 112, identifier:calculate_angles; 113, argument_list; 113, 114; 113, 115; 114, identifier:detector; 115, identifier:combs; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:cos_angles; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:np; 122, identifier:cos; 123, argument_list; 123, 124; 124, identifier:angles; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:angles; 128, subscript; 128, 129; 128, 130; 129, identifier:angles; 130, comparison_operator:>=; 130, 131; 130, 132; 131, identifier:cos_angles; 132, identifier:ctmin; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:data; 136, subscript; 136, 137; 136, 138; 137, identifier:data; 138, comparison_operator:>=; 138, 139; 138, 140; 139, identifier:cos_angles; 140, identifier:ctmin; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:combs; 144, subscript; 144, 145; 144, 146; 145, identifier:combs; 146, comparison_operator:>=; 146, 147; 146, 148; 147, identifier:cos_angles; 148, identifier:ctmin; 149, try_statement; 149, 150; 149, 171; 150, block; 150, 151; 150, 162; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:fit_res; 154, call; 154, 155; 154, 156; 155, identifier:fit_delta_ts; 156, argument_list; 156, 157; 156, 158; 156, 159; 157, identifier:data; 158, identifier:livetime; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:fit_background; 161, identifier:fit_background; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 170; 164, pattern_list; 164, 165; 164, 166; 164, 167; 164, 168; 164, 169; 165, identifier:rates; 166, identifier:means; 167, identifier:sigmas; 168, identifier:popts; 169, identifier:pcovs; 170, identifier:fit_res; 171, except_clause; 171, 172; 172, block; 172, 173; 173, return_statement; 173, 174; 174, integer:0; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:rate_errors; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:np; 181, identifier:array; 182, argument_list; 182, 183; 183, list_comprehension; 183, 184; 183, 192; 184, subscript; 184, 185; 184, 191; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:np; 188, identifier:diag; 189, argument_list; 189, 190; 190, identifier:pc; 191, integer:2; 192, for_in_clause; 192, 193; 192, 194; 193, identifier:pc; 194, identifier:pcovs; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:scale_factor; 198, None; 199, if_statement; 199, 200; 199, 201; 199, 221; 200, identifier:fit_ang_dist; 201, block; 201, 202; 201, 214; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:fit_res; 205, call; 205, 206; 205, 207; 206, identifier:fit_angular_distribution; 207, argument_list; 207, 208; 207, 209; 207, 210; 207, 211; 208, identifier:angles; 209, identifier:rates; 210, identifier:rate_errors; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:shape; 213, identifier:ad_fit_shape; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 220; 216, pattern_list; 216, 217; 216, 218; 216, 219; 217, identifier:fitted_rates; 218, identifier:exp_popts; 219, identifier:exp_pcov; 220, identifier:fit_res; 221, else_clause; 221, 222; 222, block; 222, 223; 222, 237; 222, 271; 222, 277; 222, 281; 222, 285; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:mc_fitted_rates; 226, call; 226, 227; 226, 228; 227, identifier:exponential_polinomial; 228, argument_list; 228, 229; 228, 235; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:np; 232, identifier:cos; 233, argument_list; 233, 234; 234, identifier:angles; 235, list_splat; 235, 236; 236, identifier:MC_ANG_DIST; 237, if_statement; 237, 238; 237, 239; 237, 265; 238, identifier:scale_mc_to_data; 239, block; 239, 240; 240, expression_statement; 240, 241; 241, assignment; 241, 242; 241, 243; 242, identifier:scale_factor; 243, binary_operator:/; 243, 244; 243, 254; 243, 255; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:np; 247, identifier:mean; 248, argument_list; 248, 249; 249, subscript; 249, 250; 249, 251; 250, identifier:rates; 251, comparison_operator:<; 251, 252; 251, 253; 252, identifier:angles; 253, float:1.5; 254, line_continuation:\; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:np; 258, identifier:mean; 259, argument_list; 259, 260; 260, subscript; 260, 261; 260, 262; 261, identifier:mc_fitted_rates; 262, comparison_operator:<; 262, 263; 262, 264; 263, identifier:angles; 264, float:1.5; 265, else_clause; 265, 266; 266, block; 266, 267; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:scale_factor; 270, float:1.; 271, expression_statement; 271, 272; 272, assignment; 272, 273; 272, 274; 273, identifier:fitted_rates; 274, binary_operator:*; 274, 275; 274, 276; 275, identifier:mc_fitted_rates; 276, identifier:scale_factor; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:exp_popts; 280, list:[]; 281, expression_statement; 281, 282; 282, assignment; 282, 283; 282, 284; 283, identifier:exp_pcov; 284, list:[]; 285, expression_statement; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:print; 288, argument_list; 288, 289; 289, string:'Using angular distribution from Monte Carlo'; 290, if_statement; 290, 291; 290, 293; 290, 302; 291, not_operator; 291, 292; 292, identifier:fit_background; 293, block; 293, 294; 294, expression_statement; 294, 295; 295, assignment; 295, 296; 295, 297; 296, identifier:minimize_weights; 297, call; 297, 298; 297, 299; 298, identifier:calculate_weights; 299, argument_list; 299, 300; 299, 301; 300, identifier:fitted_rates; 301, identifier:data; 302, else_clause; 302, 303; 303, block; 303, 304; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:minimize_weights; 307, identifier:fitted_rates; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:opt_t0s; 311, call; 311, 312; 311, 313; 312, identifier:minimize_t0s; 313, argument_list; 313, 314; 313, 315; 313, 316; 314, identifier:means; 315, identifier:minimize_weights; 316, identifier:combs; 317, expression_statement; 317, 318; 318, assignment; 318, 319; 318, 320; 319, identifier:opt_sigmas; 320, call; 320, 321; 320, 322; 321, identifier:minimize_sigmas; 322, argument_list; 322, 323; 322, 324; 322, 325; 323, identifier:sigmas; 324, identifier:minimize_weights; 325, identifier:combs; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 329; 328, identifier:opt_qes; 329, call; 329, 330; 329, 331; 330, identifier:minimize_qes; 331, argument_list; 331, 332; 331, 333; 331, 334; 331, 335; 332, identifier:fitted_rates; 333, identifier:rates; 334, identifier:minimize_weights; 335, identifier:combs; 336, expression_statement; 336, 337; 337, assignment; 337, 338; 337, 339; 338, identifier:corrected_means; 339, call; 339, 340; 339, 341; 340, identifier:correct_means; 341, argument_list; 341, 342; 341, 343; 341, 346; 342, identifier:means; 343, attribute; 343, 344; 343, 345; 344, identifier:opt_t0s; 345, identifier:x; 346, identifier:combs; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:corrected_rates; 350, call; 350, 351; 350, 352; 351, identifier:correct_rates; 352, argument_list; 352, 353; 352, 354; 352, 357; 353, identifier:rates; 354, attribute; 354, 355; 354, 356; 355, identifier:opt_qes; 356, identifier:x; 357, identifier:combs; 358, expression_statement; 358, 359; 359, assignment; 359, 360; 359, 363; 360, pattern_list; 360, 361; 360, 362; 361, identifier:rms_means; 362, identifier:rms_corrected_means; 363, call; 363, 364; 363, 365; 364, identifier:calculate_rms_means; 365, argument_list; 365, 366; 365, 367; 366, identifier:means; 367, identifier:corrected_means; 368, expression_statement; 368, 369; 369, assignment; 369, 370; 369, 373; 370, pattern_list; 370, 371; 370, 372; 371, identifier:rms_rates; 372, identifier:rms_corrected_rates; 373, call; 373, 374; 373, 375; 374, identifier:calculate_rms_rates; 375, argument_list; 375, 376; 375, 377; 375, 378; 376, identifier:rates; 377, identifier:fitted_rates; 378, identifier:corrected_rates; 379, expression_statement; 379, 380; 380, assignment; 380, 381; 380, 382; 381, identifier:cos_angles; 382, call; 382, 383; 382, 386; 383, attribute; 383, 384; 383, 385; 384, identifier:np; 385, identifier:cos; 386, argument_list; 386, 387; 387, identifier:angles; 388, expression_statement; 388, 389; 389, assignment; 389, 390; 389, 391; 390, identifier:return_data; 391, dictionary; 391, 392; 391, 395; 391, 398; 391, 401; 391, 404; 391, 407; 391, 410; 391, 413; 391, 416; 391, 419; 391, 422; 391, 425; 391, 428; 391, 431; 391, 434; 391, 437; 391, 440; 391, 443; 391, 446; 391, 449; 391, 452; 392, pair; 392, 393; 392, 394; 393, string:'opt_t0s'; 394, identifier:opt_t0s; 395, pair; 395, 396; 395, 397; 396, string:'opt_qes'; 397, identifier:opt_qes; 398, pair; 398, 399; 398, 400; 399, string:'data'; 400, identifier:data; 401, pair; 401, 402; 401, 403; 402, string:'means'; 403, identifier:means; 404, pair; 404, 405; 404, 406; 405, string:'rates'; 406, identifier:rates; 407, pair; 407, 408; 407, 409; 408, string:'fitted_rates'; 409, identifier:fitted_rates; 410, pair; 410, 411; 410, 412; 411, string:'angles'; 412, identifier:angles; 413, pair; 413, 414; 413, 415; 414, string:'corrected_means'; 415, identifier:corrected_means; 416, pair; 416, 417; 416, 418; 417, string:'corrected_rates'; 418, identifier:corrected_rates; 419, pair; 419, 420; 419, 421; 420, string:'rms_means'; 421, identifier:rms_means; 422, pair; 422, 423; 422, 424; 423, string:'rms_corrected_means'; 424, identifier:rms_corrected_means; 425, pair; 425, 426; 425, 427; 426, string:'rms_rates'; 427, identifier:rms_rates; 428, pair; 428, 429; 428, 430; 429, string:'rms_corrected_rates'; 430, identifier:rms_corrected_rates; 431, pair; 431, 432; 431, 433; 432, string:'gaussian_popts'; 433, identifier:popts; 434, pair; 434, 435; 434, 436; 435, string:'livetime'; 436, identifier:livetime; 437, pair; 437, 438; 437, 439; 438, string:'exp_popts'; 439, identifier:exp_popts; 440, pair; 440, 441; 440, 442; 441, string:'exp_pcov'; 442, identifier:exp_pcov; 443, pair; 443, 444; 443, 445; 444, string:'scale_factor'; 445, identifier:scale_factor; 446, pair; 446, 447; 446, 448; 447, string:'opt_sigmas'; 448, identifier:opt_sigmas; 449, pair; 449, 450; 449, 451; 450, string:'sigmas'; 451, identifier:sigmas; 452, pair; 452, 453; 452, 454; 453, string:'combs'; 454, identifier:combs; 455, return_statement; 455, 456; 456, identifier:return_data | def calibrate_dom(
dom_id,
data,
detector,
livetime=None,
fit_ang_dist=False,
scale_mc_to_data=True,
ad_fit_shape='pexp',
fit_background=True,
ctmin=-1.
):
if isinstance(data, str):
filename = data
loaders = {
'.h5': load_k40_coincidences_from_hdf5,
'.root': load_k40_coincidences_from_rootfile
}
try:
loader = loaders[os.path.splitext(filename)[1]]
except KeyError:
log.critical('File format not supported.')
raise IOError
else:
data, livetime = loader(filename, dom_id)
combs = np.array(list(combinations(range(31), 2)))
angles = calculate_angles(detector, combs)
cos_angles = np.cos(angles)
angles = angles[cos_angles >= ctmin]
data = data[cos_angles >= ctmin]
combs = combs[cos_angles >= ctmin]
try:
fit_res = fit_delta_ts(data, livetime, fit_background=fit_background)
rates, means, sigmas, popts, pcovs = fit_res
except:
return 0
rate_errors = np.array([np.diag(pc)[2] for pc in pcovs])
scale_factor = None
if fit_ang_dist:
fit_res = fit_angular_distribution(
angles, rates, rate_errors, shape=ad_fit_shape
)
fitted_rates, exp_popts, exp_pcov = fit_res
else:
mc_fitted_rates = exponential_polinomial(np.cos(angles), *MC_ANG_DIST)
if scale_mc_to_data:
scale_factor = np.mean(rates[angles < 1.5]) / \
np.mean(mc_fitted_rates[angles < 1.5])
else:
scale_factor = 1.
fitted_rates = mc_fitted_rates * scale_factor
exp_popts = []
exp_pcov = []
print('Using angular distribution from Monte Carlo')
if not fit_background:
minimize_weights = calculate_weights(fitted_rates, data)
else:
minimize_weights = fitted_rates
opt_t0s = minimize_t0s(means, minimize_weights, combs)
opt_sigmas = minimize_sigmas(sigmas, minimize_weights, combs)
opt_qes = minimize_qes(fitted_rates, rates, minimize_weights, combs)
corrected_means = correct_means(means, opt_t0s.x, combs)
corrected_rates = correct_rates(rates, opt_qes.x, combs)
rms_means, rms_corrected_means = calculate_rms_means(
means, corrected_means
)
rms_rates, rms_corrected_rates = calculate_rms_rates(
rates, fitted_rates, corrected_rates
)
cos_angles = np.cos(angles)
return_data = {
'opt_t0s': opt_t0s,
'opt_qes': opt_qes,
'data': data,
'means': means,
'rates': rates,
'fitted_rates': fitted_rates,
'angles': angles,
'corrected_means': corrected_means,
'corrected_rates': corrected_rates,
'rms_means': rms_means,
'rms_corrected_means': rms_corrected_means,
'rms_rates': rms_rates,
'rms_corrected_rates': rms_corrected_rates,
'gaussian_popts': popts,
'livetime': livetime,
'exp_popts': exp_popts,
'exp_pcov': exp_pcov,
'scale_factor': scale_factor,
'opt_sigmas': opt_sigmas,
'sigmas': sigmas,
'combs': combs
}
return return_data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:analyze; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:segments; 5, identifier:analysis; 6, default_parameter; 6, 7; 6, 8; 7, identifier:lookup; 8, call; 8, 9; 8, 10; 9, identifier:dict; 10, argument_list; 10, 11; 10, 14; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:bipa; 13, dictionary; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:dolgo; 16, dictionary; 17, block; 17, 18; 17, 27; 17, 46; 17, 146; 17, 177; 17, 252; 18, if_statement; 18, 19; 18, 21; 19, not_operator; 19, 20; 20, identifier:segments; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, string:'Empty sequence.'; 27, if_statement; 27, 28; 27, 40; 28, not_operator; 28, 29; 29, list_comprehension; 29, 30; 29, 31; 29, 34; 30, identifier:segment; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:segment; 33, identifier:segments; 34, if_clause; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:segment; 38, identifier:strip; 39, argument_list; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:ValueError; 44, argument_list; 44, 45; 45, string:'No information in the sequence.'; 46, try_statement; 46, 47; 46, 138; 47, block; 47, 48; 47, 56; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, pattern_list; 50, 51; 50, 52; 51, identifier:bipa_analysis; 52, identifier:sc_analysis; 53, expression_list; 53, 54; 53, 55; 54, list:[]; 55, list:[]; 56, for_statement; 56, 57; 56, 58; 56, 59; 57, identifier:s; 58, identifier:segments; 59, block; 59, 60; 59, 71; 59, 90; 59, 97; 59, 108; 59, 131; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:a; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:lookup; 67, string:'bipa'; 68, identifier:get; 69, argument_list; 69, 70; 70, identifier:s; 71, if_statement; 71, 72; 71, 75; 72, comparison_operator:is; 72, 73; 72, 74; 73, identifier:a; 74, None; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:a; 79, call; 79, 80; 79, 85; 80, attribute; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:lookup; 83, string:'bipa'; 84, identifier:setdefault; 85, argument_list; 85, 86; 85, 87; 86, identifier:s; 87, subscript; 87, 88; 87, 89; 88, identifier:BIPA; 89, identifier:s; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:bipa_analysis; 94, identifier:append; 95, argument_list; 95, 96; 96, identifier:a; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:sc; 100, call; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:lookup; 104, string:'dolgo'; 105, identifier:get; 106, argument_list; 106, 107; 107, identifier:s; 108, if_statement; 108, 109; 108, 112; 109, comparison_operator:is; 109, 110; 109, 111; 110, identifier:sc; 111, None; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:sc; 116, call; 116, 117; 116, 122; 117, attribute; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:lookup; 120, string:'dolgo'; 121, identifier:setdefault; 122, argument_list; 122, 123; 122, 124; 123, identifier:s; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:BIPA; 127, identifier:translate; 128, argument_list; 128, 129; 128, 130; 129, identifier:s; 130, identifier:DOLGO; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:sc_analysis; 135, identifier:append; 136, argument_list; 136, 137; 137, identifier:sc; 138, except_clause; 138, 139; 139, block; 139, 140; 139, 145; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 143; 142, identifier:print; 143, argument_list; 143, 144; 144, identifier:segments; 145, raise_statement; 146, for_statement; 146, 147; 146, 150; 146, 155; 147, pattern_list; 147, 148; 147, 149; 148, identifier:sound_bipa; 149, identifier:sound_class; 150, call; 150, 151; 150, 152; 151, identifier:zip; 152, argument_list; 152, 153; 152, 154; 153, identifier:bipa_analysis; 154, identifier:sc_analysis; 155, block; 155, 156; 156, if_statement; 156, 157; 156, 170; 157, boolean_operator:or; 157, 158; 157, 167; 158, call; 158, 159; 158, 160; 159, identifier:isinstance; 160, argument_list; 160, 161; 160, 162; 161, identifier:sound_bipa; 162, attribute; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:pyclts; 165, identifier:models; 166, identifier:UnknownSound; 167, comparison_operator:==; 167, 168; 167, 169; 168, identifier:sound_class; 169, string:'?'; 170, block; 170, 171; 171, expression_statement; 171, 172; 172, augmented_assignment:+=; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:analysis; 175, identifier:general_errors; 176, integer:1; 177, for_statement; 177, 178; 177, 182; 177, 188; 178, pattern_list; 178, 179; 178, 180; 178, 181; 179, identifier:segment; 180, identifier:sound_bipa; 181, identifier:sound_class; 182, call; 182, 183; 182, 184; 183, identifier:zip; 184, argument_list; 184, 185; 184, 186; 184, 187; 185, identifier:segments; 186, identifier:bipa_analysis; 187, identifier:sc_analysis; 188, block; 188, 189; 188, 199; 188, 238; 189, expression_statement; 189, 190; 190, call; 190, 191; 190, 196; 191, attribute; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:analysis; 194, identifier:segments; 195, identifier:update; 196, argument_list; 196, 197; 197, list:[segment]; 197, 198; 198, identifier:segment; 199, if_statement; 199, 200; 199, 209; 199, 219; 200, call; 200, 201; 200, 202; 201, identifier:isinstance; 202, argument_list; 202, 203; 202, 204; 203, identifier:sound_bipa; 204, attribute; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:pyclts; 207, identifier:models; 208, identifier:UnknownSound; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 217; 212, attribute; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:analysis; 215, identifier:bipa_errors; 216, identifier:add; 217, argument_list; 217, 218; 218, identifier:segment; 219, else_clause; 219, 220; 220, block; 220, 221; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 232; 223, attribute; 223, 224; 223, 231; 224, subscript; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:analysis; 227, identifier:replacements; 228, attribute; 228, 229; 228, 230; 229, identifier:sound_bipa; 230, identifier:source; 231, identifier:add; 232, argument_list; 232, 233; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:sound_bipa; 236, identifier:__unicode__; 237, argument_list; 238, if_statement; 238, 239; 238, 242; 239, comparison_operator:==; 239, 240; 239, 241; 240, identifier:sound_class; 241, string:'?'; 242, block; 242, 243; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 250; 245, attribute; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:analysis; 248, identifier:sclass_errors; 249, identifier:add; 250, argument_list; 250, 251; 251, identifier:segment; 252, return_statement; 252, 253; 253, expression_list; 253, 254; 253, 255; 253, 256; 253, 257; 254, identifier:segments; 255, identifier:bipa_analysis; 256, identifier:sc_analysis; 257, identifier:analysis | def analyze(segments, analysis, lookup=dict(bipa={}, dolgo={})):
if not segments:
raise ValueError('Empty sequence.')
if not [segment for segment in segments if segment.strip()]:
raise ValueError('No information in the sequence.')
try:
bipa_analysis, sc_analysis = [], []
for s in segments:
a = lookup['bipa'].get(s)
if a is None:
a = lookup['bipa'].setdefault(s, BIPA[s])
bipa_analysis.append(a)
sc = lookup['dolgo'].get(s)
if sc is None:
sc = lookup['dolgo'].setdefault(s, BIPA.translate(s, DOLGO))
sc_analysis.append(sc)
except:
print(segments)
raise
for sound_bipa, sound_class in zip(bipa_analysis, sc_analysis):
if isinstance(sound_bipa, pyclts.models.UnknownSound) or sound_class == '?':
analysis.general_errors += 1
for segment, sound_bipa, sound_class in zip(segments, bipa_analysis, sc_analysis):
analysis.segments.update([segment])
if isinstance(sound_bipa, pyclts.models.UnknownSound):
analysis.bipa_errors.add(segment)
else:
analysis.replacements[sound_bipa.source].add(sound_bipa.__unicode__())
if sound_class == '?':
analysis.sclass_errors.add(segment)
return segments, bipa_analysis, sc_analysis, analysis |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:setup_limits; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:conf_file; 5, identifier:limits_file; 6, default_parameter; 6, 7; 6, 8; 7, identifier:do_reload; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:dry_run; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:debug; 14, False; 15, block; 15, 16; 15, 23; 15, 34; 15, 42; 15, 54; 15, 66; 15, 75; 15, 79; 15, 145; 15, 166; 15, 179; 15, 185; 15, 189; 15, 235; 15, 270; 16, if_statement; 16, 17; 16, 18; 17, identifier:dry_run; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:debug; 22, True; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:conf; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:config; 29, identifier:Config; 30, argument_list; 30, 31; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:conf_file; 33, identifier:conf_file; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:db; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:conf; 40, identifier:get_database; 41, argument_list; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:limits_key; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:conf; 49, string:'control'; 50, identifier:get; 51, argument_list; 51, 52; 51, 53; 52, string:'limits_key'; 53, string:'limits'; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:control_channel; 57, call; 57, 58; 57, 63; 58, attribute; 58, 59; 58, 62; 59, subscript; 59, 60; 59, 61; 60, identifier:conf; 61, string:'control'; 62, identifier:get; 63, argument_list; 63, 64; 63, 65; 64, string:'channel'; 65, string:'control'; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:limits_tree; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:etree; 72, identifier:parse; 73, argument_list; 73, 74; 74, identifier:limits_file; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:lims; 78, list:[]; 79, for_statement; 79, 80; 79, 83; 79, 91; 80, pattern_list; 80, 81; 80, 82; 81, identifier:idx; 82, identifier:lim; 83, call; 83, 84; 83, 85; 84, identifier:enumerate; 85, argument_list; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:limits_tree; 89, identifier:getroot; 90, argument_list; 91, block; 91, 92; 91, 113; 92, if_statement; 92, 93; 92, 98; 93, comparison_operator:!=; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:lim; 96, identifier:tag; 97, string:'limit'; 98, block; 98, 99; 98, 112; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:warnings; 103, identifier:warn; 104, argument_list; 104, 105; 105, binary_operator:%; 105, 106; 105, 107; 106, string:"Unrecognized tag %r in limits file at index %d"; 107, tuple; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:lim; 110, identifier:tag; 111, identifier:idx; 112, continue_statement; 113, try_statement; 113, 114; 113, 127; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:lims; 119, identifier:append; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:parse_limit_node; 123, argument_list; 123, 124; 123, 125; 123, 126; 124, identifier:db; 125, identifier:idx; 126, identifier:lim; 127, except_clause; 127, 128; 127, 132; 128, as_pattern; 128, 129; 128, 130; 129, identifier:Exception; 130, as_pattern_target; 130, 131; 131, identifier:exc; 132, block; 132, 133; 132, 144; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:warnings; 137, identifier:warn; 138, argument_list; 138, 139; 139, binary_operator:%; 139, 140; 139, 141; 140, string:"Couldn't understand limit at index %d: %s"; 141, tuple; 141, 142; 141, 143; 142, identifier:idx; 143, identifier:exc; 144, continue_statement; 145, if_statement; 145, 146; 145, 147; 146, identifier:debug; 147, block; 147, 148; 147, 154; 148, print_statement; 148, 149; 148, 153; 149, chevron; 149, 150; 150, attribute; 150, 151; 150, 152; 151, identifier:sys; 152, identifier:stderr; 153, string:"Installing the following limits:"; 154, for_statement; 154, 155; 154, 156; 154, 157; 155, identifier:lim; 156, identifier:lims; 157, block; 157, 158; 158, print_statement; 158, 159; 158, 163; 159, chevron; 159, 160; 160, attribute; 160, 161; 160, 162; 161, identifier:sys; 162, identifier:stderr; 163, binary_operator:%; 163, 164; 163, 165; 164, string:" %r"; 165, identifier:lim; 166, if_statement; 166, 167; 166, 169; 167, not_operator; 167, 168; 168, identifier:dry_run; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:database; 174, identifier:limit_update; 175, argument_list; 175, 176; 175, 177; 175, 178; 176, identifier:db; 177, identifier:limits_key; 178, identifier:lims; 179, if_statement; 179, 180; 179, 183; 180, comparison_operator:is; 180, 181; 180, 182; 181, identifier:do_reload; 182, False; 183, block; 183, 184; 184, return_statement; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:params; 188, list:[]; 189, if_statement; 189, 190; 189, 193; 189, 195; 189, 225; 190, comparison_operator:is; 190, 191; 190, 192; 191, identifier:do_reload; 192, True; 193, block; 193, 194; 194, pass_statement; 195, elif_clause; 195, 196; 195, 218; 196, parenthesized_expression; 196, 197; 197, boolean_operator:or; 197, 198; 197, 206; 198, call; 198, 199; 198, 200; 199, identifier:isinstance; 200, argument_list; 200, 201; 200, 202; 201, identifier:do_reload; 202, tuple; 202, 203; 202, 204; 202, 205; 203, identifier:int; 204, identifier:long; 205, identifier:float; 206, parenthesized_expression; 206, 207; 207, boolean_operator:and; 207, 208; 207, 213; 208, call; 208, 209; 208, 210; 209, identifier:isinstance; 210, argument_list; 210, 211; 210, 212; 211, identifier:do_reload; 212, identifier:basestring; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:do_reload; 216, identifier:isdigit; 217, argument_list; 218, block; 218, 219; 219, expression_statement; 219, 220; 220, assignment; 220, 221; 220, 222; 221, identifier:params; 222, list:['spread', do_reload]; 222, 223; 222, 224; 223, string:'spread'; 224, identifier:do_reload; 225, else_clause; 225, 226; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:params; 230, list:[str(do_reload)]; 230, 231; 231, call; 231, 232; 231, 233; 232, identifier:str; 233, argument_list; 233, 234; 234, identifier:do_reload; 235, if_statement; 235, 236; 235, 237; 236, identifier:debug; 237, block; 237, 238; 237, 243; 237, 250; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:cmd; 241, list:['reload']; 241, 242; 242, string:'reload'; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:cmd; 247, identifier:extend; 248, argument_list; 248, 249; 249, identifier:params; 250, print_statement; 250, 251; 250, 255; 251, chevron; 251, 252; 252, attribute; 252, 253; 252, 254; 253, identifier:sys; 254, identifier:stderr; 255, parenthesized_expression; 255, 256; 256, binary_operator:%; 256, 257; 256, 258; 257, string:"Issuing command: %s"; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, string:' '; 261, identifier:join; 262, generator_expression; 262, 263; 262, 267; 263, call; 263, 264; 263, 265; 264, identifier:str; 265, argument_list; 265, 266; 266, identifier:c; 267, for_in_clause; 267, 268; 267, 269; 268, identifier:c; 269, identifier:cmd; 270, if_statement; 270, 271; 270, 273; 271, not_operator; 271, 272; 272, identifier:dry_run; 273, block; 273, 274; 274, expression_statement; 274, 275; 275, call; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:database; 278, identifier:command; 279, argument_list; 279, 280; 279, 281; 279, 282; 279, 283; 280, identifier:db; 281, identifier:control_channel; 282, string:'reload'; 283, list_splat; 283, 284; 284, identifier:params | def setup_limits(conf_file, limits_file, do_reload=True,
dry_run=False, debug=False):
if dry_run:
debug = True
conf = config.Config(conf_file=conf_file)
db = conf.get_database()
limits_key = conf['control'].get('limits_key', 'limits')
control_channel = conf['control'].get('channel', 'control')
limits_tree = etree.parse(limits_file)
lims = []
for idx, lim in enumerate(limits_tree.getroot()):
if lim.tag != 'limit':
warnings.warn("Unrecognized tag %r in limits file at index %d" %
(lim.tag, idx))
continue
try:
lims.append(parse_limit_node(db, idx, lim))
except Exception as exc:
warnings.warn("Couldn't understand limit at index %d: %s" %
(idx, exc))
continue
if debug:
print >>sys.stderr, "Installing the following limits:"
for lim in lims:
print >>sys.stderr, " %r" % lim
if not dry_run:
database.limit_update(db, limits_key, lims)
if do_reload is False:
return
params = []
if do_reload is True:
pass
elif (isinstance(do_reload, (int, long, float)) or
(isinstance(do_reload, basestring) and do_reload.isdigit())):
params = ['spread', do_reload]
else:
params = [str(do_reload)]
if debug:
cmd = ['reload']
cmd.extend(params)
print >>sys.stderr, ("Issuing command: %s" %
' '.join(str(c) for c in cmd))
if not dry_run:
database.command(db, control_channel, 'reload', *params) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:make_limit_node; 3, parameters; 3, 4; 3, 5; 4, identifier:root; 5, identifier:limit; 6, block; 6, 7; 6, 23; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:limit_node; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:etree; 13, identifier:SubElement; 14, argument_list; 14, 15; 14, 16; 14, 17; 15, identifier:root; 16, string:'limit'; 17, dictionary; 17, 18; 18, pair; 18, 19; 18, 20; 19, string:'class'; 20, attribute; 20, 21; 20, 22; 21, identifier:limit; 22, identifier:_limit_full_name; 23, for_statement; 23, 24; 23, 25; 23, 31; 24, identifier:attr; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 28, attribute; 28, 29; 28, 30; 29, identifier:limit; 30, identifier:attrs; 31, block; 31, 32; 31, 40; 31, 50; 31, 58; 31, 88; 31, 101; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:desc; 35, subscript; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:limit; 38, identifier:attrs; 39, identifier:attr; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:attr_type; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:desc; 46, identifier:get; 47, argument_list; 47, 48; 47, 49; 48, string:'type'; 49, identifier:str; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:value; 53, call; 53, 54; 53, 55; 54, identifier:getattr; 55, argument_list; 55, 56; 55, 57; 56, identifier:limit; 57, identifier:attr; 58, if_statement; 58, 59; 58, 62; 59, comparison_operator:in; 59, 60; 59, 61; 60, string:'default'; 61, identifier:desc; 62, block; 62, 63; 62, 82; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:default; 66, parenthesized_expression; 66, 67; 67, conditional_expression:if; 67, 68; 67, 73; 67, 79; 68, call; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:desc; 71, string:'default'; 72, argument_list; 73, call; 73, 74; 73, 75; 74, identifier:callable; 75, argument_list; 75, 76; 76, subscript; 76, 77; 76, 78; 77, identifier:desc; 78, string:'default'; 79, subscript; 79, 80; 79, 81; 80, identifier:desc; 81, string:'default'; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:==; 83, 84; 83, 85; 84, identifier:value; 85, identifier:default; 86, block; 86, 87; 87, continue_statement; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:attr_node; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:etree; 94, identifier:SubElement; 95, argument_list; 95, 96; 95, 97; 95, 98; 96, identifier:limit_node; 97, string:'attr'; 98, keyword_argument; 98, 99; 98, 100; 99, identifier:name; 100, identifier:attr; 101, if_statement; 101, 102; 101, 105; 101, 129; 101, 177; 102, comparison_operator:==; 102, 103; 102, 104; 103, identifier:attr_type; 104, identifier:list; 105, block; 105, 106; 106, for_statement; 106, 107; 106, 108; 106, 109; 107, identifier:val; 108, identifier:value; 109, block; 109, 110; 109, 120; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:val_node; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:etree; 116, identifier:SubElement; 117, argument_list; 117, 118; 117, 119; 118, identifier:attr_node; 119, string:'value'; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:val_node; 124, identifier:text; 125, call; 125, 126; 125, 127; 126, identifier:str; 127, argument_list; 127, 128; 128, identifier:val; 129, elif_clause; 129, 130; 129, 133; 130, comparison_operator:==; 130, 131; 130, 132; 131, identifier:attr_type; 132, identifier:dict; 133, block; 133, 134; 134, for_statement; 134, 135; 134, 138; 134, 154; 135, pattern_list; 135, 136; 135, 137; 136, identifier:key; 137, identifier:val; 138, call; 138, 139; 138, 140; 139, identifier:sorted; 140, argument_list; 140, 141; 140, 146; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:value; 144, identifier:items; 145, argument_list; 146, keyword_argument; 146, 147; 146, 148; 147, identifier:key; 148, lambda; 148, 149; 148, 151; 149, lambda_parameters; 149, 150; 150, identifier:x; 151, subscript; 151, 152; 151, 153; 152, identifier:x; 153, integer:0; 154, block; 154, 155; 154, 168; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:val_node; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:etree; 161, identifier:SubElement; 162, argument_list; 162, 163; 162, 164; 162, 165; 163, identifier:attr_node; 164, string:'value'; 165, keyword_argument; 165, 166; 165, 167; 166, identifier:key; 167, identifier:key; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:val_node; 172, identifier:text; 173, call; 173, 174; 173, 175; 174, identifier:str; 175, argument_list; 175, 176; 176, identifier:val; 177, else_clause; 177, 178; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:attr_node; 183, identifier:text; 184, call; 184, 185; 184, 186; 185, identifier:str; 186, argument_list; 186, 187; 187, identifier:value | def make_limit_node(root, limit):
limit_node = etree.SubElement(root, 'limit',
{'class': limit._limit_full_name})
for attr in sorted(limit.attrs):
desc = limit.attrs[attr]
attr_type = desc.get('type', str)
value = getattr(limit, attr)
if 'default' in desc:
default = (desc['default']() if callable(desc['default']) else
desc['default'])
if value == default:
continue
attr_node = etree.SubElement(limit_node, 'attr', name=attr)
if attr_type == list:
for val in value:
val_node = etree.SubElement(attr_node, 'value')
val_node.text = str(val)
elif attr_type == dict:
for key, val in sorted(value.items(), key=lambda x: x[0]):
val_node = etree.SubElement(attr_node, 'value', key=key)
val_node.text = str(val)
else:
attr_node.text = str(value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:turnstile_command; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:conf_file; 5, identifier:command; 6, default_parameter; 6, 7; 6, 8; 7, identifier:arguments; 8, list:[]; 9, default_parameter; 9, 10; 9, 11; 10, identifier:channel; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:debug; 14, False; 15, block; 15, 16; 15, 27; 15, 35; 15, 47; 15, 55; 15, 59; 15, 122; 15, 146; 15, 157; 15, 162; 15, 170; 15, 177; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:conf; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:config; 22, identifier:Config; 23, argument_list; 23, 24; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:conf_file; 26, identifier:conf_file; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:db; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:conf; 33, identifier:get_database; 34, argument_list; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:control_channel; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:conf; 42, string:'control'; 43, identifier:get; 44, argument_list; 44, 45; 44, 46; 45, string:'channel'; 46, string:'control'; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:command; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:command; 53, identifier:lower; 54, argument_list; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:ts_conv; 58, False; 59, if_statement; 59, 60; 59, 63; 60, comparison_operator:==; 60, 61; 60, 62; 61, identifier:command; 62, string:'ping'; 63, block; 63, 64; 63, 91; 63, 114; 64, if_statement; 64, 65; 64, 66; 64, 73; 65, identifier:arguments; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:channel; 70, subscript; 70, 71; 70, 72; 71, identifier:arguments; 72, integer:0; 73, else_clause; 73, 74; 74, block; 74, 75; 74, 86; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:channel; 78, call; 78, 79; 78, 80; 79, identifier:str; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:uuid; 84, identifier:uuid4; 85, argument_list; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:arguments; 89, list:[channel]; 89, 90; 90, identifier:channel; 91, if_statement; 91, 92; 91, 98; 92, comparison_operator:<; 92, 93; 92, 97; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, identifier:arguments; 97, integer:2; 98, block; 98, 99; 98, 110; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:arguments; 103, identifier:append; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:time; 108, identifier:time; 109, argument_list; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:ts_conv; 113, True; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:arguments; 117, subscript; 117, 118; 117, 119; 118, identifier:arguments; 119, slice; 119, 120; 119, 121; 120, colon; 121, integer:2; 122, if_statement; 122, 123; 122, 124; 123, identifier:debug; 124, block; 124, 125; 124, 132; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:cmd; 128, binary_operator:+; 128, 129; 128, 131; 129, list:[command]; 129, 130; 130, identifier:command; 131, identifier:arguments; 132, print_statement; 132, 133; 132, 137; 133, chevron; 133, 134; 134, attribute; 134, 135; 134, 136; 135, identifier:sys; 136, identifier:stderr; 137, parenthesized_expression; 137, 138; 138, binary_operator:%; 138, 139; 138, 140; 139, string:"Issuing command: %s"; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, string:' '; 143, identifier:join; 144, argument_list; 144, 145; 145, identifier:cmd; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:database; 150, identifier:command; 151, argument_list; 151, 152; 151, 153; 151, 154; 151, 155; 152, identifier:db; 153, identifier:control_channel; 154, identifier:command; 155, list_splat; 155, 156; 156, identifier:arguments; 157, if_statement; 157, 158; 157, 160; 158, not_operator; 158, 159; 159, identifier:channel; 160, block; 160, 161; 161, return_statement; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:pubsub; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:db; 168, identifier:pubsub; 169, argument_list; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:pubsub; 174, identifier:subscribe; 175, argument_list; 175, 176; 176, identifier:channel; 177, try_statement; 177, 178; 177, 296; 178, block; 178, 179; 178, 183; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:count; 182, integer:0; 183, for_statement; 183, 184; 183, 185; 183, 190; 184, identifier:msg; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:pubsub; 188, identifier:listen; 189, argument_list; 190, block; 190, 191; 190, 211; 190, 228; 190, 232; 190, 243; 190, 285; 191, if_statement; 191, 192; 191, 193; 192, identifier:debug; 193, block; 193, 194; 193, 203; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:formatted; 197, call; 197, 198; 197, 201; 198, attribute; 198, 199; 198, 200; 199, identifier:pprint; 200, identifier:pformat; 201, argument_list; 201, 202; 202, identifier:msg; 203, print_statement; 203, 204; 203, 208; 204, chevron; 204, 205; 205, attribute; 205, 206; 205, 207; 206, identifier:sys; 207, identifier:stderr; 208, binary_operator:%; 208, 209; 208, 210; 209, string:"Received message: %s"; 210, identifier:formatted; 211, if_statement; 211, 212; 211, 226; 212, parenthesized_expression; 212, 213; 213, boolean_operator:or; 213, 214; 213, 221; 214, comparison_operator:not; 214, 215; 214, 218; 215, subscript; 215, 216; 215, 217; 216, identifier:msg; 217, string:'type'; 218, tuple; 218, 219; 218, 220; 219, string:'pmessage'; 220, string:'message'; 221, comparison_operator:!=; 221, 222; 221, 225; 222, subscript; 222, 223; 222, 224; 223, identifier:msg; 224, string:'channel'; 225, identifier:channel; 226, block; 226, 227; 227, continue_statement; 228, expression_statement; 228, 229; 229, augmented_assignment:+=; 229, 230; 229, 231; 230, identifier:count; 231, integer:1; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:response; 235, call; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:msg; 239, string:'data'; 240, identifier:split; 241, argument_list; 241, 242; 242, string:':'; 243, if_statement; 243, 244; 243, 251; 244, boolean_operator:and; 244, 245; 244, 246; 245, identifier:ts_conv; 246, comparison_operator:==; 246, 247; 246, 250; 247, subscript; 247, 248; 247, 249; 248, identifier:response; 249, integer:0; 250, string:'pong'; 251, block; 251, 252; 252, try_statement; 252, 253; 252, 281; 253, block; 253, 254; 253, 272; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:rtt; 257, binary_operator:*; 257, 258; 257, 271; 258, parenthesized_expression; 258, 259; 259, binary_operator:-; 259, 260; 259, 265; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:time; 263, identifier:time; 264, argument_list; 265, call; 265, 266; 265, 267; 266, identifier:float; 267, argument_list; 267, 268; 268, subscript; 268, 269; 268, 270; 269, identifier:response; 270, integer:2; 271, integer:100; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:response; 276, identifier:append; 277, argument_list; 277, 278; 278, binary_operator:%; 278, 279; 278, 280; 279, string:'(RTT %.2fms)'; 280, identifier:rtt; 281, except_clause; 281, 282; 281, 283; 282, identifier:Exception; 283, block; 283, 284; 284, pass_statement; 285, print_statement; 285, 286; 286, binary_operator:%; 286, 287; 286, 288; 287, string:"Response % 5d: %s"; 288, tuple; 288, 289; 288, 290; 289, identifier:count; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, string:' '; 293, identifier:join; 294, argument_list; 294, 295; 295, identifier:response; 296, except_clause; 296, 297; 296, 298; 297, identifier:KeyboardInterrupt; 298, block; 298, 299; 299, pass_statement | def turnstile_command(conf_file, command, arguments=[], channel=None,
debug=False):
conf = config.Config(conf_file=conf_file)
db = conf.get_database()
control_channel = conf['control'].get('channel', 'control')
command = command.lower()
ts_conv = False
if command == 'ping':
if arguments:
channel = arguments[0]
else:
channel = str(uuid.uuid4())
arguments = [channel]
if len(arguments) < 2:
arguments.append(time.time())
ts_conv = True
arguments = arguments[:2]
if debug:
cmd = [command] + arguments
print >>sys.stderr, ("Issuing command: %s" %
' '.join(cmd))
database.command(db, control_channel, command, *arguments)
if not channel:
return
pubsub = db.pubsub()
pubsub.subscribe(channel)
try:
count = 0
for msg in pubsub.listen():
if debug:
formatted = pprint.pformat(msg)
print >>sys.stderr, "Received message: %s" % formatted
if (msg['type'] not in ('pmessage', 'message') or
msg['channel'] != channel):
continue
count += 1
response = msg['data'].split(':')
if ts_conv and response[0] == 'pong':
try:
rtt = (time.time() - float(response[2])) * 100
response.append('(RTT %.2fms)' % rtt)
except Exception:
pass
print "Response % 5d: %s" % (count, ' '.join(response))
except KeyboardInterrupt:
pass |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:humanize_timesince; 3, parameters; 3, 4; 4, identifier:start_time; 5, block; 5, 6; 5, 12; 5, 20; 5, 31; 5, 39; 5, 62; 5, 70; 5, 93; 5, 99; 5, 122; 5, 130; 5, 153; 5, 161; 5, 184; 6, if_statement; 6, 7; 6, 9; 7, not_operator; 7, 8; 8, identifier:start_time; 9, block; 9, 10; 10, return_statement; 10, 11; 11, identifier:start_time; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:delta; 15, binary_operator:-; 15, 16; 15, 19; 16, call; 16, 17; 16, 18; 17, identifier:local_now; 18, argument_list; 19, identifier:start_time; 20, if_statement; 20, 21; 20, 28; 21, comparison_operator:<; 21, 22; 21, 27; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:delta; 25, identifier:total_seconds; 26, argument_list; 27, integer:0; 28, block; 28, 29; 29, return_statement; 29, 30; 30, string:'a few seconds ago'; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:num_years; 34, binary_operator://; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:delta; 37, identifier:days; 38, integer:365; 39, if_statement; 39, 40; 39, 43; 40, comparison_operator:>; 40, 41; 40, 42; 41, identifier:num_years; 42, integer:0; 43, block; 43, 44; 44, return_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, string:'{} year{} ago'; 48, identifier:format; 49, argument_list; 49, 50; 50, list_splat; 50, 51; 51, parenthesized_expression; 51, 52; 52, conditional_expression:if; 52, 53; 52, 56; 52, 59; 53, tuple; 53, 54; 53, 55; 54, identifier:num_years; 55, string:'s'; 56, comparison_operator:>; 56, 57; 56, 58; 57, identifier:num_years; 58, integer:1; 59, tuple; 59, 60; 59, 61; 60, identifier:num_years; 61, string:''; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:num_weeks; 65, binary_operator://; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:delta; 68, identifier:days; 69, integer:7; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:>; 71, 72; 71, 73; 72, identifier:num_weeks; 73, integer:0; 74, block; 74, 75; 75, return_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, string:'{} week{} ago'; 79, identifier:format; 80, argument_list; 80, 81; 81, list_splat; 81, 82; 82, parenthesized_expression; 82, 83; 83, conditional_expression:if; 83, 84; 83, 87; 83, 90; 84, tuple; 84, 85; 84, 86; 85, identifier:num_weeks; 86, string:'s'; 87, comparison_operator:>; 87, 88; 87, 89; 88, identifier:num_weeks; 89, integer:1; 90, tuple; 90, 91; 90, 92; 91, identifier:num_weeks; 92, string:''; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:num_days; 96, attribute; 96, 97; 96, 98; 97, identifier:delta; 98, identifier:days; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:>; 100, 101; 100, 102; 101, identifier:num_days; 102, integer:0; 103, block; 103, 104; 104, return_statement; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, string:'{} day{} ago'; 108, identifier:format; 109, argument_list; 109, 110; 110, list_splat; 110, 111; 111, parenthesized_expression; 111, 112; 112, conditional_expression:if; 112, 113; 112, 116; 112, 119; 113, tuple; 113, 114; 113, 115; 114, identifier:num_days; 115, string:'s'; 116, comparison_operator:>; 116, 117; 116, 118; 117, identifier:num_days; 118, integer:1; 119, tuple; 119, 120; 119, 121; 120, identifier:num_days; 121, string:''; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:num_hours; 125, binary_operator://; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:delta; 128, identifier:seconds; 129, integer:3600; 130, if_statement; 130, 131; 130, 134; 131, comparison_operator:>; 131, 132; 131, 133; 132, identifier:num_hours; 133, integer:0; 134, block; 134, 135; 135, return_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, string:'{} hour{} ago'; 139, identifier:format; 140, argument_list; 140, 141; 141, list_splat; 141, 142; 142, parenthesized_expression; 142, 143; 143, conditional_expression:if; 143, 144; 143, 147; 143, 150; 144, tuple; 144, 145; 144, 146; 145, identifier:num_hours; 146, string:'s'; 147, comparison_operator:>; 147, 148; 147, 149; 148, identifier:num_hours; 149, integer:1; 150, tuple; 150, 151; 150, 152; 151, identifier:num_hours; 152, string:''; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:num_minutes; 156, binary_operator://; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:delta; 159, identifier:seconds; 160, integer:60; 161, if_statement; 161, 162; 161, 165; 162, comparison_operator:>; 162, 163; 162, 164; 163, identifier:num_minutes; 164, integer:0; 165, block; 165, 166; 166, return_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, string:'{} minute{} ago'; 170, identifier:format; 171, argument_list; 171, 172; 172, list_splat; 172, 173; 173, parenthesized_expression; 173, 174; 174, conditional_expression:if; 174, 175; 174, 178; 174, 181; 175, tuple; 175, 176; 175, 177; 176, identifier:num_minutes; 177, string:'s'; 178, comparison_operator:>; 178, 179; 178, 180; 179, identifier:num_minutes; 180, integer:1; 181, tuple; 181, 182; 181, 183; 182, identifier:num_minutes; 183, string:''; 184, return_statement; 184, 185; 185, string:'a few seconds ago' | def humanize_timesince(start_time):
if not start_time:
return start_time
delta = local_now() - start_time
if delta.total_seconds() < 0:
return 'a few seconds ago'
num_years = delta.days // 365
if num_years > 0:
return '{} year{} ago'.format(
*((num_years, 's') if num_years > 1 else (num_years, '')))
num_weeks = delta.days // 7
if num_weeks > 0:
return '{} week{} ago'.format(
*((num_weeks, 's') if num_weeks > 1 else (num_weeks, '')))
num_days = delta.days
if num_days > 0:
return '{} day{} ago'.format(
*((num_days, 's') if num_days > 1 else (num_days, '')))
num_hours = delta.seconds // 3600
if num_hours > 0:
return '{} hour{} ago'.format(*((num_hours, 's') if num_hours > 1 else (num_hours, '')))
num_minutes = delta.seconds // 60
if num_minutes > 0:
return '{} minute{} ago'.format(
*((num_minutes, 's') if num_minutes > 1 else (num_minutes, '')))
return 'a few seconds ago' |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:fire; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kw; 9, block; 9, 10; 9, 14; 9, 27; 9, 345; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:result; 13, list:[]; 14, with_statement; 14, 15; 14, 20; 15, with_clause; 15, 16; 16, with_item; 16, 17; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_hlock; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:handlers; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:handlers; 27, if_statement; 27, 28; 27, 33; 27, 95; 28, comparison_operator:==; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:threads; 32, integer:0; 33, block; 33, 34; 34, for_statement; 34, 35; 34, 36; 34, 37; 35, identifier:k; 36, identifier:handlers; 37, block; 37, 38; 37, 47; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 44; 40, pattern_list; 40, 41; 40, 42; 40, 43; 41, identifier:h; 42, identifier:m; 43, identifier:t; 44, subscript; 44, 45; 44, 46; 45, identifier:handlers; 46, identifier:k; 47, try_statement; 47, 48; 47, 74; 48, block; 48, 49; 48, 64; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:r; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_memoize; 56, argument_list; 56, 57; 56, 58; 56, 59; 56, 60; 56, 62; 57, identifier:h; 58, identifier:m; 59, identifier:t; 60, list_splat; 60, 61; 61, identifier:args; 62, dictionary_splat; 62, 63; 63, identifier:kw; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:result; 68, identifier:append; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:tuple; 72, argument_list; 72, 73; 73, identifier:r; 74, except_clause; 74, 75; 75, block; 75, 76; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:result; 80, identifier:append; 81, argument_list; 81, 82; 82, tuple; 82, 83; 82, 84; 82, 94; 83, False; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_error; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:sys; 92, identifier:exc_info; 93, argument_list; 94, identifier:h; 95, elif_clause; 95, 96; 95, 101; 96, comparison_operator:>; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:threads; 100, integer:0; 101, block; 101, 102; 101, 108; 101, 114; 101, 236; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:queue; 105, call; 105, 106; 105, 107; 106, identifier:Queue; 107, argument_list; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:rlock; 111, call; 111, 112; 111, 113; 112, identifier:RLock; 113, argument_list; 114, function_definition; 114, 115; 114, 116; 114, 121; 115, function_name:_execute; 116, parameters; 116, 117; 116, 119; 117, list_splat_pattern; 117, 118; 118, identifier:args; 119, dictionary_splat_pattern; 119, 120; 120, identifier:kw; 121, block; 121, 122; 122, while_statement; 122, 123; 122, 124; 123, True; 124, block; 124, 125; 125, try_statement; 125, 126; 125, 232; 126, block; 126, 127; 126, 135; 126, 147; 126, 156; 126, 226; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:item; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:queue; 133, identifier:get; 134, argument_list; 135, if_statement; 135, 136; 135, 139; 136, comparison_operator:is; 136, 137; 136, 138; 137, identifier:item; 138, None; 139, block; 139, 140; 139, 146; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:queue; 144, identifier:task_done; 145, argument_list; 146, break_statement; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 153; 149, pattern_list; 149, 150; 149, 151; 149, 152; 150, identifier:h; 151, identifier:m; 152, identifier:t; 153, subscript; 153, 154; 153, 155; 154, identifier:handlers; 155, identifier:item; 156, try_statement; 156, 157; 156, 194; 157, block; 157, 158; 157, 173; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:r; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:_memoize; 165, argument_list; 165, 166; 165, 167; 165, 168; 165, 169; 165, 171; 166, identifier:h; 167, identifier:m; 168, identifier:t; 169, list_splat; 169, 170; 170, identifier:args; 171, dictionary_splat; 171, 172; 172, identifier:kw; 173, if_statement; 173, 174; 173, 178; 174, not_operator; 174, 175; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:asynch; 178, block; 178, 179; 179, with_statement; 179, 180; 179, 183; 180, with_clause; 180, 181; 181, with_item; 181, 182; 182, identifier:rlock; 183, block; 183, 184; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:result; 188, identifier:append; 189, argument_list; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:tuple; 192, argument_list; 192, 193; 193, identifier:r; 194, except_clause; 194, 195; 195, block; 195, 196; 196, if_statement; 196, 197; 196, 201; 197, not_operator; 197, 198; 198, attribute; 198, 199; 198, 200; 199, identifier:self; 200, identifier:asynch; 201, block; 201, 202; 202, with_statement; 202, 203; 202, 206; 203, with_clause; 203, 204; 204, with_item; 204, 205; 205, identifier:rlock; 206, block; 206, 207; 207, expression_statement; 207, 208; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:result; 211, identifier:append; 212, argument_list; 212, 213; 213, tuple; 213, 214; 213, 215; 213, 225; 214, False; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:self; 218, identifier:_error; 219, argument_list; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:sys; 223, identifier:exc_info; 224, argument_list; 225, identifier:h; 226, expression_statement; 226, 227; 227, call; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:queue; 230, identifier:task_done; 231, argument_list; 232, except_clause; 232, 233; 232, 234; 233, identifier:Empty; 234, block; 234, 235; 235, break_statement; 236, if_statement; 236, 237; 236, 238; 237, identifier:handlers; 238, block; 238, 239; 238, 250; 238, 284; 238, 319; 238, 333; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:threads; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:self; 245, identifier:_threads; 246, argument_list; 246, 247; 247, keyword_argument; 247, 248; 247, 249; 248, identifier:handlers; 249, identifier:handlers; 250, for_statement; 250, 251; 250, 252; 250, 256; 251, identifier:_; 252, call; 252, 253; 252, 254; 253, identifier:range; 254, argument_list; 254, 255; 255, identifier:threads; 256, block; 256, 257; 256, 272; 256, 278; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:t; 260, call; 260, 261; 260, 262; 261, identifier:Thread; 262, argument_list; 262, 263; 262, 266; 262, 269; 263, keyword_argument; 263, 264; 263, 265; 264, identifier:target; 265, identifier:_execute; 266, keyword_argument; 266, 267; 266, 268; 267, identifier:args; 268, identifier:args; 269, keyword_argument; 269, 270; 269, 271; 270, identifier:kwargs; 271, identifier:kw; 272, expression_statement; 272, 273; 273, assignment; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:t; 276, identifier:daemon; 277, True; 278, expression_statement; 278, 279; 279, call; 279, 280; 279, 283; 280, attribute; 280, 281; 280, 282; 281, identifier:t; 282, identifier:start; 283, argument_list; 284, for_statement; 284, 285; 284, 286; 284, 287; 285, identifier:k; 286, identifier:handlers; 287, block; 287, 288; 287, 295; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:queue; 292, identifier:put; 293, argument_list; 293, 294; 294, identifier:k; 295, if_statement; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:self; 298, identifier:asynch; 299, block; 299, 300; 299, 309; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 306; 302, pattern_list; 302, 303; 302, 304; 302, 305; 303, identifier:h; 304, identifier:_; 305, identifier:_; 306, subscript; 306, 307; 306, 308; 307, identifier:handlers; 308, identifier:k; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:result; 313, identifier:append; 314, argument_list; 314, 315; 315, tuple; 315, 316; 315, 317; 315, 318; 316, None; 317, None; 318, identifier:h; 319, for_statement; 319, 320; 319, 321; 319, 325; 320, identifier:_; 321, call; 321, 322; 321, 323; 322, identifier:range; 323, argument_list; 323, 324; 324, identifier:threads; 325, block; 325, 326; 326, expression_statement; 326, 327; 327, call; 327, 328; 327, 331; 328, attribute; 328, 329; 328, 330; 329, identifier:queue; 330, identifier:put; 331, argument_list; 331, 332; 332, None; 333, if_statement; 333, 334; 333, 338; 334, not_operator; 334, 335; 335, attribute; 335, 336; 335, 337; 336, identifier:self; 337, identifier:asynch; 338, block; 338, 339; 339, expression_statement; 339, 340; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:queue; 343, identifier:join; 344, argument_list; 345, return_statement; 345, 346; 346, boolean_operator:or; 346, 347; 346, 351; 347, call; 347, 348; 347, 349; 348, identifier:tuple; 349, argument_list; 349, 350; 350, identifier:result; 351, None | def fire(self, *args, **kw):
result = []
with self._hlock:
handlers = self.handlers
if self.threads == 0:
for k in handlers:
h, m, t = handlers[k]
try:
r = self._memoize(h, m, t, *args, **kw)
result.append(tuple(r))
except:
result.append((False, self._error(sys.exc_info()), h))
elif self.threads > 0:
queue = Queue()
rlock = RLock()
def _execute(*args, **kw):
while True:
try:
item = queue.get()
if item is None:
queue.task_done()
break
h, m, t = handlers[item]
try:
r = self._memoize(h, m, t, *args, **kw)
if not self.asynch:
with rlock:
result.append(tuple(r))
except:
if not self.asynch:
with rlock:
result.append((False, self._error(sys.exc_info()), h))
queue.task_done()
except Empty:
break
if handlers:
threads = self._threads(handlers=handlers)
for _ in range(threads):
t = Thread(target=_execute, args=args, kwargs=kw)
t.daemon = True
t.start()
for k in handlers:
queue.put(k)
if self.asynch:
h, _, _ = handlers[k]
result.append((None, None, h))
for _ in range(threads):
queue.put(None)
if not self.asynch:
queue.join()
return tuple(result) or None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:runGetResults; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:cmd; 5, default_parameter; 5, 6; 5, 7; 6, identifier:stdout; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:stderr; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:encoding; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:sys; 16, identifier:getdefaultencoding; 17, argument_list; 18, block; 18, 19; 18, 21; 18, 59; 18, 94; 18, 115; 18, 187; 18, 191; 18, 195; 18, 199; 18, 233; 18, 267; 18, 271; 18, 278; 18, 369; 18, 409; 18, 415; 19, expression_statement; 19, 20; 20, string:'''
runGetResults - Simple method to run a command and return the results of the execution as a dict.
@param cmd <str/list> - String of command and arguments, or list of command and arguments
If cmd is a string, the command will be executed as if ran exactly as written in a shell. This mode supports shell-isms like '&&' and '|'
If cmd is a list, the first element will be the executable, and further elements are arguments that will be passed to that executable.
@param stdout <True/False> - Default True, Whether to gather and include program's stdout data in results.
If False, that data the program prints to stdout will just be output to the current tty and not recorded.
If True, it will NOT be output to the tty, and will be recorded under the key "stdout" in the return dict.
@param stderr <True/False or "stdout"/subprocess.STDOUT> - Default True, Whether to gather and include program's stderr data in results, or to combine with "stdout" data.
If False, the data the program prints to stderr will just be output to the current tty and not recorded
If True, it will NOT be output to the tty, and will be recorded under the key "stderr" in the return dict.
If "stdout" or subprocess.STDOUT - stderr data will be blended with stdout data. This requires that stdout=True.
@param encoding <None/str> - Default sys.getdefaultencoding(), the program's output will automatically be decoded using the provided codec (e.x. "utf-8" or "ascii").
If None or False-ish, data will not be decoded (i.e. in python3 will be "bytes" type)
If unsure, leave this as it's default value, or provide "utf-8"
@return <dict> - Dict of results. Has following keys:
'returnCode' - <int> - Always present, included the integer return-code from the command.
'stdout' <unciode/str/bytes (depending on
'stderr' <unicode/str/bytes (depending on
@raises - SimpleCommandFailure if it cannot launch the given command, for reasons such as: cannot find the executable, or no permission to execute, etc
'''; 21, if_statement; 21, 22; 21, 29; 21, 36; 21, 53; 22, comparison_operator:in; 22, 23; 22, 24; 23, identifier:stderr; 24, tuple; 24, 25; 24, 26; 25, string:'stdout'; 26, attribute; 26, 27; 26, 28; 27, identifier:subprocess; 28, identifier:STDOUT; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:stderr; 33, attribute; 33, 34; 33, 35; 34, identifier:subprocess; 35, identifier:STDOUT; 36, elif_clause; 36, 37; 36, 46; 37, boolean_operator:or; 37, 38; 37, 41; 38, comparison_operator:==; 38, 39; 38, 40; 39, identifier:stderr; 40, True; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:stderr; 43, attribute; 43, 44; 43, 45; 44, identifier:subprocess; 45, identifier:PIPE; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:stderr; 50, attribute; 50, 51; 50, 52; 51, identifier:subprocess; 52, identifier:PIPE; 53, else_clause; 53, 54; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:stderr; 58, None; 59, if_statement; 59, 60; 59, 69; 59, 76; 60, boolean_operator:or; 60, 61; 60, 64; 61, comparison_operator:==; 61, 62; 61, 63; 62, identifier:stdout; 63, True; 64, comparison_operator:==; 64, 65; 64, 66; 65, identifier:stdout; 66, attribute; 66, 67; 66, 68; 67, identifier:subprocess; 68, identifier:STDOUT; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:stdout; 73, attribute; 73, 74; 73, 75; 74, identifier:subprocess; 75, identifier:PIPE; 76, else_clause; 76, 77; 77, block; 77, 78; 77, 82; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:stdout; 81, None; 82, if_statement; 82, 83; 82, 88; 83, comparison_operator:==; 83, 84; 83, 85; 84, identifier:stderr; 85, attribute; 85, 86; 85, 87; 86, identifier:subprocess; 87, identifier:PIPE; 88, block; 88, 89; 89, raise_statement; 89, 90; 90, call; 90, 91; 90, 92; 91, identifier:ValueError; 92, argument_list; 92, 93; 93, string:'Cannot redirect stderr to stdout if stdout is not captured.'; 94, if_statement; 94, 95; 94, 104; 94, 109; 95, call; 95, 96; 95, 97; 96, identifier:issubclass; 97, argument_list; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:cmd; 100, identifier:__class__; 101, tuple; 101, 102; 101, 103; 102, identifier:list; 103, identifier:tuple; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:shell; 108, False; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:shell; 114, True; 115, try_statement; 115, 116; 115, 135; 116, block; 116, 117; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:pipe; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:subprocess; 123, identifier:Popen; 124, argument_list; 124, 125; 124, 126; 124, 129; 124, 132; 125, identifier:cmd; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:stdout; 128, identifier:stdout; 129, keyword_argument; 129, 130; 129, 131; 130, identifier:stderr; 131, identifier:stderr; 132, keyword_argument; 132, 133; 132, 134; 133, identifier:shell; 134, identifier:shell; 135, except_clause; 135, 136; 135, 140; 136, as_pattern; 136, 137; 136, 138; 137, identifier:Exception; 138, as_pattern_target; 138, 139; 139, identifier:e; 140, block; 140, 141; 140, 172; 141, try_statement; 141, 142; 141, 163; 142, block; 142, 143; 143, if_statement; 143, 144; 143, 147; 143, 157; 144, comparison_operator:is; 144, 145; 144, 146; 145, identifier:shell; 146, True; 147, block; 147, 148; 148, expression_statement; 148, 149; 149, assignment; 149, 150; 149, 151; 150, identifier:cmdStr; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, string:' '; 154, identifier:join; 155, argument_list; 155, 156; 156, identifier:cmd; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:cmdStr; 162, identifier:cmd; 163, except_clause; 163, 164; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:cmdStr; 168, call; 168, 169; 168, 170; 169, identifier:repr; 170, argument_list; 170, 171; 171, identifier:cmd; 172, raise_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:SimpleCommandFailure; 175, argument_list; 175, 176; 175, 184; 176, binary_operator:%; 176, 177; 176, 178; 177, string:'Failed to execute "%s": %s'; 178, tuple; 178, 179; 178, 180; 179, identifier:cmdStr; 180, call; 180, 181; 180, 182; 181, identifier:str; 182, argument_list; 182, 183; 183, identifier:e; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:returnCode; 186, integer:255; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:streams; 190, list:[]; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:fileNoToKey; 194, dictionary; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:ret; 198, dictionary; 199, if_statement; 199, 200; 199, 205; 200, comparison_operator:==; 200, 201; 200, 202; 201, identifier:stdout; 202, attribute; 202, 203; 202, 204; 203, identifier:subprocess; 204, identifier:PIPE; 205, block; 205, 206; 205, 215; 205, 227; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:streams; 210, identifier:append; 211, argument_list; 211, 212; 212, attribute; 212, 213; 212, 214; 213, identifier:pipe; 214, identifier:stdout; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 226; 217, subscript; 217, 218; 217, 219; 218, identifier:fileNoToKey; 219, call; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:pipe; 223, identifier:stdout; 224, identifier:fileno; 225, argument_list; 226, string:'stdout'; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 232; 229, subscript; 229, 230; 229, 231; 230, identifier:ret; 231, string:'stdout'; 232, list:[]; 233, if_statement; 233, 234; 233, 239; 234, comparison_operator:==; 234, 235; 234, 236; 235, identifier:stderr; 236, attribute; 236, 237; 236, 238; 237, identifier:subprocess; 238, identifier:PIPE; 239, block; 239, 240; 239, 249; 239, 261; 240, expression_statement; 240, 241; 241, call; 241, 242; 241, 245; 242, attribute; 242, 243; 242, 244; 243, identifier:streams; 244, identifier:append; 245, argument_list; 245, 246; 246, attribute; 246, 247; 246, 248; 247, identifier:pipe; 248, identifier:stderr; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 260; 251, subscript; 251, 252; 251, 253; 252, identifier:fileNoToKey; 253, call; 253, 254; 253, 259; 254, attribute; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:pipe; 257, identifier:stderr; 258, identifier:fileno; 259, argument_list; 260, string:'stderr'; 261, expression_statement; 261, 262; 262, assignment; 262, 263; 262, 266; 263, subscript; 263, 264; 263, 265; 264, identifier:ret; 265, string:'stderr'; 266, list:[]; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:returnCode; 270, None; 271, expression_statement; 271, 272; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:time; 275, identifier:sleep; 276, argument_list; 276, 277; 277, float:.02; 278, while_statement; 278, 279; 278, 284; 279, boolean_operator:or; 279, 280; 279, 283; 280, comparison_operator:is; 280, 281; 280, 282; 281, identifier:returnCode; 282, None; 283, identifier:streams; 284, block; 284, 285; 284, 293; 285, expression_statement; 285, 286; 286, assignment; 286, 287; 286, 288; 287, identifier:returnCode; 288, call; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:pipe; 291, identifier:poll; 292, argument_list; 293, while_statement; 293, 294; 293, 295; 294, True; 295, block; 295, 296; 295, 311; 295, 323; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 302; 298, tuple_pattern; 298, 299; 298, 300; 298, 301; 299, identifier:readyToRead; 300, identifier:junk1; 301, identifier:junk2; 302, call; 302, 303; 302, 306; 303, attribute; 303, 304; 303, 305; 304, identifier:select; 305, identifier:select; 306, argument_list; 306, 307; 306, 308; 306, 309; 306, 310; 307, identifier:streams; 308, list:[]; 309, list:[]; 310, float:.005; 311, if_statement; 311, 312; 311, 314; 312, not_operator; 312, 313; 313, identifier:readyToRead; 314, block; 314, 315; 314, 322; 315, expression_statement; 315, 316; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:time; 319, identifier:sleep; 320, argument_list; 320, 321; 321, float:.01; 322, break_statement; 323, for_statement; 323, 324; 323, 325; 323, 326; 324, identifier:readyStream; 325, identifier:readyToRead; 326, block; 326, 327; 326, 337; 326, 345; 326, 360; 327, expression_statement; 327, 328; 328, assignment; 328, 329; 328, 330; 329, identifier:retKey; 330, subscript; 330, 331; 330, 332; 331, identifier:fileNoToKey; 332, call; 332, 333; 332, 336; 333, attribute; 333, 334; 333, 335; 334, identifier:readyStream; 335, identifier:fileno; 336, argument_list; 337, expression_statement; 337, 338; 338, assignment; 338, 339; 338, 340; 339, identifier:curRead; 340, call; 340, 341; 340, 344; 341, attribute; 341, 342; 341, 343; 342, identifier:readyStream; 343, identifier:read; 344, argument_list; 345, if_statement; 345, 346; 345, 351; 346, comparison_operator:in; 346, 347; 346, 348; 347, identifier:curRead; 348, tuple; 348, 349; 348, 350; 349, string:b''; 350, string:''; 351, block; 351, 352; 351, 359; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 357; 354, attribute; 354, 355; 354, 356; 355, identifier:streams; 356, identifier:remove; 357, argument_list; 357, 358; 358, identifier:readyStream; 359, continue_statement; 360, expression_statement; 360, 361; 361, call; 361, 362; 361, 367; 362, attribute; 362, 363; 362, 366; 363, subscript; 363, 364; 363, 365; 364, identifier:ret; 365, identifier:retKey; 366, identifier:append; 367, argument_list; 367, 368; 368, identifier:curRead; 369, for_statement; 369, 370; 369, 371; 369, 379; 370, identifier:key; 371, call; 371, 372; 371, 373; 372, identifier:list; 373, argument_list; 373, 374; 374, call; 374, 375; 374, 378; 375, attribute; 375, 376; 375, 377; 376, identifier:ret; 377, identifier:keys; 378, argument_list; 379, block; 379, 380; 379, 393; 380, expression_statement; 380, 381; 381, assignment; 381, 382; 381, 385; 382, subscript; 382, 383; 382, 384; 383, identifier:ret; 384, identifier:key; 385, call; 385, 386; 385, 389; 386, attribute; 386, 387; 386, 388; 387, string:b''; 388, identifier:join; 389, argument_list; 389, 390; 390, subscript; 390, 391; 390, 392; 391, identifier:ret; 392, identifier:key; 393, if_statement; 393, 394; 393, 395; 394, identifier:encoding; 395, block; 395, 396; 396, expression_statement; 396, 397; 397, assignment; 397, 398; 397, 401; 398, subscript; 398, 399; 398, 400; 399, identifier:ret; 400, identifier:key; 401, call; 401, 402; 401, 407; 402, attribute; 402, 403; 402, 406; 403, subscript; 403, 404; 403, 405; 404, identifier:ret; 405, identifier:key; 406, identifier:decode; 407, argument_list; 407, 408; 408, identifier:encoding; 409, expression_statement; 409, 410; 410, assignment; 410, 411; 410, 414; 411, subscript; 411, 412; 411, 413; 412, identifier:ret; 413, string:'returnCode'; 414, identifier:returnCode; 415, return_statement; 415, 416; 416, identifier:ret | def runGetResults(cmd, stdout=True, stderr=True, encoding=sys.getdefaultencoding()):
'''
runGetResults - Simple method to run a command and return the results of the execution as a dict.
@param cmd <str/list> - String of command and arguments, or list of command and arguments
If cmd is a string, the command will be executed as if ran exactly as written in a shell. This mode supports shell-isms like '&&' and '|'
If cmd is a list, the first element will be the executable, and further elements are arguments that will be passed to that executable.
@param stdout <True/False> - Default True, Whether to gather and include program's stdout data in results.
If False, that data the program prints to stdout will just be output to the current tty and not recorded.
If True, it will NOT be output to the tty, and will be recorded under the key "stdout" in the return dict.
@param stderr <True/False or "stdout"/subprocess.STDOUT> - Default True, Whether to gather and include program's stderr data in results, or to combine with "stdout" data.
If False, the data the program prints to stderr will just be output to the current tty and not recorded
If True, it will NOT be output to the tty, and will be recorded under the key "stderr" in the return dict.
If "stdout" or subprocess.STDOUT - stderr data will be blended with stdout data. This requires that stdout=True.
@param encoding <None/str> - Default sys.getdefaultencoding(), the program's output will automatically be decoded using the provided codec (e.x. "utf-8" or "ascii").
If None or False-ish, data will not be decoded (i.e. in python3 will be "bytes" type)
If unsure, leave this as it's default value, or provide "utf-8"
@return <dict> - Dict of results. Has following keys:
'returnCode' - <int> - Always present, included the integer return-code from the command.
'stdout' <unciode/str/bytes (depending on
'stderr' <unicode/str/bytes (depending on
@raises - SimpleCommandFailure if it cannot launch the given command, for reasons such as: cannot find the executable, or no permission to execute, etc
'''
if stderr in ('stdout', subprocess.STDOUT):
stderr = subprocess.STDOUT
elif stderr == True or stderr == subprocess.PIPE:
stderr = subprocess.PIPE
else:
stderr = None
if stdout == True or stdout == subprocess.STDOUT:
stdout = subprocess.PIPE
else:
stdout = None
if stderr == subprocess.PIPE:
raise ValueError('Cannot redirect stderr to stdout if stdout is not captured.')
if issubclass(cmd.__class__, (list, tuple)):
shell = False
else:
shell = True
try:
pipe = subprocess.Popen(cmd, stdout=stdout, stderr=stderr, shell=shell)
except Exception as e:
try:
if shell is True:
cmdStr = ' '.join(cmd)
else:
cmdStr = cmd
except:
cmdStr = repr(cmd)
raise SimpleCommandFailure('Failed to execute "%s": %s' %(cmdStr, str(e)), returnCode=255)
streams = []
fileNoToKey = {}
ret = {}
if stdout == subprocess.PIPE:
streams.append(pipe.stdout)
fileNoToKey[pipe.stdout.fileno()] = 'stdout'
ret['stdout'] = []
if stderr == subprocess.PIPE:
streams.append(pipe.stderr)
fileNoToKey[pipe.stderr.fileno()] = 'stderr'
ret['stderr'] = []
returnCode = None
time.sleep(.02)
while returnCode is None or streams:
returnCode = pipe.poll()
while True:
(readyToRead, junk1, junk2) = select.select(streams, [], [], .005)
if not readyToRead:
time.sleep(.01)
break
for readyStream in readyToRead:
retKey = fileNoToKey[readyStream.fileno()]
curRead = readyStream.read()
if curRead in (b'', ''):
streams.remove(readyStream)
continue
ret[retKey].append(curRead)
for key in list(ret.keys()):
ret[key] = b''.join(ret[key])
if encoding:
ret[key] = ret[key].decode(encoding)
ret['returnCode'] = returnCode
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_pathway_feature_permutation; 3, parameters; 3, 4; 3, 5; 4, identifier:pathway_feature_tuples; 5, identifier:permutation_max_iters; 6, block; 6, 7; 6, 24; 6, 31; 6, 38; 6, 42; 6, 46; 6, 245; 6, 252; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 12; 9, pattern_list; 9, 10; 9, 11; 10, identifier:pathways; 11, identifier:features; 12, list_comprehension; 12, 13; 12, 17; 13, call; 13, 14; 13, 15; 14, identifier:list; 15, argument_list; 15, 16; 16, identifier:elements_at_position; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:elements_at_position; 19, call; 19, 20; 19, 21; 20, identifier:zip; 21, argument_list; 21, 22; 22, list_splat; 22, 23; 23, identifier:pathway_feature_tuples; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:original_pathways; 27, subscript; 27, 28; 27, 29; 28, identifier:pathways; 29, slice; 29, 30; 30, colon; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:random; 35, identifier:shuffle; 36, argument_list; 36, 37; 37, identifier:pathways; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:feature_block_locations; 41, dictionary; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:i; 45, integer:0; 46, while_statement; 46, 47; 46, 53; 47, comparison_operator:<; 47, 48; 47, 49; 48, identifier:i; 49, call; 49, 50; 49, 51; 50, identifier:len; 51, argument_list; 51, 52; 52, identifier:pathways; 53, block; 53, 54; 53, 58; 53, 64; 53, 70; 53, 233; 53, 237; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:starting_index; 57, identifier:i; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:current_feature; 61, subscript; 61, 62; 61, 63; 62, identifier:features; 63, identifier:i; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:pathway_set; 67, call; 67, 68; 67, 69; 68, identifier:set; 69, argument_list; 70, while_statement; 70, 71; 70, 83; 71, boolean_operator:and; 71, 72; 71, 78; 72, comparison_operator:<; 72, 73; 72, 74; 73, identifier:i; 74, call; 74, 75; 74, 76; 75, identifier:len; 76, argument_list; 76, 77; 77, identifier:pathways; 78, comparison_operator:==; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:features; 81, identifier:i; 82, identifier:current_feature; 83, block; 83, 84; 83, 229; 84, if_statement; 84, 85; 84, 90; 84, 100; 85, comparison_operator:not; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:pathways; 88, identifier:i; 89, identifier:pathway_set; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:pathway_set; 95, identifier:add; 96, argument_list; 96, 97; 97, subscript; 97, 98; 97, 99; 98, identifier:pathways; 99, identifier:i; 100, else_clause; 100, 101; 101, block; 101, 102; 101, 106; 101, 110; 101, 208; 101, 215; 101, 223; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:k; 105, integer:0; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:random_pathway; 109, None; 110, while_statement; 110, 111; 110, 112; 111, True; 112, block; 112, 113; 112, 129; 112, 135; 112, 141; 112, 185; 112, 189; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:j; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:random; 119, identifier:choice; 120, argument_list; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:range; 123, argument_list; 123, 124; 123, 125; 124, integer:0; 125, call; 125, 126; 125, 127; 126, identifier:len; 127, argument_list; 127, 128; 128, identifier:pathways; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:random_pathway; 132, subscript; 132, 133; 132, 134; 133, identifier:pathways; 134, identifier:j; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:random_feature; 138, subscript; 138, 139; 138, 140; 139, identifier:features; 140, identifier:j; 141, if_statement; 141, 142; 141, 152; 142, parenthesized_expression; 142, 143; 143, boolean_operator:and; 143, 144; 143, 149; 144, comparison_operator:!=; 144, 145; 144, 146; 145, identifier:random_pathway; 146, subscript; 146, 147; 146, 148; 147, identifier:pathways; 148, identifier:i; 149, comparison_operator:not; 149, 150; 149, 151; 150, identifier:random_pathway; 151, identifier:pathway_set; 152, block; 152, 153; 152, 159; 152, 168; 152, 177; 153, if_statement; 153, 154; 153, 157; 154, comparison_operator:not; 154, 155; 154, 156; 155, identifier:random_feature; 156, identifier:feature_block_locations; 157, block; 157, 158; 158, break_statement; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 164; 160, 165; 161, pattern_list; 161, 162; 161, 163; 162, identifier:feature_block_start; 163, identifier:feature_block_end; 164, line_continuation:\; 165, subscript; 165, 166; 165, 167; 166, identifier:feature_block_locations; 167, identifier:random_feature; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:pathway_block; 171, subscript; 171, 172; 171, 173; 172, identifier:pathways; 173, slice; 173, 174; 173, 175; 173, 176; 174, identifier:feature_block_start; 175, colon; 176, identifier:feature_block_end; 177, if_statement; 177, 178; 177, 183; 178, comparison_operator:not; 178, 179; 178, 182; 179, subscript; 179, 180; 179, 181; 180, identifier:pathways; 181, identifier:i; 182, identifier:pathway_block; 183, block; 183, 184; 184, break_statement; 185, expression_statement; 185, 186; 186, augmented_assignment:+=; 186, 187; 186, 188; 187, identifier:k; 188, integer:1; 189, if_statement; 189, 190; 189, 193; 190, comparison_operator:>; 190, 191; 190, 192; 191, identifier:k; 192, identifier:permutation_max_iters; 193, block; 193, 194; 193, 206; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 197; 196, identifier:print; 197, argument_list; 197, 198; 198, call; 198, 199; 198, 204; 199, attribute; 199, 200; 199, 203; 200, concatenated_string; 200, 201; 200, 202; 201, string:"Permutation step: reached the maximum "; 202, string:"number of iterations {0}."; 203, identifier:format; 204, argument_list; 204, 205; 205, identifier:permutation_max_iters; 206, return_statement; 206, 207; 207, None; 208, expression_statement; 208, 209; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, identifier:pathway_set; 212, identifier:add; 213, argument_list; 213, 214; 214, identifier:random_pathway; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 220; 217, subscript; 217, 218; 217, 219; 218, identifier:pathways; 219, identifier:j; 220, subscript; 220, 221; 220, 222; 221, identifier:pathways; 222, identifier:i; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 228; 225, subscript; 225, 226; 225, 227; 226, identifier:pathways; 227, identifier:i; 228, identifier:random_pathway; 229, expression_statement; 229, 230; 230, augmented_assignment:+=; 230, 231; 230, 232; 231, identifier:i; 232, integer:1; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:ending_index; 236, identifier:i; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:feature_block_locations; 241, identifier:current_feature; 242, tuple; 242, 243; 242, 244; 243, identifier:starting_index; 244, identifier:ending_index; 245, if_statement; 245, 246; 245, 249; 246, comparison_operator:==; 246, 247; 246, 248; 247, identifier:original_pathways; 248, identifier:pathways; 249, block; 249, 250; 250, return_statement; 250, 251; 251, None; 252, return_statement; 252, 253; 253, call; 253, 254; 253, 255; 254, identifier:list; 255, argument_list; 255, 256; 256, call; 256, 257; 256, 258; 257, identifier:zip; 258, argument_list; 258, 259; 258, 260; 259, identifier:pathways; 260, identifier:features | def _pathway_feature_permutation(pathway_feature_tuples,
permutation_max_iters):
pathways, features = [list(elements_at_position)
for elements_at_position in
zip(*pathway_feature_tuples)]
original_pathways = pathways[:]
random.shuffle(pathways)
feature_block_locations = {}
i = 0
while i < len(pathways):
starting_index = i
current_feature = features[i]
pathway_set = set()
while i < len(pathways) and features[i] == current_feature:
if pathways[i] not in pathway_set:
pathway_set.add(pathways[i])
else:
k = 0
random_pathway = None
while True:
j = random.choice(range(0, len(pathways)))
random_pathway = pathways[j]
random_feature = features[j]
if (random_pathway != pathways[i] and
random_pathway not in pathway_set):
if random_feature not in feature_block_locations:
break
feature_block_start, feature_block_end = \
feature_block_locations[random_feature]
pathway_block = pathways[feature_block_start:
feature_block_end]
if pathways[i] not in pathway_block:
break
k += 1
if k > permutation_max_iters:
print("Permutation step: reached the maximum "
"number of iterations {0}.".format(
permutation_max_iters))
return None
pathway_set.add(random_pathway)
pathways[j] = pathways[i]
pathways[i] = random_pathway
i += 1
ending_index = i
feature_block_locations[current_feature] = (
starting_index, ending_index)
if original_pathways == pathways:
return None
return list(zip(pathways, features)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_field_infos; 3, parameters; 3, 4; 3, 5; 4, identifier:code; 5, identifier:free_format; 6, block; 6, 7; 6, 11; 6, 15; 6, 22; 6, 26; 6, 190; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:offset; 10, integer:0; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:field_infos; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:lines; 18, call; 18, 19; 18, 20; 19, identifier:_clean_code; 20, argument_list; 20, 21; 21, identifier:code; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:previous_offset; 25, integer:0; 26, for_statement; 26, 27; 26, 28; 26, 33; 27, identifier:row; 28, call; 28, 29; 28, 30; 29, identifier:process_cobol; 30, argument_list; 30, 31; 30, 32; 31, identifier:lines; 32, identifier:free_format; 33, block; 33, 34; 33, 40; 33, 48; 33, 56; 33, 64; 33, 72; 33, 80; 33, 88; 33, 112; 33, 123; 33, 134; 33, 145; 33, 151; 33, 170; 33, 177; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:fi; 37, call; 37, 38; 37, 39; 38, identifier:PicFieldInfo; 39, argument_list; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:fi; 44, identifier:name; 45, subscript; 45, 46; 45, 47; 46, identifier:row; 47, string:"name"; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:fi; 52, identifier:level; 53, subscript; 53, 54; 53, 55; 54, identifier:row; 55, string:"level"; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:fi; 60, identifier:pic; 61, subscript; 61, 62; 61, 63; 62, identifier:row; 63, string:"pic"; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:fi; 68, identifier:occurs; 69, subscript; 69, 70; 69, 71; 70, identifier:row; 71, string:"occurs"; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:fi; 76, identifier:redefines; 77, subscript; 77, 78; 77, 79; 78, identifier:row; 79, string:"redefines"; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:fi; 84, identifier:indexed_by; 85, subscript; 85, 86; 85, 87; 86, identifier:row; 87, string:"indexed_by"; 88, if_statement; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:fi; 91, identifier:redefines; 92, block; 92, 93; 93, for_statement; 93, 94; 93, 95; 93, 96; 94, identifier:fib; 95, identifier:field_infos; 96, block; 96, 97; 97, if_statement; 97, 98; 97, 105; 98, comparison_operator:==; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:fib; 101, identifier:name; 102, attribute; 102, 103; 102, 104; 103, identifier:fi; 104, identifier:redefines; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:offset; 109, attribute; 109, 110; 109, 111; 110, identifier:fib; 111, identifier:offset; 112, if_statement; 112, 113; 112, 118; 113, comparison_operator:==; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:fi; 116, identifier:level; 117, integer:1; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:offset; 122, integer:1; 123, if_statement; 123, 124; 123, 129; 124, comparison_operator:==; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:fi; 127, identifier:level; 128, integer:78; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:offset; 133, integer:0; 134, if_statement; 134, 135; 134, 140; 135, comparison_operator:==; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:fi; 138, identifier:level; 139, integer:77; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:offset; 144, integer:1; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:fi; 149, identifier:offset; 150, identifier:offset; 151, if_statement; 151, 152; 151, 157; 151, 164; 152, comparison_operator:==; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:fi; 155, identifier:level; 156, integer:88; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:fi; 162, identifier:offset; 163, identifier:previous_offset; 164, else_clause; 164, 165; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:previous_offset; 169, identifier:offset; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:field_infos; 174, identifier:append; 175, argument_list; 175, 176; 176, identifier:fi; 177, if_statement; 177, 178; 177, 181; 178, subscript; 178, 179; 178, 180; 179, identifier:row; 180, string:'pic'; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, augmented_assignment:+=; 183, 184; 183, 185; 184, identifier:offset; 185, subscript; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:row; 188, string:'pic_info'; 189, string:'length'; 190, return_statement; 190, 191; 191, identifier:field_infos | def get_field_infos(code, free_format):
offset = 0
field_infos = []
lines = _clean_code(code)
previous_offset = 0
for row in process_cobol(lines, free_format):
fi = PicFieldInfo()
fi.name = row["name"]
fi.level = row["level"]
fi.pic = row["pic"]
fi.occurs = row["occurs"]
fi.redefines = row["redefines"]
fi.indexed_by = row["indexed_by"]
if fi.redefines:
for fib in field_infos:
if fib.name == fi.redefines:
offset = fib.offset
if fi.level == 1:
offset = 1
if fi.level == 78:
offset = 0
if fi.level == 77:
offset = 1
fi.offset = offset
if fi.level == 88:
fi.offset = previous_offset
else:
previous_offset = offset
field_infos.append(fi)
if row['pic']:
offset += row['pic_info']['length']
return field_infos |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_advanced_acronym_detection; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:s; 5, identifier:i; 6, identifier:words; 7, identifier:acronyms; 8, block; 8, 9; 8, 23; 8, 27; 8, 40; 8, 151; 8, 166; 8, 172; 8, 184; 8, 219; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:acstr; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, string:''; 15, identifier:join; 16, argument_list; 16, 17; 17, subscript; 17, 18; 17, 19; 18, identifier:words; 19, slice; 19, 20; 19, 21; 19, 22; 20, identifier:s; 21, colon; 22, identifier:i; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:range_list; 26, list:[]; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:not_range; 30, call; 30, 31; 30, 32; 31, identifier:set; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:range; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:acstr; 40, for_statement; 40, 41; 40, 42; 40, 43; 41, identifier:acronym; 42, identifier:acronyms; 43, block; 43, 44; 43, 56; 43, 60; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:rac; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:regex; 50, identifier:compile; 51, argument_list; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:unicode; 54, argument_list; 54, 55; 55, identifier:acronym; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:n; 59, integer:0; 60, while_statement; 60, 61; 60, 62; 61, True; 62, block; 62, 63; 62, 73; 62, 78; 62, 94; 62, 98; 62, 102; 62, 124; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:m; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:rac; 69, identifier:search; 70, argument_list; 70, 71; 70, 72; 71, identifier:acstr; 72, identifier:n; 73, if_statement; 73, 74; 73, 76; 74, not_operator; 74, 75; 75, identifier:m; 76, block; 76, 77; 77, break_statement; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, pattern_list; 80, 81; 80, 82; 81, identifier:a; 82, identifier:b; 83, expression_list; 83, 84; 83, 89; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:m; 87, identifier:start; 88, argument_list; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:m; 92, identifier:end; 93, argument_list; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:n; 97, identifier:b; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:ok; 101, True; 102, for_statement; 102, 103; 102, 104; 102, 105; 103, identifier:r; 104, identifier:range_list; 105, block; 105, 106; 106, if_statement; 106, 107; 106, 118; 107, boolean_operator:and; 107, 108; 107, 113; 108, comparison_operator:<; 108, 109; 108, 110; 109, identifier:a; 110, subscript; 110, 111; 110, 112; 111, identifier:r; 112, integer:1; 113, comparison_operator:>; 113, 114; 113, 115; 114, identifier:b; 115, subscript; 115, 116; 115, 117; 116, identifier:r; 117, integer:0; 118, block; 118, 119; 118, 123; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:ok; 122, False; 123, break_statement; 124, if_statement; 124, 125; 124, 126; 125, identifier:ok; 126, block; 126, 127; 126, 136; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:range_list; 131, identifier:append; 132, argument_list; 132, 133; 133, tuple; 133, 134; 133, 135; 134, identifier:a; 135, identifier:b; 136, for_statement; 136, 137; 136, 138; 136, 143; 137, identifier:j; 138, call; 138, 139; 138, 140; 139, identifier:xrange; 140, argument_list; 140, 141; 140, 142; 141, identifier:a; 142, identifier:b; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:not_range; 148, identifier:remove; 149, argument_list; 149, 150; 150, identifier:j; 151, for_statement; 151, 152; 151, 153; 151, 154; 152, identifier:nr; 153, identifier:not_range; 154, block; 154, 155; 155, expression_statement; 155, 156; 156, call; 156, 157; 156, 160; 157, attribute; 157, 158; 157, 159; 158, identifier:range_list; 159, identifier:append; 160, argument_list; 160, 161; 161, tuple; 161, 162; 161, 163; 162, identifier:nr; 163, binary_operator:+; 163, 164; 163, 165; 164, identifier:nr; 165, integer:1; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:range_list; 170, identifier:sort; 171, argument_list; 172, for_statement; 172, 173; 172, 174; 172, 179; 173, identifier:_; 174, call; 174, 175; 174, 176; 175, identifier:xrange; 176, argument_list; 176, 177; 176, 178; 177, identifier:s; 178, identifier:i; 179, block; 179, 180; 180, delete_statement; 180, 181; 181, subscript; 181, 182; 181, 183; 182, identifier:words; 183, identifier:s; 184, for_statement; 184, 185; 184, 186; 184, 193; 185, identifier:j; 186, call; 186, 187; 186, 188; 187, identifier:xrange; 188, argument_list; 188, 189; 189, call; 189, 190; 189, 191; 190, identifier:len; 191, argument_list; 191, 192; 192, identifier:range_list; 193, block; 193, 194; 193, 200; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:r; 197, subscript; 197, 198; 197, 199; 198, identifier:range_list; 199, identifier:j; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:words; 204, identifier:insert; 205, argument_list; 205, 206; 205, 209; 206, binary_operator:+; 206, 207; 206, 208; 207, identifier:s; 208, identifier:j; 209, subscript; 209, 210; 209, 211; 210, identifier:acstr; 211, slice; 211, 212; 211, 215; 211, 216; 212, subscript; 212, 213; 212, 214; 213, identifier:r; 214, integer:0; 215, colon; 216, subscript; 216, 217; 216, 218; 217, identifier:r; 218, integer:1; 219, return_statement; 219, 220; 220, binary_operator:-; 220, 221; 220, 227; 221, binary_operator:+; 221, 222; 221, 223; 222, identifier:s; 223, call; 223, 224; 223, 225; 224, identifier:len; 225, argument_list; 225, 226; 226, identifier:range_list; 227, integer:1 | def _advanced_acronym_detection(s, i, words, acronyms):
acstr = ''.join(words[s:i])
range_list = []
not_range = set(range(len(acstr)))
for acronym in acronyms:
rac = regex.compile(unicode(acronym))
n = 0
while True:
m = rac.search(acstr, n)
if not m:
break
a, b = m.start(), m.end()
n = b
ok = True
for r in range_list:
if a < r[1] and b > r[0]:
ok = False
break
if ok:
range_list.append((a, b))
for j in xrange(a, b):
not_range.remove(j)
for nr in not_range:
range_list.append((nr, nr + 1))
range_list.sort()
for _ in xrange(s, i):
del words[s]
for j in xrange(len(range_list)):
r = range_list[j]
words.insert(s + j, acstr[r[0]:r[1]])
return s + len(range_list) - 1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_separate_words; 3, parameters; 3, 4; 4, identifier:string; 5, block; 5, 6; 5, 10; 5, 14; 5, 18; 5, 22; 5, 31; 5, 35; 5, 54; 5, 200; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:words; 9, list:[]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:separator; 13, string:""; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:i; 17, integer:1; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:s; 21, integer:0; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:p; 25, subscript; 25, 26; 25, 27; 26, identifier:string; 27, slice; 27, 28; 27, 29; 27, 30; 28, integer:0; 29, colon; 30, integer:1; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:was_upper; 34, False; 35, if_statement; 35, 36; 35, 41; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:string; 39, identifier:isupper; 40, argument_list; 41, block; 41, 42; 41, 50; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:string; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:string; 48, identifier:lower; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:was_upper; 53, True; 54, while_statement; 54, 55; 54, 61; 55, comparison_operator:<=; 55, 56; 55, 57; 56, identifier:i; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:string; 61, block; 61, 62; 61, 73; 61, 77; 61, 141; 61, 192; 61, 196; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:c; 65, subscript; 65, 66; 65, 67; 66, identifier:string; 67, slice; 67, 68; 67, 69; 67, 70; 68, identifier:i; 69, colon; 70, binary_operator:+; 70, 71; 70, 72; 71, identifier:i; 72, integer:1; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:split; 76, False; 77, if_statement; 77, 78; 77, 84; 77, 135; 78, comparison_operator:<; 78, 79; 78, 80; 79, identifier:i; 80, call; 80, 81; 80, 82; 81, identifier:len; 82, argument_list; 82, 83; 83, identifier:string; 84, block; 84, 85; 85, if_statement; 85, 86; 85, 92; 85, 97; 85, 116; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:UPPER; 89, identifier:match; 90, argument_list; 90, 91; 91, identifier:c; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:split; 96, True; 97, elif_clause; 97, 98; 97, 111; 98, boolean_operator:and; 98, 99; 98, 105; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:NOTSEP; 102, identifier:match; 103, argument_list; 103, 104; 104, identifier:c; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:SEP; 108, identifier:match; 109, argument_list; 109, 110; 110, identifier:p; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:split; 115, True; 116, elif_clause; 116, 117; 116, 130; 117, boolean_operator:and; 117, 118; 117, 124; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:SEP; 121, identifier:match; 122, argument_list; 122, 123; 123, identifier:c; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:NOTSEP; 127, identifier:match; 128, argument_list; 128, 129; 129, identifier:p; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:split; 134, True; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:split; 140, True; 141, if_statement; 141, 142; 141, 143; 142, identifier:split; 143, block; 143, 144; 143, 188; 144, if_statement; 144, 145; 144, 151; 144, 164; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:NOTSEP; 148, identifier:match; 149, argument_list; 149, 150; 150, identifier:p; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:words; 156, identifier:append; 157, argument_list; 157, 158; 158, subscript; 158, 159; 158, 160; 159, identifier:string; 160, slice; 160, 161; 160, 162; 160, 163; 161, identifier:s; 162, colon; 163, identifier:i; 164, else_clause; 164, 165; 165, block; 165, 166; 165, 181; 166, if_statement; 166, 167; 166, 169; 167, not_operator; 167, 168; 168, identifier:separator; 169, block; 169, 170; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:separator; 173, subscript; 173, 174; 173, 175; 174, identifier:string; 175, slice; 175, 176; 175, 177; 175, 178; 176, identifier:s; 177, colon; 178, binary_operator:+; 178, 179; 178, 180; 179, identifier:s; 180, integer:1; 181, expression_statement; 181, 182; 182, call; 182, 183; 182, 186; 183, attribute; 183, 184; 183, 185; 184, identifier:words; 185, identifier:append; 186, argument_list; 186, 187; 187, None; 188, expression_statement; 188, 189; 189, assignment; 189, 190; 189, 191; 190, identifier:s; 191, identifier:i; 192, expression_statement; 192, 193; 193, augmented_assignment:+=; 193, 194; 193, 195; 194, identifier:i; 195, integer:1; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:p; 199, identifier:c; 200, return_statement; 200, 201; 201, expression_list; 201, 202; 201, 203; 201, 204; 202, identifier:words; 203, identifier:separator; 204, identifier:was_upper | def _separate_words(string):
words = []
separator = ""
i = 1
s = 0
p = string[0:1]
was_upper = False
if string.isupper():
string = string.lower()
was_upper = True
while i <= len(string):
c = string[i:i + 1]
split = False
if i < len(string):
if UPPER.match(c):
split = True
elif NOTSEP.match(c) and SEP.match(p):
split = True
elif SEP.match(c) and NOTSEP.match(p):
split = True
else:
split = True
if split:
if NOTSEP.match(p):
words.append(string[s:i])
else:
if not separator:
separator = string[s:s + 1]
words.append(None)
s = i
i += 1
p = c
return words, separator, was_upper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:parse_case; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:string; 5, default_parameter; 5, 6; 5, 7; 6, identifier:acronyms; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:preserve_case; 10, False; 11, block; 11, 12; 11, 22; 11, 46; 11, 50; 11, 54; 11, 114; 11, 127; 11, 139; 11, 148; 11, 176; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 18; 14, pattern_list; 14, 15; 14, 16; 14, 17; 15, identifier:words; 16, identifier:separator; 17, identifier:was_upper; 18, call; 18, 19; 18, 20; 19, identifier:_separate_words; 20, argument_list; 20, 21; 21, identifier:string; 22, if_statement; 22, 23; 22, 24; 22, 36; 23, identifier:acronyms; 24, block; 24, 25; 24, 32; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:acronyms; 28, call; 28, 29; 28, 30; 29, identifier:_sanitize_acronyms; 30, argument_list; 30, 31; 31, identifier:acronyms; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:check_acronym; 35, identifier:_advanced_acronym_detection; 36, else_clause; 36, 37; 37, block; 37, 38; 37, 42; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:acronyms; 41, list:[]; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:check_acronym; 45, identifier:_simple_acronym_detection; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:i; 49, integer:0; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:s; 53, None; 54, while_statement; 54, 55; 54, 61; 55, comparison_operator:<; 55, 56; 55, 57; 56, identifier:i; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:words; 61, block; 61, 62; 61, 68; 61, 110; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:word; 65, subscript; 65, 66; 65, 67; 66, identifier:words; 67, identifier:i; 68, if_statement; 68, 69; 68, 79; 68, 89; 69, boolean_operator:and; 69, 70; 69, 73; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:word; 72, None; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:UPPER; 76, identifier:match; 77, argument_list; 77, 78; 78, identifier:word; 79, block; 79, 80; 80, if_statement; 80, 81; 80, 84; 81, comparison_operator:is; 81, 82; 81, 83; 82, identifier:s; 83, None; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:s; 88, identifier:i; 89, elif_clause; 89, 90; 89, 93; 90, comparison_operator:is; 90, 91; 90, 92; 91, identifier:s; 92, None; 93, block; 93, 94; 93, 106; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:i; 97, binary_operator:+; 97, 98; 97, 105; 98, call; 98, 99; 98, 100; 99, identifier:check_acronym; 100, argument_list; 100, 101; 100, 102; 100, 103; 100, 104; 101, identifier:s; 102, identifier:i; 103, identifier:words; 104, identifier:acronyms; 105, integer:1; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:s; 109, None; 110, expression_statement; 110, 111; 111, augmented_assignment:+=; 111, 112; 111, 113; 112, identifier:i; 113, integer:1; 114, if_statement; 114, 115; 114, 118; 115, comparison_operator:is; 115, 116; 115, 117; 116, identifier:s; 117, None; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:check_acronym; 122, argument_list; 122, 123; 122, 124; 122, 125; 122, 126; 123, identifier:s; 124, identifier:i; 125, identifier:words; 126, identifier:acronyms; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:words; 130, list_comprehension; 130, 131; 130, 132; 130, 135; 131, identifier:w; 132, for_in_clause; 132, 133; 132, 134; 133, identifier:w; 134, identifier:words; 135, if_clause; 135, 136; 136, comparison_operator:is; 136, 137; 136, 138; 137, identifier:w; 138, None; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:case_type; 142, call; 142, 143; 142, 144; 143, identifier:_determine_case; 144, argument_list; 144, 145; 144, 146; 144, 147; 145, identifier:was_upper; 146, identifier:words; 147, identifier:string; 148, if_statement; 148, 149; 148, 150; 148, 166; 149, identifier:preserve_case; 150, block; 150, 151; 151, if_statement; 151, 152; 151, 153; 152, identifier:was_upper; 153, block; 153, 154; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:words; 157, list_comprehension; 157, 158; 157, 163; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:w; 161, identifier:upper; 162, argument_list; 163, for_in_clause; 163, 164; 163, 165; 164, identifier:w; 165, identifier:words; 166, else_clause; 166, 167; 167, block; 167, 168; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:words; 171, call; 171, 172; 171, 173; 172, identifier:_normalize_words; 173, argument_list; 173, 174; 173, 175; 174, identifier:words; 175, identifier:acronyms; 176, return_statement; 176, 177; 177, expression_list; 177, 178; 177, 179; 177, 180; 178, identifier:words; 179, identifier:case_type; 180, identifier:separator | def parse_case(string, acronyms=None, preserve_case=False):
words, separator, was_upper = _separate_words(string)
if acronyms:
acronyms = _sanitize_acronyms(acronyms)
check_acronym = _advanced_acronym_detection
else:
acronyms = []
check_acronym = _simple_acronym_detection
i = 0
s = None
while i < len(words):
word = words[i]
if word is not None and UPPER.match(word):
if s is None:
s = i
elif s is not None:
i = check_acronym(s, i, words, acronyms) + 1
s = None
i += 1
if s is not None:
check_acronym(s, i, words, acronyms)
words = [w for w in words if w is not None]
case_type = _determine_case(was_upper, words, string)
if preserve_case:
if was_upper:
words = [w.upper() for w in words]
else:
words = _normalize_words(words, acronyms)
return words, case_type, separator |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:listen; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 17; 5, 21; 5, 42; 5, 52; 5, 66; 5, 73; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:db; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:config; 14, identifier:get_database; 15, argument_list; 15, 16; 16, string:'control'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:kwargs; 20, dictionary; 21, if_statement; 21, 22; 21, 29; 22, comparison_operator:in; 22, 23; 22, 24; 23, string:'shard_hint'; 24, subscript; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:config; 28, string:'control'; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:kwargs; 34, string:'shard_hint'; 35, subscript; 35, 36; 35, 41; 36, subscript; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:config; 40, string:'control'; 41, string:'shard_hint'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:pubsub; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:db; 48, identifier:pubsub; 49, argument_list; 49, 50; 50, dictionary_splat; 50, 51; 51, identifier:kwargs; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:channel; 55, call; 55, 56; 55, 63; 56, attribute; 56, 57; 56, 62; 57, subscript; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:config; 61, string:'control'; 62, identifier:get; 63, argument_list; 63, 64; 63, 65; 64, string:'channel'; 65, string:'control'; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:pubsub; 70, identifier:subscribe; 71, argument_list; 71, 72; 72, identifier:channel; 73, for_statement; 73, 74; 73, 75; 73, 80; 74, identifier:msg; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:pubsub; 78, identifier:listen; 79, argument_list; 80, block; 80, 81; 81, if_statement; 81, 82; 81, 96; 82, parenthesized_expression; 82, 83; 83, boolean_operator:and; 83, 84; 83, 91; 84, comparison_operator:in; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:msg; 87, string:'type'; 88, tuple; 88, 89; 88, 90; 89, string:'pmessage'; 90, string:'message'; 91, comparison_operator:==; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:msg; 94, string:'channel'; 95, identifier:channel; 96, block; 96, 97; 96, 111; 96, 116; 96, 133; 96, 171; 96, 185; 96, 197; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 103; 99, pattern_list; 99, 100; 99, 101; 99, 102; 100, identifier:command; 101, identifier:_sep; 102, identifier:args; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:msg; 107, string:'data'; 108, identifier:partition; 109, argument_list; 109, 110; 110, string:':'; 111, if_statement; 111, 112; 111, 114; 112, not_operator; 112, 113; 113, identifier:command; 114, block; 114, 115; 115, continue_statement; 116, if_statement; 116, 117; 116, 122; 117, comparison_operator:==; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:command; 120, integer:0; 121, string:'_'; 122, block; 122, 123; 122, 132; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:LOG; 127, identifier:error; 128, argument_list; 128, 129; 129, binary_operator:%; 129, 130; 129, 131; 130, string:"Cannot call internal command %r"; 131, identifier:command; 132, continue_statement; 133, if_statement; 133, 134; 133, 139; 133, 148; 134, comparison_operator:in; 134, 135; 134, 136; 135, identifier:command; 136, attribute; 136, 137; 136, 138; 137, identifier:self; 138, identifier:_commands; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:func; 143, subscript; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:_commands; 147, identifier:command; 148, else_clause; 148, 149; 149, block; 149, 150; 149, 163; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:func; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:utils; 156, identifier:find_entrypoint; 157, argument_list; 157, 158; 157, 159; 157, 160; 158, string:'turnstile.command'; 159, identifier:command; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:compat; 162, False; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 170; 165, subscript; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:_commands; 169, identifier:command; 170, identifier:func; 171, if_statement; 171, 172; 171, 174; 172, not_operator; 172, 173; 173, identifier:func; 174, block; 174, 175; 174, 184; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:LOG; 179, identifier:error; 180, argument_list; 180, 181; 181, binary_operator:%; 181, 182; 181, 183; 182, string:"No such command %r"; 183, identifier:command; 184, continue_statement; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:arglist; 188, conditional_expression:if; 188, 189; 188, 195; 188, 196; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:args; 192, identifier:split; 193, argument_list; 193, 194; 194, string:':'; 195, identifier:args; 196, list:[]; 197, try_statement; 197, 198; 197, 206; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 202; 201, identifier:func; 202, argument_list; 202, 203; 202, 204; 203, identifier:self; 204, list_splat; 204, 205; 205, identifier:arglist; 206, except_clause; 206, 207; 206, 208; 207, identifier:Exception; 208, block; 208, 209; 208, 220; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:LOG; 213, identifier:exception; 214, argument_list; 214, 215; 215, binary_operator:%; 215, 216; 215, 217; 216, string:"Failed to execute command %r arguments %r"; 217, tuple; 217, 218; 217, 219; 218, identifier:command; 219, identifier:arglist; 220, continue_statement | def listen(self):
db = self.config.get_database('control')
kwargs = {}
if 'shard_hint' in self.config['control']:
kwargs['shard_hint'] = self.config['control']['shard_hint']
pubsub = db.pubsub(**kwargs)
channel = self.config['control'].get('channel', 'control')
pubsub.subscribe(channel)
for msg in pubsub.listen():
if (msg['type'] in ('pmessage', 'message') and
msg['channel'] == channel):
command, _sep, args = msg['data'].partition(':')
if not command:
continue
if command[0] == '_':
LOG.error("Cannot call internal command %r" % command)
continue
if command in self._commands:
func = self._commands[command]
else:
func = utils.find_entrypoint('turnstile.command', command,
compat=False)
self._commands[command] = func
if not func:
LOG.error("No such command %r" % command)
continue
arglist = args.split(':') if args else []
try:
func(self, *arglist)
except Exception:
LOG.exception("Failed to execute command %r arguments %r" %
(command, arglist))
continue |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:initialize; 3, parameters; 3, 4; 4, identifier:config; 5, block; 5, 6; 5, 34; 5, 38; 5, 64; 5, 80; 5, 84; 5, 88; 5, 92; 5, 199; 5, 208; 5, 228; 5, 309; 5, 316; 6, if_statement; 6, 7; 6, 10; 6, 26; 7, comparison_operator:in; 7, 8; 7, 9; 8, string:'redis_client'; 9, identifier:config; 10, block; 10, 11; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:client; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:utils; 17, identifier:find_entrypoint; 18, argument_list; 18, 19; 18, 20; 18, 23; 19, string:'turnstile.redis_client'; 20, subscript; 20, 21; 20, 22; 21, identifier:config; 22, string:'redis_client'; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:required; 25, True; 26, else_clause; 26, 27; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:client; 31, attribute; 31, 32; 31, 33; 32, identifier:redis; 33, identifier:StrictRedis; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:kwargs; 37, dictionary; 38, for_statement; 38, 39; 38, 42; 38, 47; 39, pattern_list; 39, 40; 39, 41; 40, identifier:cfg_var; 41, identifier:type_; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:REDIS_CONFIGS; 45, identifier:items; 46, argument_list; 47, block; 47, 48; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:cfg_var; 51, identifier:config; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:kwargs; 57, identifier:cfg_var; 58, call; 58, 59; 58, 60; 59, identifier:type_; 60, argument_list; 60, 61; 61, subscript; 61, 62; 61, 63; 62, identifier:config; 63, identifier:cfg_var; 64, if_statement; 64, 65; 64, 72; 65, boolean_operator:and; 65, 66; 65, 69; 66, comparison_operator:not; 66, 67; 66, 68; 67, string:'host'; 68, identifier:kwargs; 69, comparison_operator:not; 69, 70; 69, 71; 70, string:'unix_socket_path'; 71, identifier:kwargs; 72, block; 72, 73; 73, raise_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:redis; 77, identifier:ConnectionError; 78, argument_list; 78, 79; 79, string:"No host specified for redis database"; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:cpool_class; 83, None; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:cpool; 87, dictionary; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:extra_kwargs; 91, dictionary; 92, for_statement; 92, 93; 92, 96; 92, 101; 93, pattern_list; 93, 94; 93, 95; 94, identifier:key; 95, identifier:value; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:config; 99, identifier:items; 100, argument_list; 101, block; 101, 102; 102, if_statement; 102, 103; 102, 109; 102, 184; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:key; 106, identifier:startswith; 107, argument_list; 107, 108; 108, string:'connection_pool.'; 109, block; 109, 110; 109, 122; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 116; 112, pattern_list; 112, 113; 112, 114; 112, 115; 113, identifier:_dummy; 114, identifier:_sep; 115, identifier:varname; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:key; 119, identifier:partition; 120, argument_list; 120, 121; 121, string:'.'; 122, if_statement; 122, 123; 122, 126; 122, 142; 122, 156; 122, 176; 123, comparison_operator:==; 123, 124; 123, 125; 124, identifier:varname; 125, string:'connection_class'; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:cpool; 131, identifier:varname; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:utils; 135, identifier:find_entrypoint; 136, argument_list; 136, 137; 136, 138; 136, 139; 137, string:'turnstile.connection_class'; 138, identifier:value; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:required; 141, True; 142, elif_clause; 142, 143; 142, 146; 143, comparison_operator:==; 143, 144; 143, 145; 144, identifier:varname; 145, string:'max_connections'; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:cpool; 151, identifier:varname; 152, call; 152, 153; 152, 154; 153, identifier:int; 154, argument_list; 154, 155; 155, identifier:value; 156, elif_clause; 156, 157; 156, 160; 157, comparison_operator:==; 157, 158; 157, 159; 158, identifier:varname; 159, string:'parser_class'; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:cpool; 165, identifier:varname; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:utils; 169, identifier:find_entrypoint; 170, argument_list; 170, 171; 170, 172; 170, 173; 171, string:'turnstile.parser_class'; 172, identifier:value; 173, keyword_argument; 173, 174; 173, 175; 174, identifier:required; 175, True; 176, else_clause; 176, 177; 177, block; 177, 178; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 183; 180, subscript; 180, 181; 180, 182; 181, identifier:cpool; 182, identifier:varname; 183, identifier:value; 184, elif_clause; 184, 185; 184, 192; 185, boolean_operator:and; 185, 186; 185, 189; 186, comparison_operator:not; 186, 187; 186, 188; 187, identifier:key; 188, identifier:REDIS_CONFIGS; 189, comparison_operator:not; 189, 190; 189, 191; 190, identifier:key; 191, identifier:REDIS_EXCLUDES; 192, block; 192, 193; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:extra_kwargs; 197, identifier:key; 198, identifier:value; 199, if_statement; 199, 200; 199, 201; 200, identifier:cpool; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:cpool_class; 205, attribute; 205, 206; 205, 207; 206, identifier:redis; 207, identifier:ConnectionPool; 208, if_statement; 208, 209; 208, 212; 209, comparison_operator:in; 209, 210; 209, 211; 210, string:'connection_pool'; 211, identifier:config; 212, block; 212, 213; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:cpool_class; 216, call; 216, 217; 216, 220; 217, attribute; 217, 218; 217, 219; 218, identifier:utils; 219, identifier:find_entrypoint; 220, argument_list; 220, 221; 220, 222; 220, 225; 221, string:'turnstile.connection_pool'; 222, subscript; 222, 223; 222, 224; 223, identifier:config; 224, string:'connection_pool'; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:required; 227, True; 228, if_statement; 228, 229; 228, 230; 229, identifier:cpool_class; 230, block; 230, 231; 230, 238; 230, 296; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:cpool; 235, identifier:update; 236, argument_list; 236, 237; 237, identifier:kwargs; 238, if_statement; 238, 239; 238, 242; 239, comparison_operator:not; 239, 240; 239, 241; 240, string:'connection_class'; 241, identifier:cpool; 242, block; 242, 243; 243, if_statement; 243, 244; 243, 247; 243, 286; 244, comparison_operator:in; 244, 245; 244, 246; 245, string:'unix_socket_path'; 246, identifier:cpool; 247, block; 247, 248; 247, 257; 247, 266; 247, 274; 247, 278; 248, if_statement; 248, 249; 248, 252; 249, comparison_operator:in; 249, 250; 249, 251; 250, string:'host'; 251, identifier:cpool; 252, block; 252, 253; 253, delete_statement; 253, 254; 254, subscript; 254, 255; 254, 256; 255, identifier:cpool; 256, string:'host'; 257, if_statement; 257, 258; 257, 261; 258, comparison_operator:in; 258, 259; 258, 260; 259, string:'port'; 260, identifier:cpool; 261, block; 261, 262; 262, delete_statement; 262, 263; 263, subscript; 263, 264; 263, 265; 264, identifier:cpool; 265, string:'port'; 266, expression_statement; 266, 267; 267, assignment; 267, 268; 267, 271; 268, subscript; 268, 269; 268, 270; 269, identifier:cpool; 270, string:'path'; 271, subscript; 271, 272; 271, 273; 272, identifier:cpool; 273, string:'unix_socket_path'; 274, delete_statement; 274, 275; 275, subscript; 275, 276; 275, 277; 276, identifier:cpool; 277, string:'unix_socket_path'; 278, expression_statement; 278, 279; 279, assignment; 279, 280; 279, 283; 280, subscript; 280, 281; 280, 282; 281, identifier:cpool; 282, string:'connection_class'; 283, attribute; 283, 284; 283, 285; 284, identifier:redis; 285, identifier:UnixDomainSocketConnection; 286, else_clause; 286, 287; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 293; 290, subscript; 290, 291; 290, 292; 291, identifier:cpool; 292, string:'connection_class'; 293, attribute; 293, 294; 293, 295; 294, identifier:redis; 295, identifier:Connection; 296, expression_statement; 296, 297; 297, assignment; 297, 298; 297, 299; 298, identifier:kwargs; 299, call; 299, 300; 299, 301; 300, identifier:dict; 301, argument_list; 301, 302; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:connection_pool; 304, call; 304, 305; 304, 306; 305, identifier:cpool_class; 306, argument_list; 306, 307; 307, dictionary_splat; 307, 308; 308, identifier:cpool; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:kwargs; 313, identifier:update; 314, argument_list; 314, 315; 315, identifier:extra_kwargs; 316, return_statement; 316, 317; 317, call; 317, 318; 317, 319; 318, identifier:client; 319, argument_list; 319, 320; 320, dictionary_splat; 320, 321; 321, identifier:kwargs | def initialize(config):
if 'redis_client' in config:
client = utils.find_entrypoint('turnstile.redis_client',
config['redis_client'], required=True)
else:
client = redis.StrictRedis
kwargs = {}
for cfg_var, type_ in REDIS_CONFIGS.items():
if cfg_var in config:
kwargs[cfg_var] = type_(config[cfg_var])
if 'host' not in kwargs and 'unix_socket_path' not in kwargs:
raise redis.ConnectionError("No host specified for redis database")
cpool_class = None
cpool = {}
extra_kwargs = {}
for key, value in config.items():
if key.startswith('connection_pool.'):
_dummy, _sep, varname = key.partition('.')
if varname == 'connection_class':
cpool[varname] = utils.find_entrypoint(
'turnstile.connection_class', value, required=True)
elif varname == 'max_connections':
cpool[varname] = int(value)
elif varname == 'parser_class':
cpool[varname] = utils.find_entrypoint(
'turnstile.parser_class', value, required=True)
else:
cpool[varname] = value
elif key not in REDIS_CONFIGS and key not in REDIS_EXCLUDES:
extra_kwargs[key] = value
if cpool:
cpool_class = redis.ConnectionPool
if 'connection_pool' in config:
cpool_class = utils.find_entrypoint('turnstile.connection_pool',
config['connection_pool'],
required=True)
if cpool_class:
cpool.update(kwargs)
if 'connection_class' not in cpool:
if 'unix_socket_path' in cpool:
if 'host' in cpool:
del cpool['host']
if 'port' in cpool:
del cpool['port']
cpool['path'] = cpool['unix_socket_path']
del cpool['unix_socket_path']
cpool['connection_class'] = redis.UnixDomainSocketConnection
else:
cpool['connection_class'] = redis.Connection
kwargs = dict(connection_pool=cpool_class(**cpool))
kwargs.update(extra_kwargs)
return client(**kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:read_attributes; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:attributes; 7, None; 8, block; 8, 9; 8, 11; 8, 24; 8, 32; 8, 41; 8, 68; 8, 148; 8, 155; 8, 167; 8, 205; 9, expression_statement; 9, 10; 10, string:'''
Collect read attributes across reads in this PileupCollection into a
pandas.DataFrame.
Valid attributes are the following properties of a pysam.AlignedSegment
instance. See:
http://pysam.readthedocs.org/en/latest/api.html
for the meaning of these attributes.
* cigarstring
* flag
* inferred_length
* is_duplicate
* is_paired
* is_proper_pair
* is_qcfail
* is_read1
* is_read2
* is_reverse
* is_secondary
* is_unmapped
* mapping_quality
* mate_is_reverse
* mate_is_unmapped
* next_reference_id
* next_reference_start
* query_alignment_end
* query_alignment_length
* query_alignment_qualities
* query_alignment_sequence
* query_alignment_start
* query_length
* query_name
* reference_end
* reference_id
* reference_length
* reference_start
* template_length
(Note: the above list is parsed into the _READ_ATTRIBUTE_NAMES class
variable, so be careful when modifying it.)
Additionally, for alignment "tags" (arbitrary key values associated
with an alignment), a column of the form "TAG_{tag name}" is
included.
Finally, the column "pysam_alignment_record" gives the underlying
`pysam.AlignedSegment` instances.
Parameters
----------
attributes (optional): list of strings
List of columns to include. If unspecified, all columns are
included in the result.
Returns
----------
pandas.DataFrame of read attributes.
'''; 11, function_definition; 11, 12; 11, 13; 11, 15; 12, function_name:include; 13, parameters; 13, 14; 14, identifier:attribute; 15, block; 15, 16; 16, return_statement; 16, 17; 17, boolean_operator:or; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:attributes; 20, None; 21, comparison_operator:in; 21, 22; 21, 23; 22, identifier:attribute; 23, identifier:attributes; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:reads; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:reads; 31, argument_list; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:possible_column_names; 35, call; 35, 36; 35, 37; 36, identifier:list; 37, argument_list; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:PileupCollection; 40, identifier:_READ_ATTRIBUTE_NAMES; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:result; 44, call; 44, 45; 44, 46; 45, identifier:OrderedDict; 46, generator_expression; 46, 47; 46, 58; 46, 63; 47, tuple; 47, 48; 47, 49; 48, identifier:name; 49, list_comprehension; 49, 50; 49, 55; 50, call; 50, 51; 50, 52; 51, identifier:getattr; 52, argument_list; 52, 53; 52, 54; 53, identifier:read; 54, identifier:name; 55, for_in_clause; 55, 56; 55, 57; 56, identifier:read; 57, identifier:reads; 58, for_in_clause; 58, 59; 58, 60; 59, identifier:name; 60, attribute; 60, 61; 60, 62; 61, identifier:PileupCollection; 62, identifier:_READ_ATTRIBUTE_NAMES; 63, if_clause; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:include; 66, argument_list; 66, 67; 67, identifier:name; 68, if_statement; 68, 69; 68, 70; 69, identifier:reads; 70, block; 70, 71; 70, 86; 70, 107; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:tag_dicts; 74, list_comprehension; 74, 75; 74, 83; 75, call; 75, 76; 75, 77; 76, identifier:dict; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:x; 81, identifier:get_tags; 82, argument_list; 83, for_in_clause; 83, 84; 83, 85; 84, identifier:x; 85, identifier:reads; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:tag_keys; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:set; 92, identifier:union; 93, argument_list; 93, 94; 94, list_splat; 94, 95; 95, list_comprehension; 95, 96; 95, 104; 96, call; 96, 97; 96, 98; 97, identifier:set; 98, argument_list; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:item; 102, identifier:keys; 103, argument_list; 104, for_in_clause; 104, 105; 104, 106; 105, identifier:item; 106, identifier:tag_dicts; 107, for_statement; 107, 108; 107, 109; 107, 113; 108, identifier:tag_key; 109, call; 109, 110; 109, 111; 110, identifier:sorted; 111, argument_list; 111, 112; 112, identifier:tag_keys; 113, block; 113, 114; 113, 120; 113, 127; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:column_name; 117, binary_operator:%; 117, 118; 117, 119; 118, string:"TAG_%s"; 119, identifier:tag_key; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:possible_column_names; 124, identifier:append; 125, argument_list; 125, 126; 126, identifier:column_name; 127, if_statement; 127, 128; 127, 132; 128, call; 128, 129; 128, 130; 129, identifier:include; 130, argument_list; 130, 131; 131, identifier:column_name; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:result; 137, identifier:column_name; 138, list_comprehension; 138, 139; 138, 145; 139, call; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:d; 142, identifier:get; 143, argument_list; 143, 144; 144, identifier:tag_key; 145, for_in_clause; 145, 146; 145, 147; 146, identifier:d; 147, identifier:tag_dicts; 148, expression_statement; 148, 149; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:possible_column_names; 152, identifier:append; 153, argument_list; 153, 154; 154, string:"pysam_alignment_record"; 155, if_statement; 155, 156; 155, 160; 156, call; 156, 157; 156, 158; 157, identifier:include; 158, argument_list; 158, 159; 159, string:"pysam_alignment_record"; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:result; 165, string:"pysam_alignment_record"; 166, identifier:reads; 167, if_statement; 167, 168; 167, 171; 168, comparison_operator:is; 168, 169; 168, 170; 169, identifier:attributes; 170, None; 171, block; 171, 172; 171, 195; 172, for_statement; 172, 173; 172, 174; 172, 175; 173, identifier:attribute; 174, identifier:attributes; 175, block; 175, 176; 176, if_statement; 176, 177; 176, 180; 177, comparison_operator:not; 177, 178; 177, 179; 178, identifier:attribute; 179, identifier:result; 180, block; 180, 181; 181, raise_statement; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:ValueError; 184, argument_list; 184, 185; 185, binary_operator:%; 185, 186; 185, 187; 186, string:"No such attribute: %s. Valid attributes are: %s"; 187, tuple; 187, 188; 187, 189; 188, identifier:attribute; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, string:" "; 192, identifier:join; 193, argument_list; 193, 194; 194, identifier:possible_column_names; 195, assert_statement; 195, 196; 196, comparison_operator:==; 196, 197; 196, 201; 197, call; 197, 198; 197, 199; 198, identifier:set; 199, argument_list; 199, 200; 200, identifier:attributes; 201, call; 201, 202; 201, 203; 202, identifier:set; 203, argument_list; 203, 204; 204, identifier:result; 205, return_statement; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:pandas; 209, identifier:DataFrame; 210, argument_list; 210, 211; 211, identifier:result | def read_attributes(self, attributes=None):
'''
Collect read attributes across reads in this PileupCollection into a
pandas.DataFrame.
Valid attributes are the following properties of a pysam.AlignedSegment
instance. See:
http://pysam.readthedocs.org/en/latest/api.html
for the meaning of these attributes.
* cigarstring
* flag
* inferred_length
* is_duplicate
* is_paired
* is_proper_pair
* is_qcfail
* is_read1
* is_read2
* is_reverse
* is_secondary
* is_unmapped
* mapping_quality
* mate_is_reverse
* mate_is_unmapped
* next_reference_id
* next_reference_start
* query_alignment_end
* query_alignment_length
* query_alignment_qualities
* query_alignment_sequence
* query_alignment_start
* query_length
* query_name
* reference_end
* reference_id
* reference_length
* reference_start
* template_length
(Note: the above list is parsed into the _READ_ATTRIBUTE_NAMES class
variable, so be careful when modifying it.)
Additionally, for alignment "tags" (arbitrary key values associated
with an alignment), a column of the form "TAG_{tag name}" is
included.
Finally, the column "pysam_alignment_record" gives the underlying
`pysam.AlignedSegment` instances.
Parameters
----------
attributes (optional): list of strings
List of columns to include. If unspecified, all columns are
included in the result.
Returns
----------
pandas.DataFrame of read attributes.
'''
def include(attribute):
return attributes is None or attribute in attributes
reads = self.reads()
possible_column_names = list(PileupCollection._READ_ATTRIBUTE_NAMES)
result = OrderedDict(
(name, [getattr(read, name) for read in reads])
for name in PileupCollection._READ_ATTRIBUTE_NAMES
if include(name))
if reads:
tag_dicts = [dict(x.get_tags()) for x in reads]
tag_keys = set.union(
*[set(item.keys()) for item in tag_dicts])
for tag_key in sorted(tag_keys):
column_name = "TAG_%s" % tag_key
possible_column_names.append(column_name)
if include(column_name):
result[column_name] = [d.get(tag_key) for d in tag_dicts]
possible_column_names.append("pysam_alignment_record")
if include("pysam_alignment_record"):
result["pysam_alignment_record"] = reads
if attributes is not None:
for attribute in attributes:
if attribute not in result:
raise ValueError(
"No such attribute: %s. Valid attributes are: %s"
% (attribute, " ".join(possible_column_names)))
assert set(attributes) == set(result)
return pandas.DataFrame(result) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:group_by_allele; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:locus; 6, block; 6, 7; 6, 9; 6, 16; 6, 20; 6, 24; 6, 170; 6, 186; 6, 262; 6, 284; 7, expression_statement; 7, 8; 8, string:'''
Split the PileupCollection by the alleles suggested by the reads at the
specified locus.
If a read has an insertion immediately following the locus, then the
insertion is included in the allele. For example, if locus is the
1-base range [5,6), one allele might be "AGA", indicating that at
locus 5 some read has an "A" followed by a 2-base insertion ("GA"). If
a read has a deletion at the specified locus, the allele is the empty
string.
The given locus may include any number of bases. If the locus includes
multiple bases, then the alleles consist of all bases aligning to that
range in any read. Note that only sequences actually sequenced in a
particular read are included. For example, if one read has "ATT" at a
locus and another read has "GCC", then the alleles are "ATT" and
"GCC", but not "GTT". That is, the bases in each allele are phased. For
this reason, only reads that overlap the entire locus are included.
If the locus is an empty interval (e.g. [5,5) ), then the alleles
consist only of inserted bases. In this example, only bases inserted
immediately after locus 5 would be included (but *not* the base
actually at locus 5). In the previous insertion example, the allele
would be "GA", indicating a 2-base insertion. Reads that have no
insertion at that position (matches or deletions) would have the empty
string as their allele.
Parameters
----------
locus : Locus
The reference locus, encompassing 0 or more bases.
Returns
----------
A dict of string -> PileupCollection. The keys are nucleotide strings
giving the bases sequenced at the locus, and the values are
PileupCollection instances of the alignments that support that allele.
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:locus; 12, call; 12, 13; 12, 14; 13, identifier:to_locus; 14, argument_list; 14, 15; 15, identifier:locus; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:read_to_allele; 19, None; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:loci; 23, list:[]; 24, if_statement; 24, 25; 24, 28; 24, 114; 25, attribute; 25, 26; 25, 27; 26, identifier:locus; 27, identifier:positions; 28, block; 28, 29; 29, for_statement; 29, 30; 29, 31; 29, 34; 30, identifier:position; 31, attribute; 31, 32; 31, 33; 32, identifier:locus; 33, identifier:positions; 34, block; 34, 35; 34, 47; 34, 54; 34, 58; 34, 110; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:base_position; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:Locus; 41, identifier:from_interbase_coordinates; 42, argument_list; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:locus; 45, identifier:contig; 46, identifier:position; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:loci; 51, identifier:append; 52, argument_list; 52, 53; 53, identifier:base_position; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:new_read_to_allele; 57, dictionary; 58, for_statement; 58, 59; 58, 60; 58, 65; 59, identifier:element; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:pileups; 64, identifier:base_position; 65, block; 65, 66; 65, 70; 65, 79; 65, 96; 65, 104; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:allele_prefix; 69, string:""; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:key; 73, call; 73, 74; 73, 75; 74, identifier:alignment_key; 75, argument_list; 75, 76; 76, attribute; 76, 77; 76, 78; 77, identifier:element; 78, identifier:alignment; 79, if_statement; 79, 80; 79, 83; 80, comparison_operator:is; 80, 81; 80, 82; 81, identifier:read_to_allele; 82, None; 83, block; 83, 84; 84, try_statement; 84, 85; 84, 92; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:allele_prefix; 89, subscript; 89, 90; 89, 91; 90, identifier:read_to_allele; 91, identifier:key; 92, except_clause; 92, 93; 92, 94; 93, identifier:KeyError; 94, block; 94, 95; 95, continue_statement; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:allele; 99, binary_operator:+; 99, 100; 99, 101; 100, identifier:allele_prefix; 101, attribute; 101, 102; 101, 103; 102, identifier:element; 103, identifier:bases; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:new_read_to_allele; 108, identifier:key; 109, identifier:allele; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:read_to_allele; 113, identifier:new_read_to_allele; 114, else_clause; 114, 115; 115, block; 115, 116; 115, 130; 115, 137; 115, 141; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:position_before; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:Locus; 122, identifier:from_interbase_coordinates; 123, argument_list; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:locus; 126, identifier:contig; 127, attribute; 127, 128; 127, 129; 128, identifier:locus; 129, identifier:start; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:loci; 134, identifier:append; 135, argument_list; 135, 136; 136, identifier:position_before; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:read_to_allele; 140, dictionary; 141, for_statement; 141, 142; 141, 143; 141, 148; 142, identifier:element; 143, subscript; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:pileups; 147, identifier:position_before; 148, block; 148, 149; 148, 159; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:allele; 152, subscript; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:element; 155, identifier:bases; 156, slice; 156, 157; 156, 158; 157, integer:1; 158, colon; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 169; 161, subscript; 161, 162; 161, 163; 162, identifier:read_to_allele; 163, call; 163, 164; 163, 165; 164, identifier:alignment_key; 165, argument_list; 165, 166; 166, attribute; 166, 167; 166, 168; 167, identifier:element; 168, identifier:alignment; 169, identifier:allele; 170, expression_statement; 170, 171; 171, assignment; 171, 172; 171, 173; 172, identifier:split; 173, call; 173, 174; 173, 175; 174, identifier:defaultdict; 175, argument_list; 175, 176; 176, lambda; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:PileupCollection; 179, argument_list; 179, 180; 179, 183; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:pileups; 182, dictionary; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:parent; 185, identifier:self; 186, for_statement; 186, 187; 186, 188; 186, 189; 187, identifier:locus; 188, identifier:loci; 189, block; 189, 190; 189, 198; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:pileup; 193, subscript; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:pileups; 197, identifier:locus; 198, for_statement; 198, 199; 198, 200; 198, 203; 199, identifier:e; 200, attribute; 200, 201; 200, 202; 201, identifier:pileup; 202, identifier:elements; 203, block; 203, 204; 203, 218; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:key; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:read_to_allele; 210, identifier:get; 211, argument_list; 211, 212; 212, call; 212, 213; 212, 214; 213, identifier:alignment_key; 214, argument_list; 214, 215; 215, attribute; 215, 216; 215, 217; 216, identifier:e; 217, identifier:alignment; 218, if_statement; 218, 219; 218, 222; 219, comparison_operator:is; 219, 220; 219, 221; 220, identifier:key; 221, None; 222, block; 222, 223; 223, if_statement; 223, 224; 223, 231; 223, 245; 224, comparison_operator:in; 224, 225; 224, 226; 225, identifier:locus; 226, attribute; 226, 227; 226, 230; 227, subscript; 227, 228; 227, 229; 228, identifier:split; 229, identifier:key; 230, identifier:pileups; 231, block; 231, 232; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 243; 234, attribute; 234, 235; 234, 242; 235, subscript; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:split; 239, identifier:key; 240, identifier:pileups; 241, identifier:locus; 242, identifier:append; 243, argument_list; 243, 244; 244, identifier:e; 245, else_clause; 245, 246; 246, block; 246, 247; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 256; 249, subscript; 249, 250; 249, 255; 250, attribute; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:split; 253, identifier:key; 254, identifier:pileups; 255, identifier:locus; 256, call; 256, 257; 256, 258; 257, identifier:Pileup; 258, argument_list; 258, 259; 258, 260; 259, identifier:locus; 260, list:[e]; 260, 261; 261, identifier:e; 262, function_definition; 262, 263; 262, 264; 262, 266; 263, function_name:sorter; 264, parameters; 264, 265; 265, identifier:pair; 266, block; 266, 267; 266, 273; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 272; 269, tuple_pattern; 269, 270; 269, 271; 270, identifier:allele; 271, identifier:pileup_collection; 272, identifier:pair; 273, return_statement; 273, 274; 274, tuple; 274, 275; 274, 283; 275, binary_operator:*; 275, 276; 275, 278; 276, unary_operator:-; 276, 277; 277, integer:1; 278, call; 278, 279; 278, 282; 279, attribute; 279, 280; 279, 281; 280, identifier:pileup_collection; 281, identifier:num_reads; 282, argument_list; 283, identifier:allele; 284, return_statement; 284, 285; 285, call; 285, 286; 285, 287; 286, identifier:OrderedDict; 287, argument_list; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:sorted; 290, argument_list; 290, 291; 290, 296; 291, call; 291, 292; 291, 295; 292, attribute; 292, 293; 292, 294; 293, identifier:split; 294, identifier:items; 295, argument_list; 296, keyword_argument; 296, 297; 296, 298; 297, identifier:key; 298, identifier:sorter | def group_by_allele(self, locus):
'''
Split the PileupCollection by the alleles suggested by the reads at the
specified locus.
If a read has an insertion immediately following the locus, then the
insertion is included in the allele. For example, if locus is the
1-base range [5,6), one allele might be "AGA", indicating that at
locus 5 some read has an "A" followed by a 2-base insertion ("GA"). If
a read has a deletion at the specified locus, the allele is the empty
string.
The given locus may include any number of bases. If the locus includes
multiple bases, then the alleles consist of all bases aligning to that
range in any read. Note that only sequences actually sequenced in a
particular read are included. For example, if one read has "ATT" at a
locus and another read has "GCC", then the alleles are "ATT" and
"GCC", but not "GTT". That is, the bases in each allele are phased. For
this reason, only reads that overlap the entire locus are included.
If the locus is an empty interval (e.g. [5,5) ), then the alleles
consist only of inserted bases. In this example, only bases inserted
immediately after locus 5 would be included (but *not* the base
actually at locus 5). In the previous insertion example, the allele
would be "GA", indicating a 2-base insertion. Reads that have no
insertion at that position (matches or deletions) would have the empty
string as their allele.
Parameters
----------
locus : Locus
The reference locus, encompassing 0 or more bases.
Returns
----------
A dict of string -> PileupCollection. The keys are nucleotide strings
giving the bases sequenced at the locus, and the values are
PileupCollection instances of the alignments that support that allele.
'''
locus = to_locus(locus)
read_to_allele = None
loci = []
if locus.positions:
for position in locus.positions:
base_position = Locus.from_interbase_coordinates(
locus.contig, position)
loci.append(base_position)
new_read_to_allele = {}
for element in self.pileups[base_position]:
allele_prefix = ""
key = alignment_key(element.alignment)
if read_to_allele is not None:
try:
allele_prefix = read_to_allele[key]
except KeyError:
continue
allele = allele_prefix + element.bases
new_read_to_allele[key] = allele
read_to_allele = new_read_to_allele
else:
position_before = Locus.from_interbase_coordinates(
locus.contig, locus.start)
loci.append(position_before)
read_to_allele = {}
for element in self.pileups[position_before]:
allele = element.bases[1:]
read_to_allele[alignment_key(element.alignment)] = allele
split = defaultdict(lambda: PileupCollection(pileups={}, parent=self))
for locus in loci:
pileup = self.pileups[locus]
for e in pileup.elements:
key = read_to_allele.get(alignment_key(e.alignment))
if key is not None:
if locus in split[key].pileups:
split[key].pileups[locus].append(e)
else:
split[key].pileups[locus] = Pileup(locus, [e])
def sorter(pair):
(allele, pileup_collection) = pair
return (-1 * pileup_collection.num_reads(), allele)
return OrderedDict(sorted(split.items(), key=sorter)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:from_bam; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:pysam_samfile; 5, identifier:loci; 6, default_parameter; 6, 7; 6, 8; 7, identifier:normalized_contig_names; 8, True; 9, block; 9, 10; 9, 12; 9, 23; 9, 27; 9, 46; 10, expression_statement; 10, 11; 11, string:'''
Create a PileupCollection for a set of loci from a BAM file.
Parameters
----------
pysam_samfile : `pysam.Samfile` instance, or filename string
to a BAM file. The BAM file must be indexed.
loci : list of Locus instances
Loci to collect pileups for.
normalized_contig_names : whether the contig names have been normalized
(e.g. pyensembl removes the 'chr' prefix). Set to true to
de-normalize the names when querying the BAM file.
Returns
----------
PileupCollection instance containing pileups for the specified loci.
All alignments in the BAM file are included (e.g. duplicate reads,
secondary alignments, etc.). See `PileupCollection.filter` if these
need to be removed.
'''; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:loci; 15, list_comprehension; 15, 16; 15, 20; 16, call; 16, 17; 16, 18; 17, identifier:to_locus; 18, argument_list; 18, 19; 19, identifier:obj; 20, for_in_clause; 20, 21; 20, 22; 21, identifier:obj; 22, identifier:loci; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:close_on_completion; 26, False; 27, if_statement; 27, 28; 27, 34; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:typechecks; 31, identifier:is_string; 32, argument_list; 32, 33; 33, identifier:pysam_samfile; 34, block; 34, 35; 34, 42; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:pysam_samfile; 38, call; 38, 39; 38, 40; 39, identifier:Samfile; 40, argument_list; 40, 41; 41, identifier:pysam_samfile; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:close_on_completion; 45, True; 46, try_statement; 46, 47; 46, 262; 47, block; 47, 48; 47, 90; 47, 97; 47, 128; 47, 260; 48, if_statement; 48, 49; 48, 50; 48, 84; 49, identifier:normalized_contig_names; 50, block; 50, 51; 50, 55; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:chromosome_name_map; 54, dictionary; 55, for_statement; 55, 56; 55, 57; 55, 60; 56, identifier:name; 57, attribute; 57, 58; 57, 59; 58, identifier:pysam_samfile; 59, identifier:references; 60, block; 60, 61; 60, 72; 60, 78; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:normalized; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:pyensembl; 68, identifier:locus; 69, identifier:normalize_chromosome; 70, argument_list; 70, 71; 71, identifier:name; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 77; 74, subscript; 74, 75; 74, 76; 75, identifier:chromosome_name_map; 76, identifier:normalized; 77, identifier:name; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, subscript; 80, 81; 80, 82; 81, identifier:chromosome_name_map; 82, identifier:name; 83, identifier:name; 84, else_clause; 84, 85; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:chromosome_name_map; 89, None; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:result; 93, call; 93, 94; 93, 95; 94, identifier:PileupCollection; 95, argument_list; 95, 96; 96, dictionary; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:locus_iterator; 100, call; 100, 101; 100, 106; 101, attribute; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:itertools; 104, identifier:chain; 105, identifier:from_iterable; 106, generator_expression; 106, 107; 106, 122; 107, generator_expression; 107, 108; 107, 117; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:Locus; 111, identifier:from_interbase_coordinates; 112, argument_list; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:locus_interval; 115, identifier:contig; 116, identifier:pos; 117, for_in_clause; 117, 118; 117, 119; 118, identifier:pos; 119, attribute; 119, 120; 119, 121; 120, identifier:locus_interval; 121, identifier:positions; 122, for_in_clause; 122, 123; 122, 124; 123, identifier:locus_interval; 124, call; 124, 125; 124, 126; 125, identifier:sorted; 126, argument_list; 126, 127; 127, identifier:loci; 128, for_statement; 128, 129; 128, 130; 128, 131; 129, identifier:locus; 130, identifier:locus_iterator; 131, block; 131, 132; 131, 144; 131, 180; 131, 203; 131, 216; 131, 222; 131, 229; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 139; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:result; 137, identifier:pileups; 138, identifier:locus; 139, call; 139, 140; 139, 141; 140, identifier:Pileup; 141, argument_list; 141, 142; 141, 143; 142, identifier:locus; 143, list:[]; 144, if_statement; 144, 145; 144, 146; 144, 172; 145, identifier:normalized_contig_names; 146, block; 146, 147; 147, try_statement; 147, 148; 147, 157; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:chromosome; 152, subscript; 152, 153; 152, 154; 153, identifier:chromosome_name_map; 154, attribute; 154, 155; 154, 156; 155, identifier:locus; 156, identifier:contig; 157, except_clause; 157, 158; 157, 159; 158, identifier:KeyError; 159, block; 159, 160; 159, 171; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:logging; 164, identifier:warn; 165, argument_list; 165, 166; 166, binary_operator:%; 166, 167; 166, 168; 167, string:"No such contig in bam: %s"; 168, attribute; 168, 169; 168, 170; 169, identifier:locus; 170, identifier:contig; 171, continue_statement; 172, else_clause; 172, 173; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:chromosome; 177, attribute; 177, 178; 177, 179; 178, identifier:locus; 179, identifier:contig; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:columns; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:pysam_samfile; 186, identifier:pileup; 187, argument_list; 187, 188; 187, 189; 187, 192; 187, 197; 187, 200; 188, identifier:chromosome; 189, attribute; 189, 190; 189, 191; 190, identifier:locus; 191, identifier:position; 192, binary_operator:+; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:locus; 195, identifier:position; 196, integer:1; 197, keyword_argument; 197, 198; 197, 199; 198, identifier:truncate; 199, True; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:stepper; 202, string:"nofilter"; 203, try_statement; 203, 204; 203, 212; 204, block; 204, 205; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:column; 208, call; 208, 209; 208, 210; 209, identifier:next; 210, argument_list; 210, 211; 211, identifier:columns; 212, except_clause; 212, 213; 212, 214; 213, identifier:StopIteration; 214, block; 214, 215; 215, continue_statement; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:pileups; 219, attribute; 219, 220; 219, 221; 220, identifier:column; 221, identifier:pileups; 222, assert_statement; 222, 223; 223, comparison_operator:==; 223, 224; 223, 228; 224, call; 224, 225; 224, 226; 225, identifier:list; 226, argument_list; 226, 227; 227, identifier:columns; 228, list:[]; 229, for_statement; 229, 230; 229, 231; 229, 232; 230, identifier:pileup_read; 231, identifier:pileups; 232, block; 232, 233; 233, if_statement; 233, 234; 233, 238; 234, not_operator; 234, 235; 235, attribute; 235, 236; 235, 237; 236, identifier:pileup_read; 237, identifier:is_refskip; 238, block; 238, 239; 238, 249; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 242; 241, identifier:element; 242, call; 242, 243; 242, 246; 243, attribute; 243, 244; 243, 245; 244, identifier:PileupElement; 245, identifier:from_pysam_alignment; 246, argument_list; 246, 247; 246, 248; 247, identifier:locus; 248, identifier:pileup_read; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 258; 251, attribute; 251, 252; 251, 257; 252, subscript; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:result; 255, identifier:pileups; 256, identifier:locus; 257, identifier:append; 258, argument_list; 258, 259; 259, identifier:element; 260, return_statement; 260, 261; 261, identifier:result; 262, finally_clause; 262, 263; 263, block; 263, 264; 264, if_statement; 264, 265; 264, 266; 265, identifier:close_on_completion; 266, block; 266, 267; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:pysam_samfile; 271, identifier:close; 272, argument_list | def from_bam(pysam_samfile, loci, normalized_contig_names=True):
'''
Create a PileupCollection for a set of loci from a BAM file.
Parameters
----------
pysam_samfile : `pysam.Samfile` instance, or filename string
to a BAM file. The BAM file must be indexed.
loci : list of Locus instances
Loci to collect pileups for.
normalized_contig_names : whether the contig names have been normalized
(e.g. pyensembl removes the 'chr' prefix). Set to true to
de-normalize the names when querying the BAM file.
Returns
----------
PileupCollection instance containing pileups for the specified loci.
All alignments in the BAM file are included (e.g. duplicate reads,
secondary alignments, etc.). See `PileupCollection.filter` if these
need to be removed.
'''
loci = [to_locus(obj) for obj in loci]
close_on_completion = False
if typechecks.is_string(pysam_samfile):
pysam_samfile = Samfile(pysam_samfile)
close_on_completion = True
try:
if normalized_contig_names:
chromosome_name_map = {}
for name in pysam_samfile.references:
normalized = pyensembl.locus.normalize_chromosome(name)
chromosome_name_map[normalized] = name
chromosome_name_map[name] = name
else:
chromosome_name_map = None
result = PileupCollection({})
locus_iterator = itertools.chain.from_iterable(
(Locus.from_interbase_coordinates(locus_interval.contig, pos)
for pos
in locus_interval.positions)
for locus_interval in sorted(loci))
for locus in locus_iterator:
result.pileups[locus] = Pileup(locus, [])
if normalized_contig_names:
try:
chromosome = chromosome_name_map[locus.contig]
except KeyError:
logging.warn("No such contig in bam: %s" % locus.contig)
continue
else:
chromosome = locus.contig
columns = pysam_samfile.pileup(
chromosome,
locus.position,
locus.position + 1,
truncate=True,
stepper="nofilter")
try:
column = next(columns)
except StopIteration:
continue
pileups = column.pileups
assert list(columns) == []
for pileup_read in pileups:
if not pileup_read.is_refskip:
element = PileupElement.from_pysam_alignment(
locus, pileup_read)
result.pileups[locus].append(element)
return result
finally:
if close_on_completion:
pysam_samfile.close() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:check_recommended_global_attributes; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:dataset; 6, block; 6, 7; 6, 9; 6, 19; 6, 35; 6, 44; 6, 54; 6, 66; 6, 89; 6, 138; 6, 147; 6, 168; 6, 188; 6, 196; 6, 205; 6, 214; 6, 232; 6, 254; 7, expression_statement; 7, 8; 8, string:'''
Check the global recommended attributes for 2.0 templates. These go an extra step besides
just checking that they exist.
:param netCDF4.Dataset dataset: An open netCDF dataset
:id = "" ; //.................................................. RECOMMENDED - Should be a human readable unique identifier for data set. (ACDD)
:naming_authority = "" ; //.................................... RECOMMENDED - Backward URL of institution (for example, gov.noaa.ncei). (ACDD)
:history = "" ; //............................................. RECOMMENDED - Provides an audit trail for modifications to the original data. (ACDD)
:source = "" ; //.............................................. RECOMMENDED - The method of production of the original data. (CF)
:processing_level = "" ; //.................................... RECOMMENDED - Provide a description of the processing or quality control level of the data. (ACDD)
:comment = "" ; //............................................. RECOMMENDED - Provide useful additional information here. (CF)
:acknowledgment = "" ; //...................................... RECOMMENDED - A place to acknowledge various types of support for the project that produced this data. (ACDD)
:license = "" ; //............................................. RECOMMENDED - Describe the restrictions to data access and distribution. (ACDD)
:standard_name_vocabulary = "CF Standard Name Table vNN" ; //.. RECOMMENDED - If using CF standard name attribute for variables. Replace NN with the CF standard name table number (CF)
:date_created = "" ; //........................................ RECOMMENDED - Creation date of this version of the data(netCDF). Use ISO 8601:2004 for date and time. (ACDD)
:creator_name = "" ; //........................................ RECOMMENDED - The name of the person (or other creator type specified by the creator_type attribute) principally responsible for creating this data. (ACDD)
:creator_email = "" ; //....................................... RECOMMENDED - The email address of the person (or other creator type specified by the creator_type attribute) principally responsible for creating this data. (ACDD)
:creator_url = "" ; //......................................... RECOMMENDED - The URL of the person (or other creator type specified by the creator_type attribute) principally responsible for creating this data. (ACDD)
:institution = "" ; //......................................... RECOMMENDED -The name of the institution principally responsible for originating this data.. An institution attribute can be used for each variable if variables come from more than one institution. (CF/ACDD)
:project = "" ; //............................................. RECOMMENDED - The name of the project(s) principally responsible for originating this data. Multiple projects can be separated by commas. (ACDD)
:publisher_name = "" ; //...................................... RECOMMENDED - The name of the person (or other entity specified by the publisher_type attribute) responsible for publishing the data file or product to users, with its current metadata and format. (ACDD)
:publisher_email = "" ; //..................................... RECOMMENDED - The email address of the person (or other entity specified by the publisher_type attribute) responsible for publishing the data file or product to users, with its current metadata and format. (ACDD)
:publisher_url = "" ; //....................................... RECOMMENDED - The URL of the person (or other entity specified by the publisher_type attribute) responsible for publishing the data file or product to users, with its current metadata and format. (ACDD)
:geospatial_bounds = "" ; //................................... RECOMMENDED - Describes the data's 2D or 3D geospatial extent in OGC's Well-Known Text (WKT) Geometry format. (ACDD)
:geospatial_bounds_crs = "" ; //............................... RECOMMENDED - The coordinate reference system (CRS) of the point coordinates in the geospatial_bounds attribute. (ACDD)
:geospatial_bounds_vertical_crs = "" ; //...................... RECOMMENDED - The vertical coordinate reference system (CRS) for the Z axis of the point coordinates in the geospatial_bounds attribute. (ACDD)
:geospatial_lat_min = 0.0d ; //................................ RECOMMENDED - Describes a simple lower latitude limit. (ACDD)
:geospatial_lat_max = 0.0d ; //................................ RECOMMENDED - Describes a simple upper latitude limit. (ACDD)
:geospatial_lon_min = 0.0d ; //................................ RECOMMENDED - Describes a simple lower longitude limit. (ACDD)
:geospatial_lon_max = 0.0d ; //................................ RECOMMENDED - Describes a simple upper longitude limit. (ACDD)
:geospatial_vertical_min = 0.0d ; //........................... RECOMMENDED - Describes the numerically smaller vertical limit. (ACDD)
:geospatial_vertical_max = 0.0d ; //........................... RECOMMENDED - Describes the numerically larger vertical limit. (ACDD)
:geospatial_vertical_positive = "" ; //........................ RECOMMENDED - Use "up" or "down". (ACDD)
:time_coverage_start = "" ; //................................. RECOMMENDED - Describes the time of the first data point in the data set. Use ISO 8601:2004 for date and time. (ACDD)
:time_coverage_end = "" ; //................................... RECOMMENDED - Describes the time of the last data point in the data set. Use ISO 8601:2004 for date and time.(ACDD)
:time_coverage_duration = "" ; //.............................. RECOMMENDED - Describes the duration of the data set. Use ISO 8601:2004 for date and time. (ACDD)
:time_coverage_resolution = "" ; //............................ RECOMMENDED - Describes the targeted time period between each value in the data set. Use ISO 8601:2004 for date and time. (ACDD)
:uuid = "" ; //................................................ RECOMMENDED - Machine readable unique identifier for each file. A new uuid is created whenever the file is changed. (NCEI)
:sea_name = "" ; //............................................ RECOMMENDED - The names of the sea in which the data were collected. Use NCEI sea names table. (NCEI)
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:recommended_ctx; 12, call; 12, 13; 12, 14; 13, identifier:TestCtx; 14, argument_list; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:BaseCheck; 17, identifier:MEDIUM; 18, string:'Recommended global attributes'; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:sea_names; 22, list_comprehension; 22, 23; 22, 28; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:sn; 26, identifier:lower; 27, argument_list; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:sn; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:util; 33, identifier:get_sea_names; 34, argument_list; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:sea_name; 38, call; 38, 39; 38, 40; 39, identifier:getattr; 40, argument_list; 40, 41; 40, 42; 40, 43; 41, identifier:dataset; 42, string:'sea_name'; 43, string:''; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:sea_name; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:sea_name; 50, identifier:replace; 51, argument_list; 51, 52; 51, 53; 52, string:', '; 53, string:','; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:sea_name; 57, conditional_expression:if; 57, 58; 57, 64; 57, 65; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:sea_name; 61, identifier:split; 62, argument_list; 62, 63; 63, string:','; 64, identifier:sea_name; 65, list:[]; 66, for_statement; 66, 67; 66, 68; 66, 69; 67, identifier:sea; 68, identifier:sea_name; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:recommended_ctx; 74, identifier:assert_true; 75, argument_list; 75, 76; 75, 83; 76, comparison_operator:in; 76, 77; 76, 82; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:sea; 80, identifier:lower; 81, argument_list; 82, identifier:sea_names; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, string:'sea_name attribute should exist and should be from the NODC sea names list: {} is not a valid sea name'; 86, identifier:format; 87, argument_list; 87, 88; 88, identifier:sea; 89, for_statement; 89, 90; 89, 91; 89, 96; 90, identifier:attr; 91, list:['time_coverage_start', 'time_coverage_end', 'date_created', 'date_modified']; 91, 92; 91, 93; 91, 94; 91, 95; 92, string:'time_coverage_start'; 93, string:'time_coverage_end'; 94, string:'date_created'; 95, string:'date_modified'; 96, block; 96, 97; 96, 106; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:attr_value; 100, call; 100, 101; 100, 102; 101, identifier:getattr; 102, argument_list; 102, 103; 102, 104; 102, 105; 103, identifier:dataset; 104, identifier:attr; 105, string:''; 106, try_statement; 106, 107; 106, 121; 107, block; 107, 108; 107, 113; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:parse_datetime; 111, argument_list; 111, 112; 112, identifier:attr_value; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:recommended_ctx; 117, identifier:assert_true; 118, argument_list; 118, 119; 118, 120; 119, True; 120, string:''; 121, except_clause; 121, 122; 121, 123; 122, identifier:ISO8601Error; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:recommended_ctx; 128, identifier:assert_true; 129, argument_list; 129, 130; 129, 131; 130, False; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, string:'{} should exist and be ISO-8601 format (example: PT1M30S), currently: {}'; 134, identifier:format; 135, argument_list; 135, 136; 135, 137; 136, identifier:attr; 137, identifier:attr_value; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:value; 141, call; 141, 142; 141, 143; 142, identifier:getattr; 143, argument_list; 143, 144; 143, 145; 143, 146; 144, identifier:dataset; 145, string:'geospatial_vertical_positive'; 146, string:''; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:recommended_ctx; 151, identifier:assert_true; 152, argument_list; 152, 153; 152, 162; 153, comparison_operator:in; 153, 154; 153, 159; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:value; 157, identifier:lower; 158, argument_list; 159, list:['up', 'down']; 159, 160; 159, 161; 160, string:'up'; 161, string:'down'; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, string:'geospatial_vertical_positive attribute should be up or down: {}'; 165, identifier:format; 166, argument_list; 166, 167; 167, identifier:value; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:ack_exists; 171, call; 171, 172; 171, 173; 172, identifier:any; 173, argument_list; 173, 174; 174, generator_expression; 174, 175; 174, 183; 175, comparison_operator:!=; 175, 176; 175, 182; 176, call; 176, 177; 176, 178; 177, identifier:getattr; 178, argument_list; 178, 179; 178, 180; 178, 181; 179, identifier:dataset; 180, identifier:attr; 181, string:''; 182, string:''; 183, for_in_clause; 183, 184; 183, 185; 184, identifier:attr; 185, list:['acknowledgment', 'acknowledgement']; 185, 186; 185, 187; 186, string:'acknowledgment'; 187, string:'acknowledgement'; 188, expression_statement; 188, 189; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:recommended_ctx; 192, identifier:assert_true; 193, argument_list; 193, 194; 193, 195; 194, identifier:ack_exists; 195, string:'acknowledgement attribute should exist and not be empty'; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:standard_name_vocab; 199, call; 199, 200; 199, 201; 200, identifier:getattr; 201, argument_list; 201, 202; 201, 203; 201, 204; 202, identifier:dataset; 203, string:'standard_name_vocabulary'; 204, string:''; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:regex; 208, call; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:re; 211, identifier:compile; 212, argument_list; 212, 213; 213, string:r'[sS]tandard [nN]ame [tT]able'; 214, expression_statement; 214, 215; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:recommended_ctx; 218, identifier:assert_true; 219, argument_list; 219, 220; 219, 226; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:regex; 223, identifier:search; 224, argument_list; 224, 225; 225, identifier:standard_name_vocab; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, string:"standard_name_vocabulary doesn't contain 'Standard Name Table': {}"; 229, identifier:format; 230, argument_list; 230, 231; 231, identifier:standard_name_vocab; 232, if_statement; 232, 233; 232, 238; 233, call; 233, 234; 233, 235; 234, identifier:hasattr; 235, argument_list; 235, 236; 235, 237; 236, identifier:dataset; 237, string:'comment'; 238, block; 238, 239; 239, expression_statement; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:recommended_ctx; 243, identifier:assert_true; 244, argument_list; 244, 245; 244, 253; 245, comparison_operator:!=; 245, 246; 245, 252; 246, call; 246, 247; 246, 248; 247, identifier:getattr; 248, argument_list; 248, 249; 248, 250; 248, 251; 249, identifier:dataset; 250, string:'comment'; 251, string:''; 252, string:''; 253, string:'comment attribute should not be empty if specified'; 254, return_statement; 254, 255; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:recommended_ctx; 258, identifier:to_result; 259, argument_list | def check_recommended_global_attributes(self, dataset):
'''
Check the global recommended attributes for 2.0 templates. These go an extra step besides
just checking that they exist.
:param netCDF4.Dataset dataset: An open netCDF dataset
:id = "" ; //.................................................. RECOMMENDED - Should be a human readable unique identifier for data set. (ACDD)
:naming_authority = "" ; //.................................... RECOMMENDED - Backward URL of institution (for example, gov.noaa.ncei). (ACDD)
:history = "" ; //............................................. RECOMMENDED - Provides an audit trail for modifications to the original data. (ACDD)
:source = "" ; //.............................................. RECOMMENDED - The method of production of the original data. (CF)
:processing_level = "" ; //.................................... RECOMMENDED - Provide a description of the processing or quality control level of the data. (ACDD)
:comment = "" ; //............................................. RECOMMENDED - Provide useful additional information here. (CF)
:acknowledgment = "" ; //...................................... RECOMMENDED - A place to acknowledge various types of support for the project that produced this data. (ACDD)
:license = "" ; //............................................. RECOMMENDED - Describe the restrictions to data access and distribution. (ACDD)
:standard_name_vocabulary = "CF Standard Name Table vNN" ; //.. RECOMMENDED - If using CF standard name attribute for variables. Replace NN with the CF standard name table number (CF)
:date_created = "" ; //........................................ RECOMMENDED - Creation date of this version of the data(netCDF). Use ISO 8601:2004 for date and time. (ACDD)
:creator_name = "" ; //........................................ RECOMMENDED - The name of the person (or other creator type specified by the creator_type attribute) principally responsible for creating this data. (ACDD)
:creator_email = "" ; //....................................... RECOMMENDED - The email address of the person (or other creator type specified by the creator_type attribute) principally responsible for creating this data. (ACDD)
:creator_url = "" ; //......................................... RECOMMENDED - The URL of the person (or other creator type specified by the creator_type attribute) principally responsible for creating this data. (ACDD)
:institution = "" ; //......................................... RECOMMENDED -The name of the institution principally responsible for originating this data.. An institution attribute can be used for each variable if variables come from more than one institution. (CF/ACDD)
:project = "" ; //............................................. RECOMMENDED - The name of the project(s) principally responsible for originating this data. Multiple projects can be separated by commas. (ACDD)
:publisher_name = "" ; //...................................... RECOMMENDED - The name of the person (or other entity specified by the publisher_type attribute) responsible for publishing the data file or product to users, with its current metadata and format. (ACDD)
:publisher_email = "" ; //..................................... RECOMMENDED - The email address of the person (or other entity specified by the publisher_type attribute) responsible for publishing the data file or product to users, with its current metadata and format. (ACDD)
:publisher_url = "" ; //....................................... RECOMMENDED - The URL of the person (or other entity specified by the publisher_type attribute) responsible for publishing the data file or product to users, with its current metadata and format. (ACDD)
:geospatial_bounds = "" ; //................................... RECOMMENDED - Describes the data's 2D or 3D geospatial extent in OGC's Well-Known Text (WKT) Geometry format. (ACDD)
:geospatial_bounds_crs = "" ; //............................... RECOMMENDED - The coordinate reference system (CRS) of the point coordinates in the geospatial_bounds attribute. (ACDD)
:geospatial_bounds_vertical_crs = "" ; //...................... RECOMMENDED - The vertical coordinate reference system (CRS) for the Z axis of the point coordinates in the geospatial_bounds attribute. (ACDD)
:geospatial_lat_min = 0.0d ; //................................ RECOMMENDED - Describes a simple lower latitude limit. (ACDD)
:geospatial_lat_max = 0.0d ; //................................ RECOMMENDED - Describes a simple upper latitude limit. (ACDD)
:geospatial_lon_min = 0.0d ; //................................ RECOMMENDED - Describes a simple lower longitude limit. (ACDD)
:geospatial_lon_max = 0.0d ; //................................ RECOMMENDED - Describes a simple upper longitude limit. (ACDD)
:geospatial_vertical_min = 0.0d ; //........................... RECOMMENDED - Describes the numerically smaller vertical limit. (ACDD)
:geospatial_vertical_max = 0.0d ; //........................... RECOMMENDED - Describes the numerically larger vertical limit. (ACDD)
:geospatial_vertical_positive = "" ; //........................ RECOMMENDED - Use "up" or "down". (ACDD)
:time_coverage_start = "" ; //................................. RECOMMENDED - Describes the time of the first data point in the data set. Use ISO 8601:2004 for date and time. (ACDD)
:time_coverage_end = "" ; //................................... RECOMMENDED - Describes the time of the last data point in the data set. Use ISO 8601:2004 for date and time.(ACDD)
:time_coverage_duration = "" ; //.............................. RECOMMENDED - Describes the duration of the data set. Use ISO 8601:2004 for date and time. (ACDD)
:time_coverage_resolution = "" ; //............................ RECOMMENDED - Describes the targeted time period between each value in the data set. Use ISO 8601:2004 for date and time. (ACDD)
:uuid = "" ; //................................................ RECOMMENDED - Machine readable unique identifier for each file. A new uuid is created whenever the file is changed. (NCEI)
:sea_name = "" ; //............................................ RECOMMENDED - The names of the sea in which the data were collected. Use NCEI sea names table. (NCEI)
'''
recommended_ctx = TestCtx(BaseCheck.MEDIUM, 'Recommended global attributes')
sea_names = [sn.lower() for sn in util.get_sea_names()]
sea_name = getattr(dataset, 'sea_name', '')
sea_name = sea_name.replace(', ', ',')
sea_name = sea_name.split(',') if sea_name else []
for sea in sea_name:
recommended_ctx.assert_true(
sea.lower() in sea_names,
'sea_name attribute should exist and should be from the NODC sea names list: {} is not a valid sea name'.format(sea)
)
for attr in ['time_coverage_start', 'time_coverage_end', 'date_created', 'date_modified']:
attr_value = getattr(dataset, attr, '')
try:
parse_datetime(attr_value)
recommended_ctx.assert_true(True, '')
except ISO8601Error:
recommended_ctx.assert_true(False, '{} should exist and be ISO-8601 format (example: PT1M30S), currently: {}'.format(attr, attr_value))
value = getattr(dataset, 'geospatial_vertical_positive', '')
recommended_ctx.assert_true(value.lower() in ['up', 'down'], 'geospatial_vertical_positive attribute should be up or down: {}'.format(value))
ack_exists = any((getattr(dataset, attr, '') != '' for attr in ['acknowledgment', 'acknowledgement']))
recommended_ctx.assert_true(ack_exists, 'acknowledgement attribute should exist and not be empty')
standard_name_vocab = getattr(dataset, 'standard_name_vocabulary', '')
regex = re.compile(r'[sS]tandard [nN]ame [tT]able')
recommended_ctx.assert_true(regex.search(standard_name_vocab),
"standard_name_vocabulary doesn't contain 'Standard Name Table': {}".format(standard_name_vocab))
if hasattr(dataset, 'comment'):
recommended_ctx.assert_true(getattr(dataset, 'comment', '') != '', 'comment attribute should not be empty if specified')
return recommended_ctx.to_result() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.