sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:intersect_range_array; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:bed1; 5, identifier:beds2; 6, default_parameter; 6, 7; 6, 8; 7, identifier:payload; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:is_sorted; 11, False; 12, block; 12, 13; 12, 24; 12, 28; 12, 105; 12, 113; 13, if_statement; 13, 14; 13, 16; 14, not_operator; 14, 15; 15, identifier:is_sorted; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:beds2; 20, call; 20, 21; 20, 22; 21, identifier:sort_ranges; 22, argument_list; 22, 23; 23, identifier:beds2; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:output; 27, list:[]; 28, for_statement; 28, 29; 28, 30; 28, 31; 29, identifier:bed2; 30, identifier:beds2; 31, block; 31, 32; 31, 41; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:cval; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:bed2; 38, identifier:cmp; 39, argument_list; 39, 40; 40, identifier:bed1; 41, if_statement; 41, 42; 41, 46; 41, 48; 41, 99; 42, comparison_operator:==; 42, 43; 42, 44; 43, identifier:cval; 44, unary_operator:-; 44, 45; 45, integer:1; 46, block; 46, 47; 47, continue_statement; 48, elif_clause; 48, 49; 48, 52; 49, comparison_operator:==; 49, 50; 49, 51; 50, identifier:cval; 51, integer:0; 52, block; 52, 53; 52, 65; 52, 82; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:output; 57, identifier:append; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:bed1; 62, identifier:intersect; 63, argument_list; 63, 64; 64, identifier:bed2; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:==; 66, 67; 66, 68; 67, identifier:payload; 68, integer:1; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 78; 72, attribute; 72, 73; 72, 77; 73, subscript; 73, 74; 73, 75; 74, identifier:output; 75, unary_operator:-; 75, 76; 76, integer:1; 77, identifier:set_payload; 78, argument_list; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:bed1; 81, identifier:payload; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:==; 83, 84; 83, 85; 84, identifier:payload; 85, integer:2; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 95; 89, attribute; 89, 90; 89, 94; 90, subscript; 90, 91; 90, 92; 91, identifier:output; 92, unary_operator:-; 92, 93; 93, integer:1; 94, identifier:set_payload; 95, argument_list; 95, 96; 96, attribute; 96, 97; 96, 98; 97, identifier:bed2; 98, identifier:payload; 99, elif_clause; 99, 100; 99, 103; 100, comparison_operator:==; 100, 101; 100, 102; 101, identifier:cval; 102, integer:1; 103, block; 103, 104; 104, break_statement; 105, if_statement; 105, 106; 105, 107; 106, identifier:payload; 107, block; 107, 108; 108, return_statement; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:sort_ranges; 111, argument_list; 111, 112; 112, identifier:output; 113, return_statement; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:merge_ranges; 116, argument_list; 116, 117; 117, identifier:output | def intersect_range_array(bed1,beds2,payload=None,is_sorted=False):
if not is_sorted: beds2 = sort_ranges(beds2)
output = []
for bed2 in beds2:
cval = bed2.cmp(bed1)
if cval == -1: continue
elif cval == 0:
output.append(bed1.intersect(bed2))
if payload==1:
output[-1].set_payload(bed1.payload)
if payload==2:
output[-1].set_payload(bed2.payload)
elif cval == 1: break
if payload: return sort_ranges(output)
return merge_ranges(output) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_genomic_ranges; 3, parameters; 3, 4; 4, identifier:rngs; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 11; 10, identifier:rngs; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:key; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:x; 16, tuple; 16, 17; 16, 20; 16, 23; 17, attribute; 17, 18; 17, 19; 18, identifier:x; 19, identifier:chr; 20, attribute; 20, 21; 20, 22; 21, identifier:x; 22, identifier:start; 23, attribute; 23, 24; 23, 25; 24, identifier:x; 25, identifier:end | def sort_genomic_ranges(rngs):
return sorted(rngs, key=lambda x: (x.chr, x.start, x.end)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:topological_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:dependencies; 5, identifier:start_nodes; 6, block; 6, 7; 6, 11; 6, 22; 6, 33; 6, 51; 6, 95; 6, 117; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:retval; 10, list:[]; 11, function_definition; 11, 12; 11, 13; 11, 15; 12, function_name:edges; 13, parameters; 13, 14; 14, identifier:node; 15, block; 15, 16; 16, return_statement; 16, 17; 17, subscript; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:dependencies; 20, identifier:node; 21, integer:1; 22, function_definition; 22, 23; 22, 24; 22, 26; 23, function_name:in_degree; 24, parameters; 24, 25; 25, identifier:node; 26, block; 26, 27; 27, return_statement; 27, 28; 28, subscript; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:dependencies; 31, identifier:node; 32, integer:0; 33, function_definition; 33, 34; 33, 35; 33, 37; 34, function_name:remove_incoming; 35, parameters; 35, 36; 36, identifier:node; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:dependencies; 43, identifier:node; 44, integer:0; 45, binary_operator:-; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:in_degree; 48, argument_list; 48, 49; 49, identifier:node; 50, integer:1; 51, while_statement; 51, 52; 51, 53; 52, identifier:start_nodes; 53, block; 53, 54; 53, 62; 53, 69; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:node; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:start_nodes; 60, identifier:pop; 61, argument_list; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:retval; 66, identifier:append; 67, argument_list; 67, 68; 68, identifier:node; 69, for_statement; 69, 70; 69, 71; 69, 75; 70, identifier:child; 71, call; 71, 72; 71, 73; 72, identifier:edges; 73, argument_list; 73, 74; 74, identifier:node; 75, block; 75, 76; 75, 81; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:remove_incoming; 79, argument_list; 79, 80; 80, identifier:child; 81, if_statement; 81, 82; 81, 87; 82, not_operator; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:in_degree; 85, argument_list; 85, 86; 86, identifier:child; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:start_nodes; 92, identifier:append; 93, argument_list; 93, 94; 94, identifier:child; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:leftover_nodes; 98, list_comprehension; 98, 99; 98, 100; 98, 110; 99, identifier:node; 100, for_in_clause; 100, 101; 100, 102; 101, identifier:node; 102, call; 102, 103; 102, 104; 103, identifier:list; 104, argument_list; 104, 105; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:dependencies; 108, identifier:keys; 109, argument_list; 110, if_clause; 110, 111; 111, comparison_operator:>; 111, 112; 111, 116; 112, call; 112, 113; 112, 114; 113, identifier:in_degree; 114, argument_list; 114, 115; 115, identifier:node; 116, integer:0; 117, if_statement; 117, 118; 117, 119; 117, 125; 118, identifier:leftover_nodes; 119, block; 119, 120; 120, raise_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:CyclicDependency; 123, argument_list; 123, 124; 124, identifier:leftover_nodes; 125, else_clause; 125, 126; 126, block; 126, 127; 127, return_statement; 127, 128; 128, identifier:retval | def topological_sort(dependencies, start_nodes):
retval = []
def edges(node): return dependencies[node][1]
def in_degree(node): return dependencies[node][0]
def remove_incoming(node): dependencies[node][0] = in_degree(node) - 1
while start_nodes:
node = start_nodes.pop()
retval.append(node)
for child in edges(node):
remove_incoming(child)
if not in_degree(child):
start_nodes.append(child)
leftover_nodes = [node for node in list(dependencies.keys())
if in_degree(node) > 0]
if leftover_nodes:
raise CyclicDependency(leftover_nodes)
else:
return retval |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_do_parse; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:inp; 5, identifier:fmt; 6, identifier:encoding; 7, identifier:force_types; 8, block; 8, 9; 8, 13; 8, 19; 8, 189; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:res; 12, dictionary; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:_check_lib_installed; 16, argument_list; 16, 17; 16, 18; 17, identifier:fmt; 18, string:'parse'; 19, if_statement; 19, 20; 19, 23; 19, 44; 19, 78; 19, 112; 19, 155; 19, 172; 19, 186; 20, comparison_operator:==; 20, 21; 20, 22; 21, identifier:fmt; 22, string:'ini'; 23, block; 23, 24; 23, 36; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:cfg; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:configobj; 30, identifier:ConfigObj; 31, argument_list; 31, 32; 31, 33; 32, identifier:inp; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:encoding; 35, identifier:encoding; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:res; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:cfg; 42, identifier:dict; 43, argument_list; 44, elif_clause; 44, 45; 44, 48; 45, comparison_operator:==; 45, 46; 45, 47; 46, identifier:fmt; 47, string:'json'; 48, block; 48, 49; 48, 66; 49, if_statement; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:six; 52, identifier:PY3; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:inp; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:io; 60, identifier:TextIOWrapper; 61, argument_list; 61, 62; 61, 63; 62, identifier:inp; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:encoding; 65, identifier:encoding; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:res; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:json; 72, identifier:load; 73, argument_list; 73, 74; 73, 75; 74, identifier:inp; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:encoding; 77, identifier:encoding; 78, elif_clause; 78, 79; 78, 82; 79, comparison_operator:==; 79, 80; 79, 81; 80, identifier:fmt; 81, string:'json5'; 82, block; 82, 83; 82, 100; 83, if_statement; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:six; 86, identifier:PY3; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:inp; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:io; 94, identifier:TextIOWrapper; 95, argument_list; 95, 96; 95, 97; 96, identifier:inp; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:encoding; 99, identifier:encoding; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:res; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:json5; 106, identifier:load; 107, argument_list; 107, 108; 107, 109; 108, identifier:inp; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:encoding; 111, identifier:encoding; 112, elif_clause; 112, 113; 112, 116; 113, comparison_operator:==; 113, 114; 113, 115; 114, identifier:fmt; 115, string:'toml'; 116, block; 116, 117; 116, 129; 116, 146; 117, if_statement; 117, 118; 117, 123; 118, not_operator; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:_is_utf8; 121, argument_list; 121, 122; 122, identifier:encoding; 123, block; 123, 124; 124, raise_statement; 124, 125; 125, call; 125, 126; 125, 127; 126, identifier:AnyMarkupError; 127, argument_list; 127, 128; 128, string:'toml is always utf-8 encoded according to specification'; 129, if_statement; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:six; 132, identifier:PY3; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:inp; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:io; 140, identifier:TextIOWrapper; 141, argument_list; 141, 142; 141, 143; 142, identifier:inp; 143, keyword_argument; 143, 144; 143, 145; 144, identifier:encoding; 145, identifier:encoding; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:res; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:toml; 152, identifier:load; 153, argument_list; 153, 154; 154, identifier:inp; 155, elif_clause; 155, 156; 155, 159; 156, comparison_operator:==; 156, 157; 156, 158; 157, identifier:fmt; 158, string:'xml'; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:res; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:xmltodict; 166, identifier:parse; 167, argument_list; 167, 168; 167, 169; 168, identifier:inp; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:encoding; 171, identifier:encoding; 172, elif_clause; 172, 173; 172, 176; 173, comparison_operator:==; 173, 174; 173, 175; 174, identifier:fmt; 175, string:'yaml'; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 180; 179, identifier:res; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:yaml; 183, identifier:safe_load; 184, argument_list; 184, 185; 185, identifier:inp; 186, else_clause; 186, 187; 187, block; 187, 188; 188, raise_statement; 189, return_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:_ensure_proper_types; 192, argument_list; 192, 193; 192, 194; 192, 195; 193, identifier:res; 194, identifier:encoding; 195, identifier:force_types | def _do_parse(inp, fmt, encoding, force_types):
res = {}
_check_lib_installed(fmt, 'parse')
if fmt == 'ini':
cfg = configobj.ConfigObj(inp, encoding=encoding)
res = cfg.dict()
elif fmt == 'json':
if six.PY3:
inp = io.TextIOWrapper(inp, encoding=encoding)
res = json.load(inp, encoding=encoding)
elif fmt == 'json5':
if six.PY3:
inp = io.TextIOWrapper(inp, encoding=encoding)
res = json5.load(inp, encoding=encoding)
elif fmt == 'toml':
if not _is_utf8(encoding):
raise AnyMarkupError('toml is always utf-8 encoded according to specification')
if six.PY3:
inp = io.TextIOWrapper(inp, encoding=encoding)
res = toml.load(inp)
elif fmt == 'xml':
res = xmltodict.parse(inp, encoding=encoding)
elif fmt == 'yaml':
res = yaml.safe_load(inp)
else:
raise
return _ensure_proper_types(res, encoding, force_types) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_do_serialize; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:struct; 5, identifier:fmt; 6, identifier:encoding; 7, block; 7, 8; 7, 12; 7, 18; 7, 180; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:res; 11, None; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:_check_lib_installed; 15, argument_list; 15, 16; 15, 17; 16, identifier:fmt; 17, string:'serialize'; 18, if_statement; 18, 19; 18, 22; 18, 63; 18, 101; 18, 132; 18, 157; 18, 177; 19, comparison_operator:==; 19, 20; 19, 21; 20, identifier:fmt; 21, string:'ini'; 22, block; 22, 23; 22, 34; 22, 50; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:config; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:configobj; 29, identifier:ConfigObj; 30, argument_list; 30, 31; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:encoding; 33, identifier:encoding; 34, for_statement; 34, 35; 34, 38; 34, 43; 35, pattern_list; 35, 36; 35, 37; 36, identifier:k; 37, identifier:v; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:struct; 41, identifier:items; 42, argument_list; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:config; 48, identifier:k; 49, identifier:v; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:res; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, string:b'\n'; 56, identifier:join; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:config; 61, identifier:write; 62, argument_list; 63, elif_clause; 63, 64; 63, 69; 64, comparison_operator:in; 64, 65; 64, 66; 65, identifier:fmt; 66, list:['json', 'json5']; 66, 67; 66, 68; 67, string:'json'; 68, string:'json5'; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:res; 73, call; 73, 74; 73, 99; 74, attribute; 74, 75; 74, 98; 75, call; 75, 76; 75, 85; 76, attribute; 76, 77; 76, 84; 77, parenthesized_expression; 77, 78; 78, conditional_expression:if; 78, 79; 78, 80; 78, 83; 79, identifier:json; 80, comparison_operator:==; 80, 81; 80, 82; 81, identifier:fmt; 82, string:'json'; 83, identifier:json5; 84, identifier:dumps; 85, argument_list; 85, 86; 85, 87; 85, 90; 85, 95; 86, identifier:struct; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:indent; 89, integer:2; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:separators; 92, tuple; 92, 93; 92, 94; 93, string:','; 94, string:': '; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:ensure_ascii; 97, False; 98, identifier:encode; 99, argument_list; 99, 100; 100, identifier:encoding; 101, elif_clause; 101, 102; 101, 105; 102, comparison_operator:==; 102, 103; 102, 104; 103, identifier:fmt; 104, string:'toml'; 105, block; 105, 106; 105, 118; 106, if_statement; 106, 107; 106, 112; 107, not_operator; 107, 108; 108, call; 108, 109; 108, 110; 109, identifier:_is_utf8; 110, argument_list; 110, 111; 111, identifier:encoding; 112, block; 112, 113; 113, raise_statement; 113, 114; 114, call; 114, 115; 114, 116; 115, identifier:AnyMarkupError; 116, argument_list; 116, 117; 117, string:'toml must always be utf-8 encoded according to specification'; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:res; 121, call; 121, 122; 121, 130; 122, attribute; 122, 123; 122, 129; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:toml; 126, identifier:dumps; 127, argument_list; 127, 128; 128, identifier:struct; 129, identifier:encode; 130, argument_list; 130, 131; 131, identifier:encoding; 132, elif_clause; 132, 133; 132, 136; 133, comparison_operator:==; 133, 134; 133, 135; 134, identifier:fmt; 135, string:'xml'; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:res; 140, call; 140, 141; 140, 155; 141, attribute; 141, 142; 141, 154; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:xmltodict; 145, identifier:unparse; 146, argument_list; 146, 147; 146, 148; 146, 151; 147, identifier:struct; 148, keyword_argument; 148, 149; 148, 150; 149, identifier:pretty; 150, True; 151, keyword_argument; 151, 152; 151, 153; 152, identifier:encoding; 153, string:'utf-8'; 154, identifier:encode; 155, argument_list; 155, 156; 156, string:'utf-8'; 157, elif_clause; 157, 158; 157, 161; 158, comparison_operator:==; 158, 159; 158, 160; 159, identifier:fmt; 160, string:'yaml'; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:res; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:yaml; 168, identifier:safe_dump; 169, argument_list; 169, 170; 169, 171; 169, 174; 170, identifier:struct; 171, keyword_argument; 171, 172; 171, 173; 172, identifier:encoding; 173, string:'utf-8'; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:default_flow_style; 176, False; 177, else_clause; 177, 178; 178, block; 178, 179; 179, raise_statement; 180, return_statement; 180, 181; 181, identifier:res | def _do_serialize(struct, fmt, encoding):
res = None
_check_lib_installed(fmt, 'serialize')
if fmt == 'ini':
config = configobj.ConfigObj(encoding=encoding)
for k, v in struct.items():
config[k] = v
res = b'\n'.join(config.write())
elif fmt in ['json', 'json5']:
res = (json if fmt == 'json' else json5).dumps(struct,
indent=2,
separators=(',', ': '),
ensure_ascii=False).encode(encoding)
elif fmt == 'toml':
if not _is_utf8(encoding):
raise AnyMarkupError('toml must always be utf-8 encoded according to specification')
res = toml.dumps(struct).encode(encoding)
elif fmt == 'xml':
res = xmltodict.unparse(struct, pretty=True, encoding='utf-8').encode('utf-8')
elif fmt == 'yaml':
res = yaml.safe_dump(struct, encoding='utf-8', default_flow_style=False)
else:
raise
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_header; 3, parameters; 3, 4; 4, identifier:header_text; 5, block; 5, 6; 5, 19; 5, 23; 5, 56; 5, 60; 5, 64; 5, 126; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:lines; 9, call; 9, 10; 9, 17; 10, attribute; 10, 11; 10, 16; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:header_text; 14, identifier:rstrip; 15, argument_list; 16, identifier:split; 17, argument_list; 17, 18; 18, string:"\n"; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:rlens; 22, dictionary; 23, for_statement; 23, 24; 23, 25; 23, 26; 24, identifier:ln; 25, identifier:lines; 26, block; 26, 27; 26, 37; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:m; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:re; 33, identifier:match; 34, argument_list; 34, 35; 34, 36; 35, string:'@SQ\tSN:(\S+)\tLN:(\S+)'; 36, identifier:ln; 37, if_statement; 37, 38; 37, 39; 38, identifier:m; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 50; 42, subscript; 42, 43; 42, 44; 43, identifier:rlens; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:m; 47, identifier:group; 48, argument_list; 48, 49; 49, integer:1; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:m; 53, identifier:group; 54, argument_list; 54, 55; 55, integer:2; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:output; 59, string:''; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:done_lens; 63, False; 64, for_statement; 64, 65; 64, 66; 64, 67; 65, identifier:ln; 66, identifier:lines; 67, block; 67, 68; 68, if_statement; 68, 69; 68, 76; 68, 113; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:re; 72, identifier:match; 73, argument_list; 73, 74; 73, 75; 74, string:'@SQ\tSN:'; 75, identifier:ln; 76, block; 76, 77; 77, if_statement; 77, 78; 77, 80; 78, not_operator; 78, 79; 79, identifier:done_lens; 80, block; 80, 81; 80, 85; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:done_lens; 84, True; 85, for_statement; 85, 86; 85, 87; 85, 95; 86, identifier:chr; 87, call; 87, 88; 87, 89; 88, identifier:sorted; 89, argument_list; 89, 90; 90, call; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:rlens; 93, identifier:keys; 94, argument_list; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, augmented_assignment:+=; 97, 98; 97, 99; 98, identifier:output; 99, binary_operator:+; 99, 100; 99, 112; 100, binary_operator:+; 100, 101; 100, 106; 101, binary_operator:+; 101, 102; 101, 105; 102, binary_operator:+; 102, 103; 102, 104; 103, string:"@SQ\tSN:"; 104, identifier:chr; 105, string:"\tLN:"; 106, call; 106, 107; 106, 108; 107, identifier:str; 108, argument_list; 108, 109; 109, subscript; 109, 110; 109, 111; 110, identifier:rlens; 111, identifier:chr; 112, string:"\n"; 113, else_clause; 113, 114; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, augmented_assignment:+=; 116, 117; 116, 118; 117, identifier:output; 118, binary_operator:+; 118, 119; 118, 125; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:ln; 122, identifier:rstrip; 123, argument_list; 123, 124; 124, string:"\n"; 125, string:"\n"; 126, return_statement; 126, 127; 127, identifier:output | def sort_header(header_text):
lines = header_text.rstrip().split("\n")
rlens = {}
for ln in lines:
m = re.match('@SQ\tSN:(\S+)\tLN:(\S+)',ln)
if m:
rlens[m.group(1)] = m.group(2)
output = ''
done_lens = False
for ln in lines:
if re.match('@SQ\tSN:',ln):
if not done_lens:
done_lens = True
for chr in sorted(rlens.keys()):
output += "@SQ\tSN:"+chr+"\tLN:"+str(rlens[chr])+"\n"
else:
output += ln.rstrip("\n")+"\n"
return output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:field; 6, default_parameter; 6, 7; 6, 8; 7, identifier:direction; 8, string:"asc"; 9, block; 9, 10; 9, 23; 9, 35; 10, if_statement; 10, 11; 10, 17; 11, not_operator; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:isinstance; 14, argument_list; 14, 15; 14, 16; 15, identifier:field; 16, identifier:basestring; 17, block; 17, 18; 18, raise_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:ValueError; 21, argument_list; 21, 22; 22, string:"Field should be a string"; 23, if_statement; 23, 24; 23, 29; 24, comparison_operator:not; 24, 25; 24, 26; 25, identifier:direction; 26, list:["asc", "desc"]; 26, 27; 26, 28; 27, string:"asc"; 28, string:"desc"; 29, block; 29, 30; 30, raise_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:ValueError; 33, argument_list; 33, 34; 34, string:"Sort direction should be `asc` or `desc`"; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 42; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:sorts; 41, identifier:append; 42, argument_list; 42, 43; 43, dictionary; 43, 44; 44, pair; 44, 45; 44, 46; 45, identifier:field; 46, identifier:direction | def sort(self, field, direction="asc"):
if not isinstance(field, basestring):
raise ValueError("Field should be a string")
if direction not in ["asc", "desc"]:
raise ValueError("Sort direction should be `asc` or `desc`")
self.sorts.append({field: direction}) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:remove_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:field_name; 6, block; 6, 7; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:sorts; 12, list_comprehension; 12, 13; 12, 19; 12, 26; 13, call; 13, 14; 13, 15; 14, identifier:dict; 15, argument_list; 15, 16; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:field; 18, identifier:value; 19, for_in_clause; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:field; 22, identifier:value; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:sorts; 26, if_clause; 26, 27; 27, comparison_operator:is; 27, 28; 27, 29; 28, identifier:field; 29, identifier:field_name | def remove_sort(self, field_name):
self.sorts = [dict(field=value) for field, value in self.sorts if field
is not field_name] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:aggregate_registry_timers; 3, parameters; 4, block; 4, 5; 4, 8; 4, 27; 4, 31; 4, 100; 4, 106; 5, import_statement; 5, 6; 6, dotted_name; 6, 7; 7, identifier:itertools; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:timers; 11, call; 11, 12; 11, 13; 12, identifier:sorted; 13, argument_list; 13, 14; 13, 19; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:shared_registry; 17, identifier:values; 18, argument_list; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:key; 21, lambda; 21, 22; 21, 24; 22, lambda_parameters; 22, 23; 23, identifier:t; 24, attribute; 24, 25; 24, 26; 25, identifier:t; 26, identifier:desc; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:aggregate_timers; 30, list:[]; 31, for_statement; 31, 32; 31, 35; 31, 49; 32, pattern_list; 32, 33; 32, 34; 33, identifier:k; 34, identifier:g; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:itertools; 38, identifier:groupby; 39, argument_list; 39, 40; 39, 41; 40, identifier:timers; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:key; 43, lambda; 43, 44; 43, 46; 44, lambda_parameters; 44, 45; 45, identifier:t; 46, attribute; 46, 47; 46, 48; 47, identifier:t; 48, identifier:desc; 49, block; 49, 50; 49, 57; 49, 64; 49, 76; 49, 88; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:group; 53, call; 53, 54; 53, 55; 54, identifier:list; 55, argument_list; 55, 56; 56, identifier:g; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:num_calls; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, identifier:group; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:total_elapsed_ms; 67, call; 67, 68; 67, 69; 68, identifier:sum; 69, generator_expression; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:t; 72, identifier:elapsed_time_ms; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:t; 75, identifier:group; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:first_start_time; 79, call; 79, 80; 79, 81; 80, identifier:min; 81, generator_expression; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:t; 84, identifier:start_time; 85, for_in_clause; 85, 86; 85, 87; 86, identifier:t; 87, identifier:group; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:aggregate_timers; 92, identifier:append; 93, argument_list; 93, 94; 94, tuple; 94, 95; 94, 96; 95, identifier:first_start_time; 96, tuple; 96, 97; 96, 98; 96, 99; 97, identifier:k; 98, identifier:total_elapsed_ms; 99, identifier:num_calls; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:aggregate_timers; 104, identifier:sort; 105, argument_list; 106, return_statement; 106, 107; 107, subscript; 107, 108; 107, 113; 108, call; 108, 109; 108, 110; 109, identifier:zip; 110, argument_list; 110, 111; 111, list_splat; 111, 112; 112, identifier:aggregate_timers; 113, integer:1 | def aggregate_registry_timers():
import itertools
timers = sorted(shared_registry.values(), key=lambda t: t.desc)
aggregate_timers = []
for k, g in itertools.groupby(timers, key=lambda t: t.desc):
group = list(g)
num_calls = len(group)
total_elapsed_ms = sum(t.elapsed_time_ms for t in group)
first_start_time = min(t.start_time for t in group)
aggregate_timers.append(
(first_start_time, (k, total_elapsed_ms, num_calls)))
aggregate_timers.sort()
return zip(*aggregate_timers)[1] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:spread; 3, parameters; 3, 4; 4, identifier:iterable; 5, block; 5, 6; 5, 16; 5, 24; 5, 30; 5, 60; 6, if_statement; 6, 7; 6, 13; 7, comparison_operator:==; 7, 8; 7, 12; 8, call; 8, 9; 8, 10; 9, identifier:len; 10, argument_list; 10, 11; 11, identifier:iterable; 12, integer:1; 13, block; 13, 14; 14, return_statement; 14, 15; 15, integer:0; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:iterable; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:iterable; 22, identifier:copy; 23, argument_list; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:iterable; 28, identifier:sort; 29, argument_list; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:max_diff; 33, call; 33, 34; 33, 35; 34, identifier:max; 35, generator_expression; 35, 36; 35, 42; 36, call; 36, 37; 36, 38; 37, identifier:abs; 38, argument_list; 38, 39; 39, binary_operator:-; 39, 40; 39, 41; 40, identifier:i; 41, identifier:j; 42, for_in_clause; 42, 43; 42, 46; 43, tuple_pattern; 43, 44; 43, 45; 44, identifier:i; 45, identifier:j; 46, call; 46, 47; 46, 48; 47, identifier:zip; 48, argument_list; 48, 49; 48, 54; 49, subscript; 49, 50; 49, 51; 50, identifier:iterable; 51, slice; 51, 52; 51, 53; 52, integer:1; 53, colon; 54, subscript; 54, 55; 54, 56; 55, identifier:iterable; 56, slice; 56, 57; 56, 58; 57, colon; 58, unary_operator:-; 58, 59; 59, integer:1; 60, return_statement; 60, 61; 61, identifier:max_diff | def spread(iterable):
if len(iterable) == 1:
return 0
iterable = iterable.copy()
iterable.sort()
max_diff = max(abs(i - j) for (i, j) in zip(iterable[1:], iterable[:-1]))
return max_diff |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_transcripts; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 36; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:txs; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:transcripts; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:key; 17, lambda; 17, 18; 17, 20; 18, lambda_parameters; 18, 19; 19, identifier:x; 20, tuple; 20, 21; 20, 26; 20, 31; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:x; 24, identifier:range; 25, identifier:chr; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:x; 29, identifier:range; 30, identifier:start; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:x; 34, identifier:range; 35, identifier:end; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_transcripts; 41, identifier:txs | def sort_transcripts(self):
txs = sorted(self.transcripts,key=lambda x: (x.range.chr, x.range.start, x.range.end))
self._transcripts = txs |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:in1d_events; 3, parameters; 3, 4; 3, 5; 4, identifier:ar1; 5, identifier:ar2; 6, block; 6, 7; 6, 16; 6, 25; 6, 39; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:ar1; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:np; 13, identifier:ascontiguousarray; 14, argument_list; 14, 15; 15, identifier:ar1; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:ar2; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:ascontiguousarray; 23, argument_list; 23, 24; 24, identifier:ar2; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:tmp; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:np; 31, identifier:empty_like; 32, argument_list; 32, 33; 32, 34; 33, identifier:ar1; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:dtype; 36, attribute; 36, 37; 36, 38; 37, identifier:np; 38, identifier:uint8; 39, return_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:analysis_functions; 43, identifier:get_in1d_sorted; 44, argument_list; 44, 45; 44, 46; 44, 47; 45, identifier:ar1; 46, identifier:ar2; 47, identifier:tmp | def in1d_events(ar1, ar2):
ar1 = np.ascontiguousarray(ar1)
ar2 = np.ascontiguousarray(ar2)
tmp = np.empty_like(ar1, dtype=np.uint8)
return analysis_functions.get_in1d_sorted(ar1, ar2, tmp) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_by_priority; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:iterable; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reverse; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:default_priority; 10, integer:10; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 15, 17; 15, 20; 16, identifier:iterable; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:reverse; 19, identifier:reverse; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:key; 22, lambda; 22, 23; 22, 25; 23, lambda_parameters; 23, 24; 24, identifier:o; 25, call; 25, 26; 25, 27; 26, identifier:getattr; 27, argument_list; 27, 28; 27, 29; 27, 30; 28, identifier:o; 29, string:'priority'; 30, identifier:default_priority | def sort_by_priority(iterable, reverse=False, default_priority=10):
return sorted(iterable, reverse=reverse, key=lambda o: getattr(o, 'priority', default_priority)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:apply; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:func; 6, default_parameter; 6, 7; 6, 8; 7, identifier:mapping; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:new_dtype; 11, None; 12, dictionary_splat_pattern; 12, 13; 13, identifier:kwargs; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 20; 15, 47; 15, 119; 16, call; 16, 17; 16, 18; 17, identifier:callable; 18, argument_list; 18, 19; 19, identifier:func; 20, block; 20, 21; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:Series; 24, argument_list; 24, 25; 24, 38; 24, 41; 24, 44; 25, call; 25, 26; 25, 27; 26, identifier:func; 27, argument_list; 27, 28; 27, 31; 27, 36; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:values; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:weld_type; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:weld_type; 36, dictionary_splat; 36, 37; 37, identifier:kwargs; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:index; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:dtype; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:name; 47, elif_clause; 47, 48; 47, 53; 48, call; 48, 49; 48, 50; 49, identifier:isinstance; 50, argument_list; 50, 51; 50, 52; 51, identifier:func; 52, identifier:str; 53, block; 53, 54; 53, 60; 53, 65; 53, 74; 53, 92; 53, 103; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 57; 56, identifier:check_type; 57, argument_list; 57, 58; 57, 59; 58, identifier:mapping; 59, identifier:dict; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:check_dtype; 63, argument_list; 63, 64; 64, identifier:new_dtype; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:default_mapping; 68, dictionary; 68, 69; 69, pair; 69, 70; 69, 71; 70, string:'self'; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:values; 74, if_statement; 74, 75; 74, 78; 74, 83; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:mapping; 77, None; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:mapping; 82, identifier:default_mapping; 83, else_clause; 83, 84; 84, block; 84, 85; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:mapping; 89, identifier:update; 90, argument_list; 90, 91; 91, identifier:default_mapping; 92, if_statement; 92, 93; 92, 96; 93, comparison_operator:is; 93, 94; 93, 95; 94, identifier:new_dtype; 95, None; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:new_dtype; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:dtype; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:Series; 106, argument_list; 106, 107; 106, 112; 106, 115; 106, 116; 107, call; 107, 108; 107, 109; 108, identifier:weld_udf; 109, argument_list; 109, 110; 109, 111; 110, identifier:func; 111, identifier:mapping; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:index; 115, identifier:new_dtype; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:name; 119, else_clause; 119, 120; 120, block; 120, 121; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:TypeError; 124, argument_list; 124, 125; 125, string:'Expected function or str defining a weld_template' | def apply(self, func, mapping=None, new_dtype=None, **kwargs):
if callable(func):
return Series(func(self.values,
weld_type=self.weld_type,
**kwargs),
self.index,
self.dtype,
self.name)
elif isinstance(func, str):
check_type(mapping, dict)
check_dtype(new_dtype)
default_mapping = {'self': self.values}
if mapping is None:
mapping = default_mapping
else:
mapping.update(default_mapping)
if new_dtype is None:
new_dtype = self.dtype
return Series(weld_udf(func,
mapping),
self.index,
new_dtype,
self.name)
else:
raise TypeError('Expected function or str defining a weld_template') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:weld_sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:arrays; 5, identifier:weld_types; 6, identifier:readable_text; 7, default_parameter; 7, 8; 7, 9; 8, identifier:ascending; 9, True; 10, block; 10, 11; 10, 20; 10, 28; 10, 36; 10, 46; 10, 56; 10, 68; 10, 77; 10, 88; 10, 96; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:weld_obj_sort; 14, call; 14, 15; 14, 16; 15, identifier:_weld_sort; 16, argument_list; 16, 17; 16, 18; 16, 19; 17, identifier:arrays; 18, identifier:weld_types; 19, identifier:ascending; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:weld_obj_struct; 23, call; 23, 24; 23, 25; 24, identifier:weld_vec_of_struct_to_struct_of_vec; 25, argument_list; 25, 26; 25, 27; 26, identifier:weld_obj_sort; 27, identifier:weld_types; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:weld_obj_indices; 31, call; 31, 32; 31, 33; 32, identifier:weld_select_from_struct; 33, argument_list; 33, 34; 33, 35; 34, identifier:weld_obj_struct; 35, integer:0; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:intermediate_result; 39, call; 39, 40; 39, 41; 40, identifier:LazyArrayResult; 41, argument_list; 41, 42; 41, 43; 42, identifier:weld_obj_indices; 43, call; 43, 44; 43, 45; 44, identifier:WeldLong; 45, argument_list; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:dependency_name; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:Cache; 52, identifier:cache_intermediate_result; 53, argument_list; 53, 54; 53, 55; 54, identifier:intermediate_result; 55, identifier:readable_text; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:fake_weld_input; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:Cache; 62, identifier:create_fake_array_input; 63, argument_list; 63, 64; 63, 65; 64, identifier:dependency_name; 65, binary_operator:+; 65, 66; 65, 67; 66, identifier:readable_text; 67, string:'_indices'; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 73; 70, pattern_list; 70, 71; 70, 72; 71, identifier:obj_id; 72, identifier:weld_obj; 73, call; 73, 74; 73, 75; 74, identifier:create_weld_object; 75, argument_list; 75, 76; 76, identifier:fake_weld_input; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:weld_obj; 81, identifier:weld_code; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, string:'{}'; 85, identifier:format; 86, argument_list; 86, 87; 87, identifier:obj_id; 88, expression_statement; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:Cache; 92, identifier:cache_fake_input; 93, argument_list; 93, 94; 93, 95; 94, identifier:obj_id; 95, identifier:fake_weld_input; 96, return_statement; 96, 97; 97, identifier:weld_obj | def weld_sort(arrays, weld_types, readable_text, ascending=True):
weld_obj_sort = _weld_sort(arrays, weld_types, ascending)
weld_obj_struct = weld_vec_of_struct_to_struct_of_vec(weld_obj_sort, weld_types)
weld_obj_indices = weld_select_from_struct(weld_obj_struct, 0)
intermediate_result = LazyArrayResult(weld_obj_indices, WeldLong())
dependency_name = Cache.cache_intermediate_result(intermediate_result, readable_text)
fake_weld_input = Cache.create_fake_array_input(dependency_name, readable_text + '_indices')
obj_id, weld_obj = create_weld_object(fake_weld_input)
weld_obj.weld_code = '{}'.format(obj_id)
Cache.cache_fake_input(obj_id, fake_weld_input)
return weld_obj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:chooseBestDuplicates; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:tped; 5, identifier:samples; 6, identifier:oldSamples; 7, identifier:completion; 8, identifier:concordance_all; 9, identifier:prefix; 10, block; 10, 11; 10, 15; 10, 43; 10, 56; 10, 60; 10, 88; 10, 101; 10, 105; 10, 109; 10, 435; 10, 441; 10, 447; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:chosenFile; 14, None; 15, try_statement; 15, 16; 15, 27; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:chosenFile; 20, call; 20, 21; 20, 22; 21, identifier:open; 22, argument_list; 22, 23; 22, 26; 23, binary_operator:+; 23, 24; 23, 25; 24, identifier:prefix; 25, string:".chosen_samples.info"; 26, string:"w"; 27, except_clause; 27, 28; 27, 29; 28, identifier:IOError; 29, block; 29, 30; 29, 38; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:msg; 33, binary_operator:%; 33, 34; 33, 35; 34, string:"%(prefix)s.chosen_samples.info: can't write file"; 35, call; 35, 36; 35, 37; 36, identifier:locals; 37, argument_list; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:ProgramError; 41, argument_list; 41, 42; 42, identifier:msg; 43, print_statement; 43, 44; 43, 46; 44, chevron; 44, 45; 45, identifier:chosenFile; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, string:"\t"; 49, identifier:join; 50, argument_list; 50, 51; 51, list:["origIndex", "dupIndex", "famID", "indID"]; 51, 52; 51, 53; 51, 54; 51, 55; 52, string:"origIndex"; 53, string:"dupIndex"; 54, string:"famID"; 55, string:"indID"; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:excludedFile; 59, None; 60, try_statement; 60, 61; 60, 72; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:excludedFile; 65, call; 65, 66; 65, 67; 66, identifier:open; 67, argument_list; 67, 68; 67, 71; 68, binary_operator:+; 68, 69; 68, 70; 69, identifier:prefix; 70, string:".excluded_samples.info"; 71, string:"w"; 72, except_clause; 72, 73; 72, 74; 73, identifier:IOError; 74, block; 74, 75; 74, 83; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:msg; 78, binary_operator:%; 78, 79; 78, 80; 79, string:"%(prefix)s.excluded_samples.info: can't write file"; 80, call; 80, 81; 80, 82; 81, identifier:locals; 82, argument_list; 83, raise_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:ProgramError; 86, argument_list; 86, 87; 87, identifier:msg; 88, print_statement; 88, 89; 88, 91; 89, chevron; 89, 90; 90, identifier:excludedFile; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, string:"\t"; 94, identifier:join; 95, argument_list; 95, 96; 96, list:["origIndex", "dupIndex", "famID",
"indID"]; 96, 97; 96, 98; 96, 99; 96, 100; 97, string:"origIndex"; 98, string:"dupIndex"; 99, string:"famID"; 100, string:"indID"; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:chosenIndexes; 104, dictionary; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:sampleConcordance; 108, dictionary; 109, for_statement; 109, 110; 109, 113; 109, 118; 110, pattern_list; 110, 111; 110, 112; 111, identifier:sample; 112, identifier:indexes; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:samples; 116, identifier:iteritems; 117, argument_list; 118, block; 118, 119; 118, 125; 118, 134; 118, 140; 118, 154; 118, 200; 118, 209; 118, 220; 118, 229; 118, 233; 118, 237; 118, 330; 118, 349; 118, 382; 118, 427; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:currCompletion; 122, subscript; 122, 123; 122, 124; 123, identifier:completion; 124, identifier:indexes; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:sortedCompletionIndexes; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:np; 131, identifier:argsort; 132, argument_list; 132, 133; 133, identifier:currCompletion; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:concordance; 137, subscript; 137, 138; 137, 139; 138, identifier:concordance_all; 139, identifier:sample; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:currConcordance; 143, list_comprehension; 143, 144; 143, 145; 144, list:[]; 145, for_in_clause; 145, 146; 145, 147; 146, identifier:i; 147, call; 147, 148; 147, 149; 148, identifier:xrange; 149, argument_list; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:len; 152, argument_list; 152, 153; 153, identifier:indexes; 154, for_statement; 154, 155; 154, 156; 154, 163; 155, identifier:i; 156, call; 156, 157; 156, 158; 157, identifier:xrange; 158, argument_list; 158, 159; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:indexes; 163, block; 163, 164; 163, 186; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:indexToKeep; 167, call; 167, 168; 167, 169; 168, identifier:list; 169, argument_list; 169, 170; 170, binary_operator:-; 170, 171; 170, 181; 171, call; 171, 172; 171, 173; 172, identifier:set; 173, argument_list; 173, 174; 174, call; 174, 175; 174, 176; 175, identifier:range; 176, argument_list; 176, 177; 177, call; 177, 178; 177, 179; 178, identifier:len; 179, argument_list; 179, 180; 180, identifier:indexes; 181, call; 181, 182; 181, 183; 182, identifier:set; 183, argument_list; 183, 184; 184, list:[i]; 184, 185; 185, identifier:i; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:currConcordance; 190, identifier:i; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:np; 194, identifier:mean; 195, argument_list; 195, 196; 196, subscript; 196, 197; 196, 198; 196, 199; 197, identifier:concordance; 198, identifier:i; 199, identifier:indexToKeep; 200, expression_statement; 200, 201; 201, assignment; 201, 202; 201, 203; 202, identifier:currConcordance; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:np; 206, identifier:array; 207, argument_list; 207, 208; 208, identifier:currConcordance; 209, if_statement; 209, 210; 209, 213; 210, comparison_operator:not; 210, 211; 210, 212; 211, identifier:sample; 212, identifier:sampleConcordance; 213, block; 213, 214; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 219; 216, subscript; 216, 217; 216, 218; 217, identifier:sampleConcordance; 218, identifier:sample; 219, identifier:currConcordance; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:sortedConcordanceIndexes; 223, call; 223, 224; 223, 227; 224, attribute; 224, 225; 224, 226; 225, identifier:np; 226, identifier:argsort; 227, argument_list; 227, 228; 228, identifier:currConcordance; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:nbToCheck; 232, integer:1; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:chosenIndex; 236, None; 237, while_statement; 237, 238; 237, 244; 238, comparison_operator:<=; 238, 239; 238, 240; 239, identifier:nbToCheck; 240, call; 240, 241; 240, 242; 241, identifier:len; 242, argument_list; 242, 243; 243, identifier:indexes; 244, block; 244, 245; 244, 256; 244, 267; 244, 283; 244, 299; 244, 305; 244, 326; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:completionValue; 248, subscript; 248, 249; 248, 250; 249, identifier:currCompletion; 250, subscript; 250, 251; 250, 252; 251, identifier:sortedCompletionIndexes; 252, binary_operator:*; 252, 253; 252, 254; 253, identifier:nbToCheck; 254, unary_operator:-; 254, 255; 255, integer:1; 256, expression_statement; 256, 257; 257, assignment; 257, 258; 257, 259; 258, identifier:concordanceValue; 259, subscript; 259, 260; 259, 261; 260, identifier:currConcordance; 261, subscript; 261, 262; 261, 263; 262, identifier:sortedConcordanceIndexes; 263, binary_operator:*; 263, 264; 263, 265; 264, identifier:nbToCheck; 265, unary_operator:-; 265, 266; 266, integer:1; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:completionToConsider; 270, call; 270, 271; 270, 272; 271, identifier:set; 272, argument_list; 272, 273; 273, subscript; 273, 274; 273, 282; 274, call; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:np; 277, identifier:where; 278, argument_list; 278, 279; 279, comparison_operator:>=; 279, 280; 279, 281; 280, identifier:currCompletion; 281, identifier:completionValue; 282, integer:0; 283, expression_statement; 283, 284; 284, assignment; 284, 285; 284, 286; 285, identifier:concordanceToConsider; 286, call; 286, 287; 286, 288; 287, identifier:set; 288, argument_list; 288, 289; 289, subscript; 289, 290; 289, 298; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:np; 293, identifier:where; 294, argument_list; 294, 295; 295, comparison_operator:>=; 295, 296; 295, 297; 296, identifier:currConcordance; 297, identifier:concordanceValue; 298, integer:0; 299, expression_statement; 299, 300; 300, assignment; 300, 301; 300, 302; 301, identifier:toConsider; 302, binary_operator:&; 302, 303; 302, 304; 303, identifier:concordanceToConsider; 304, identifier:completionToConsider; 305, if_statement; 305, 306; 305, 312; 306, comparison_operator:>=; 306, 307; 306, 311; 307, call; 307, 308; 307, 309; 308, identifier:len; 309, argument_list; 309, 310; 310, identifier:toConsider; 311, integer:1; 312, block; 312, 313; 312, 325; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:chosenIndex; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:random; 319, identifier:choice; 320, argument_list; 320, 321; 321, call; 321, 322; 321, 323; 322, identifier:list; 323, argument_list; 323, 324; 324, identifier:toConsider; 325, break_statement; 326, expression_statement; 326, 327; 327, augmented_assignment:+=; 327, 328; 327, 329; 328, identifier:nbToCheck; 329, integer:1; 330, if_statement; 330, 331; 330, 334; 331, comparison_operator:is; 331, 332; 331, 333; 332, identifier:chosenIndex; 333, None; 334, block; 334, 335; 334, 344; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 338; 337, identifier:msg; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, string:"Could not choose the best sample ID for {}"; 341, identifier:format; 342, argument_list; 342, 343; 343, identifier:sample; 344, raise_statement; 344, 345; 345, call; 345, 346; 345, 347; 346, identifier:ProgramError; 347, argument_list; 347, 348; 348, identifier:msg; 349, print_statement; 349, 350; 349, 352; 350, chevron; 350, 351; 351, identifier:chosenFile; 352, call; 352, 353; 352, 356; 353, attribute; 353, 354; 353, 355; 354, string:"\t"; 355, identifier:join; 356, argument_list; 356, 357; 357, list:[str(oldSamples[sample][chosenIndex]+1),
str(indexes[chosenIndex]+1), sample[0],
sample[1]]; 357, 358; 357, 368; 357, 376; 357, 379; 358, call; 358, 359; 358, 360; 359, identifier:str; 360, argument_list; 360, 361; 361, binary_operator:+; 361, 362; 361, 367; 362, subscript; 362, 363; 362, 366; 363, subscript; 363, 364; 363, 365; 364, identifier:oldSamples; 365, identifier:sample; 366, identifier:chosenIndex; 367, integer:1; 368, call; 368, 369; 368, 370; 369, identifier:str; 370, argument_list; 370, 371; 371, binary_operator:+; 371, 372; 371, 375; 372, subscript; 372, 373; 372, 374; 373, identifier:indexes; 374, identifier:chosenIndex; 375, integer:1; 376, subscript; 376, 377; 376, 378; 377, identifier:sample; 378, integer:0; 379, subscript; 379, 380; 379, 381; 380, identifier:sample; 381, integer:1; 382, for_statement; 382, 383; 382, 386; 382, 390; 383, pattern_list; 383, 384; 383, 385; 384, identifier:i; 385, identifier:index; 386, call; 386, 387; 386, 388; 387, identifier:enumerate; 388, argument_list; 388, 389; 389, identifier:indexes; 390, block; 390, 391; 391, if_statement; 391, 392; 391, 395; 392, comparison_operator:!=; 392, 393; 392, 394; 393, identifier:i; 394, identifier:chosenIndex; 395, block; 395, 396; 396, print_statement; 396, 397; 396, 399; 397, chevron; 397, 398; 398, identifier:excludedFile; 399, call; 399, 400; 399, 403; 400, attribute; 400, 401; 400, 402; 401, string:"\t"; 402, identifier:join; 403, argument_list; 403, 404; 404, list:[str(oldSamples[sample][i]+1),
str(index+1), sample[0],
sample[1]]; 404, 405; 404, 415; 404, 421; 404, 424; 405, call; 405, 406; 405, 407; 406, identifier:str; 407, argument_list; 407, 408; 408, binary_operator:+; 408, 409; 408, 414; 409, subscript; 409, 410; 409, 413; 410, subscript; 410, 411; 410, 412; 411, identifier:oldSamples; 412, identifier:sample; 413, identifier:i; 414, integer:1; 415, call; 415, 416; 415, 417; 416, identifier:str; 417, argument_list; 417, 418; 418, binary_operator:+; 418, 419; 418, 420; 419, identifier:index; 420, integer:1; 421, subscript; 421, 422; 421, 423; 422, identifier:sample; 423, integer:0; 424, subscript; 424, 425; 424, 426; 425, identifier:sample; 426, integer:1; 427, expression_statement; 427, 428; 428, assignment; 428, 429; 428, 432; 429, subscript; 429, 430; 429, 431; 430, identifier:chosenIndexes; 431, identifier:sample; 432, subscript; 432, 433; 432, 434; 433, identifier:indexes; 434, identifier:chosenIndex; 435, expression_statement; 435, 436; 436, call; 436, 437; 436, 440; 437, attribute; 437, 438; 437, 439; 438, identifier:chosenFile; 439, identifier:close; 440, argument_list; 441, expression_statement; 441, 442; 442, call; 442, 443; 442, 446; 443, attribute; 443, 444; 443, 445; 444, identifier:excludedFile; 445, identifier:close; 446, argument_list; 447, return_statement; 447, 448; 448, expression_list; 448, 449; 448, 450; 448, 451; 449, identifier:chosenIndexes; 450, identifier:completion; 451, identifier:sampleConcordance | def chooseBestDuplicates(tped, samples, oldSamples, completion,
concordance_all, prefix):
chosenFile = None
try:
chosenFile = open(prefix + ".chosen_samples.info", "w")
except IOError:
msg = "%(prefix)s.chosen_samples.info: can't write file" % locals()
raise ProgramError(msg)
print >>chosenFile, "\t".join(["origIndex", "dupIndex", "famID", "indID"])
excludedFile = None
try:
excludedFile = open(prefix + ".excluded_samples.info", "w")
except IOError:
msg = "%(prefix)s.excluded_samples.info: can't write file" % locals()
raise ProgramError(msg)
print >>excludedFile, "\t".join(["origIndex", "dupIndex", "famID",
"indID"])
chosenIndexes = {}
sampleConcordance = {}
for sample, indexes in samples.iteritems():
currCompletion = completion[indexes]
sortedCompletionIndexes = np.argsort(currCompletion)
concordance = concordance_all[sample]
currConcordance = [[] for i in xrange(len(indexes))]
for i in xrange(len(indexes)):
indexToKeep = list(set(range(len(indexes))) - set([i]))
currConcordance[i] = np.mean(concordance[i, indexToKeep])
currConcordance = np.array(currConcordance)
if sample not in sampleConcordance:
sampleConcordance[sample] = currConcordance
sortedConcordanceIndexes = np.argsort(currConcordance)
nbToCheck = 1
chosenIndex = None
while nbToCheck <= len(indexes):
completionValue = currCompletion[
sortedCompletionIndexes[nbToCheck*-1]
]
concordanceValue = currConcordance[
sortedConcordanceIndexes[nbToCheck*-1]
]
completionToConsider = set(
np.where(currCompletion >= completionValue)[0]
)
concordanceToConsider = set(
np.where(currConcordance >= concordanceValue)[0])
toConsider = concordanceToConsider & completionToConsider
if len(toConsider) >= 1:
chosenIndex = random.choice(list(toConsider))
break
nbToCheck += 1
if chosenIndex is None:
msg = "Could not choose the best sample ID for {}".format(sample)
raise ProgramError(msg)
print >>chosenFile, "\t".join([str(oldSamples[sample][chosenIndex]+1),
str(indexes[chosenIndex]+1), sample[0],
sample[1]])
for i, index in enumerate(indexes):
if i != chosenIndex:
print >>excludedFile, "\t".join([str(oldSamples[sample][i]+1),
str(index+1), sample[0],
sample[1]])
chosenIndexes[sample] = indexes[chosenIndex]
chosenFile.close()
excludedFile.close()
return chosenIndexes, completion, sampleConcordance |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:order_qc_dir; 3, parameters; 3, 4; 4, identifier:dirnames; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 11; 10, identifier:dirnames; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:key; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:dn; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:time; 19, identifier:strptime; 20, argument_list; 20, 21; 20, 38; 21, subscript; 21, 22; 21, 35; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:os; 26, identifier:path; 27, identifier:basename; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:dn; 32, identifier:rstrip; 33, argument_list; 33, 34; 34, string:"/"; 35, slice; 35, 36; 35, 37; 36, integer:14; 37, colon; 38, string:"%Y-%m-%d_%H.%M.%S" | def order_qc_dir(dirnames):
return sorted(
dirnames, key=lambda dn: time.strptime(
os.path.basename(dn.rstrip("/"))[14:],
"%Y-%m-%d_%H.%M.%S",
)
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:fetch; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:webfonts; 6, block; 6, 7; 6, 18; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sorted_keys; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:webfonts; 16, identifier:keys; 17, argument_list; 18, for_statement; 18, 19; 18, 20; 18, 21; 19, identifier:webfont_name; 20, identifier:sorted_keys; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:get; 27, argument_list; 27, 28; 27, 29; 28, identifier:webfont_name; 29, subscript; 29, 30; 29, 31; 30, identifier:webfonts; 31, identifier:webfont_name | def fetch(self, webfonts):
sorted_keys = sorted(webfonts.keys())
for webfont_name in sorted_keys:
self.get(webfont_name, webfonts[webfont_name]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_index; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ascending; 7, True; 8, block; 8, 9; 8, 23; 9, if_statement; 9, 10; 9, 17; 10, call; 10, 11; 10, 12; 11, identifier:isinstance; 12, argument_list; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:index; 16, identifier:MultiIndex; 17, block; 17, 18; 18, raise_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:NotImplementedError; 21, argument_list; 21, 22; 22, string:'Weld does not yet support sorting on multiple columns'; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:sort_values; 28, argument_list; 28, 29; 28, 36; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:index; 34, identifier:_gather_names; 35, argument_list; 36, identifier:ascending | def sort_index(self, ascending=True):
if isinstance(self.index, MultiIndex):
raise NotImplementedError('Weld does not yet support sorting on multiple columns')
return self.sort_values(self.index._gather_names(), ascending) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort_values; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:by; 6, default_parameter; 6, 7; 6, 8; 7, identifier:ascending; 8, True; 9, block; 9, 10; 9, 16; 9, 21; 9, 28; 9, 41; 9, 49; 9, 55; 9, 75; 9, 86; 9, 97; 9, 107; 9, 120; 9, 131; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:check_type; 13, argument_list; 13, 14; 13, 15; 14, identifier:ascending; 15, identifier:bool; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:check_str_or_list_str; 19, argument_list; 19, 20; 20, identifier:by; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:by; 24, call; 24, 25; 24, 26; 25, identifier:as_list; 26, argument_list; 26, 27; 27, identifier:by; 28, if_statement; 28, 29; 28, 35; 29, comparison_operator:>; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, identifier:by; 34, integer:1; 35, block; 35, 36; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:NotImplementedError; 39, argument_list; 39, 40; 40, string:'Weld does not yet support sorting on multiple columns'; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:all_data; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:reset_index; 48, argument_list; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:by_data; 52, subscript; 52, 53; 52, 54; 53, identifier:all_data; 54, identifier:by; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:sorted_indices; 58, call; 58, 59; 58, 60; 59, identifier:weld_sort; 60, argument_list; 60, 61; 60, 66; 60, 71; 60, 72; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:by_data; 64, identifier:_gather_data_for_weld; 65, argument_list; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:by_data; 69, identifier:_gather_weld_types; 70, argument_list; 71, string:'sort_index'; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:ascending; 74, identifier:ascending; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:new_index; 78, call; 78, 79; 78, 84; 79, attribute; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:index; 83, identifier:_iloc_indices; 84, argument_list; 84, 85; 85, identifier:sorted_indices; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:new_columns; 89, call; 89, 90; 89, 91; 90, identifier:list; 91, argument_list; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:_iter; 96, argument_list; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:new_column_names; 100, list_comprehension; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:column; 103, identifier:name; 104, for_in_clause; 104, 105; 104, 106; 105, identifier:column; 106, identifier:new_columns; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:new_columns; 110, list_comprehension; 110, 111; 110, 117; 111, call; 111, 112; 111, 113; 112, identifier:_series_iloc; 113, argument_list; 113, 114; 113, 115; 113, 116; 114, identifier:column; 115, identifier:sorted_indices; 116, identifier:new_index; 117, for_in_clause; 117, 118; 117, 119; 118, identifier:column; 119, identifier:new_columns; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:new_data; 123, call; 123, 124; 123, 125; 124, identifier:OrderedDict; 125, argument_list; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:zip; 128, argument_list; 128, 129; 128, 130; 129, identifier:new_column_names; 130, identifier:new_columns; 131, return_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:DataFrame; 134, argument_list; 134, 135; 134, 136; 135, identifier:new_data; 136, identifier:new_index | def sort_values(self, by, ascending=True):
check_type(ascending, bool)
check_str_or_list_str(by)
by = as_list(by)
if len(by) > 1:
raise NotImplementedError('Weld does not yet support sorting on multiple columns')
all_data = self.reset_index()
by_data = all_data[by]
sorted_indices = weld_sort(by_data._gather_data_for_weld(),
by_data._gather_weld_types(),
'sort_index',
ascending=ascending)
new_index = self.index._iloc_indices(sorted_indices)
new_columns = list(self._iter())
new_column_names = [column.name for column in new_columns]
new_columns = [_series_iloc(column, sorted_indices, new_index) for column in new_columns]
new_data = OrderedDict(zip(new_column_names, new_columns))
return DataFrame(new_data, new_index) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:optimize_with_repeates; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:fast; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:verbose; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:n_times; 13, integer:10; 14, default_parameter; 14, 15; 14, 16; 15, identifier:lambd; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:lambd_g; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:lambd_n; 22, None; 23, block; 23, 24; 23, 33; 23, 46; 23, 50; 23, 67; 23, 223; 23, 246; 23, 260; 23, 264; 23, 282; 23, 333; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:verbose; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:dlimix; 30, identifier:getVerbose; 31, argument_list; 31, 32; 32, identifier:verbose; 33, if_statement; 33, 34; 33, 38; 34, not_operator; 34, 35; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:init; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_initGP; 44, argument_list; 44, 45; 45, identifier:fast; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:opt_list; 49, list:[]; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:fixed0; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:sp; 56, identifier:zeros_like; 57, argument_list; 57, 58; 58, subscript; 58, 59; 58, 66; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:gp; 64, identifier:getParams; 65, argument_list; 66, string:'dataTerm'; 67, for_statement; 67, 68; 67, 69; 67, 73; 68, identifier:i; 69, call; 69, 70; 69, 71; 70, identifier:range; 71, argument_list; 71, 72; 72, identifier:n_times; 73, block; 73, 74; 73, 82; 73, 102; 73, 128; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:scales1; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_getScalesRand; 81, argument_list; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:fixed1; 85, binary_operator:*; 85, 86; 85, 87; 86, float:1e-1; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:sp; 90, identifier:randn; 91, argument_list; 91, 92; 91, 97; 92, subscript; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:fixed0; 95, identifier:shape; 96, integer:0; 97, subscript; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:fixed0; 100, identifier:shape; 101, integer:1; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:conv; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:trainGP; 109, argument_list; 109, 110; 109, 113; 109, 116; 109, 119; 109, 122; 109, 125; 110, keyword_argument; 110, 111; 110, 112; 111, identifier:fast; 112, identifier:fast; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:scales0; 115, identifier:scales1; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:fixed0; 118, identifier:fixed1; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:lambd; 121, identifier:lambd; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:lambd_g; 124, identifier:lambd_g; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:lambd_n; 127, identifier:lambd_n; 128, if_statement; 128, 129; 128, 130; 129, identifier:conv; 130, block; 130, 131; 130, 135; 130, 181; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:temp; 134, integer:1; 135, for_statement; 135, 136; 135, 137; 135, 144; 136, identifier:j; 137, call; 137, 138; 137, 139; 138, identifier:range; 139, argument_list; 139, 140; 140, call; 140, 141; 140, 142; 141, identifier:len; 142, argument_list; 142, 143; 143, identifier:opt_list; 144, block; 144, 145; 145, if_statement; 145, 146; 145, 167; 146, call; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:sp; 149, identifier:allclose; 150, argument_list; 150, 151; 150, 159; 151, call; 151, 152; 151, 153; 152, identifier:abs; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:getScales; 158, argument_list; 159, call; 159, 160; 159, 161; 160, identifier:abs; 161, argument_list; 161, 162; 162, subscript; 162, 163; 162, 166; 163, subscript; 163, 164; 163, 165; 164, identifier:opt_list; 165, identifier:j; 166, string:'scales'; 167, block; 167, 168; 167, 172; 167, 180; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:temp; 171, integer:0; 172, expression_statement; 172, 173; 173, augmented_assignment:+=; 173, 174; 173, 179; 174, subscript; 174, 175; 174, 178; 175, subscript; 175, 176; 175, 177; 176, identifier:opt_list; 177, identifier:j; 178, string:'counter'; 179, integer:1; 180, break_statement; 181, if_statement; 181, 182; 181, 185; 182, comparison_operator:==; 182, 183; 182, 184; 183, identifier:temp; 184, integer:1; 185, block; 185, 186; 185, 190; 185, 196; 185, 206; 185, 216; 186, expression_statement; 186, 187; 187, assignment; 187, 188; 187, 189; 188, identifier:opt; 189, dictionary; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 195; 192, subscript; 192, 193; 192, 194; 193, identifier:opt; 194, string:'counter'; 195, integer:1; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, subscript; 198, 199; 198, 200; 199, identifier:opt; 200, string:'LML'; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:self; 204, identifier:getLML; 205, argument_list; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:opt; 210, string:'scales'; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:self; 214, identifier:getScales; 215, argument_list; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:opt_list; 220, identifier:append; 221, argument_list; 221, 222; 222, identifier:opt; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:LML; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:sp; 229, identifier:array; 230, argument_list; 230, 231; 231, list_comprehension; 231, 232; 231, 237; 232, subscript; 232, 233; 232, 236; 233, subscript; 233, 234; 233, 235; 234, identifier:opt_list; 235, identifier:i; 236, string:'LML'; 237, for_in_clause; 237, 238; 237, 239; 238, identifier:i; 239, call; 239, 240; 239, 241; 240, identifier:range; 241, argument_list; 241, 242; 242, call; 242, 243; 242, 244; 243, identifier:len; 244, argument_list; 244, 245; 245, identifier:opt_list; 246, expression_statement; 246, 247; 247, assignment; 247, 248; 247, 249; 248, identifier:index; 249, subscript; 249, 250; 249, 255; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:LML; 253, identifier:argsort; 254, argument_list; 255, slice; 255, 256; 255, 257; 255, 258; 256, colon; 257, colon; 258, unary_operator:-; 258, 259; 259, integer:1; 260, expression_statement; 260, 261; 261, assignment; 261, 262; 261, 263; 262, identifier:out; 263, list:[]; 264, if_statement; 264, 265; 264, 266; 265, identifier:verbose; 266, block; 266, 267; 266, 272; 266, 277; 267, expression_statement; 267, 268; 268, call; 268, 269; 268, 270; 269, identifier:print; 270, argument_list; 270, 271; 271, string:"\nLocal mimima\n"; 272, expression_statement; 272, 273; 273, call; 273, 274; 273, 275; 274, identifier:print; 275, argument_list; 275, 276; 276, string:"n_times\t\tLML"; 277, expression_statement; 277, 278; 278, call; 278, 279; 278, 280; 279, identifier:print; 280, argument_list; 280, 281; 281, string:"------------------------------------"; 282, for_statement; 282, 283; 282, 284; 282, 291; 283, identifier:i; 284, call; 284, 285; 284, 286; 285, identifier:range; 286, argument_list; 286, 287; 287, call; 287, 288; 287, 289; 288, identifier:len; 289, argument_list; 289, 290; 290, identifier:opt_list; 291, block; 291, 292; 291, 303; 292, expression_statement; 292, 293; 293, call; 293, 294; 293, 297; 294, attribute; 294, 295; 294, 296; 295, identifier:out; 296, identifier:append; 297, argument_list; 297, 298; 298, subscript; 298, 299; 298, 300; 299, identifier:opt_list; 300, subscript; 300, 301; 300, 302; 301, identifier:index; 302, identifier:i; 303, if_statement; 303, 304; 303, 305; 304, identifier:verbose; 305, block; 305, 306; 305, 328; 306, expression_statement; 306, 307; 307, call; 307, 308; 307, 309; 308, identifier:print; 309, argument_list; 309, 310; 310, parenthesized_expression; 310, 311; 311, binary_operator:%; 311, 312; 311, 313; 312, string:"%d\t\t%f"; 313, tuple; 313, 314; 313, 321; 314, subscript; 314, 315; 314, 320; 315, subscript; 315, 316; 315, 317; 316, identifier:opt_list; 317, subscript; 317, 318; 317, 319; 318, identifier:index; 319, identifier:i; 320, string:'counter'; 321, subscript; 321, 322; 321, 327; 322, subscript; 322, 323; 322, 324; 323, identifier:opt_list; 324, subscript; 324, 325; 324, 326; 325, identifier:index; 326, identifier:i; 327, string:'LML'; 328, expression_statement; 328, 329; 329, call; 329, 330; 329, 331; 330, identifier:print; 331, argument_list; 331, 332; 332, string:""; 333, return_statement; 333, 334; 334, identifier:out | def optimize_with_repeates(self,fast=None,verbose=None,n_times=10,lambd=None,lambd_g=None,lambd_n=None):
verbose = dlimix.getVerbose(verbose)
if not self.init: self._initGP(fast)
opt_list = []
fixed0 = sp.zeros_like(self.gp.getParams()['dataTerm'])
for i in range(n_times):
scales1 = self._getScalesRand()
fixed1 = 1e-1*sp.randn(fixed0.shape[0],fixed0.shape[1])
conv = self.trainGP(fast=fast,scales0=scales1,fixed0=fixed1,lambd=lambd,lambd_g=lambd_g,lambd_n=lambd_n)
if conv:
temp=1
for j in range(len(opt_list)):
if sp.allclose(abs(self.getScales()),abs(opt_list[j]['scales'])):
temp=0
opt_list[j]['counter']+=1
break
if temp==1:
opt = {}
opt['counter'] = 1
opt['LML'] = self.getLML()
opt['scales'] = self.getScales()
opt_list.append(opt)
LML = sp.array([opt_list[i]['LML'] for i in range(len(opt_list))])
index = LML.argsort()[::-1]
out = []
if verbose:
print("\nLocal mimima\n")
print("n_times\t\tLML")
print("------------------------------------")
for i in range(len(opt_list)):
out.append(opt_list[index[i]])
if verbose:
print(("%d\t\t%f" % (opt_list[index[i]]['counter'], opt_list[index[i]]['LML'])))
print("")
return out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_prefixes; 3, parameters; 3, 4; 3, 5; 4, identifier:orig; 5, default_parameter; 5, 6; 5, 7; 6, identifier:prefixes; 7, string:'@+'; 8, block; 8, 9; 8, 13; 8, 26; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:new; 12, string:''; 13, for_statement; 13, 14; 13, 15; 13, 16; 14, identifier:prefix; 15, identifier:prefixes; 16, block; 16, 17; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:in; 18, 19; 18, 20; 19, identifier:prefix; 20, identifier:orig; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, augmented_assignment:+=; 23, 24; 23, 25; 24, identifier:new; 25, identifier:prefix; 26, return_statement; 26, 27; 27, identifier:new | def sort_prefixes(orig, prefixes='@+'):
new = ''
for prefix in prefixes:
if prefix in orig:
new += prefix
return new |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort_children; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:attribute; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse_order; 10, False; 11, block; 11, 12; 11, 16; 11, 113; 11, 119; 11, 133; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:sorted_children; 15, list:[]; 16, if_statement; 16, 17; 16, 18; 16, 88; 17, identifier:attribute; 18, block; 18, 19; 18, 23; 18, 27; 18, 57; 18, 81; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:sortable_children; 22, list:[]; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:unsortable_children; 26, list:[]; 27, for_statement; 27, 28; 27, 29; 27, 32; 28, identifier:child; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:__children; 32, block; 32, 33; 33, if_statement; 33, 34; 33, 40; 33, 48; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:child; 37, identifier:attribute_exists; 38, argument_list; 38, 39; 39, identifier:attribute; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:sortable_children; 45, identifier:append; 46, argument_list; 46, 47; 47, identifier:child; 48, else_clause; 48, 49; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:unsortable_children; 54, identifier:append; 55, argument_list; 55, 56; 56, identifier:child; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:sorted_children; 60, call; 60, 61; 60, 62; 61, identifier:sorted; 62, argument_list; 62, 63; 62, 64; 62, 76; 63, identifier:sortable_children; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:key; 66, lambda; 66, 67; 66, 69; 67, lambda_parameters; 67, 68; 68, identifier:x; 69, attribute; 69, 70; 69, 75; 70, call; 70, 71; 70, 72; 71, identifier:getattr; 72, argument_list; 72, 73; 72, 74; 73, identifier:x; 74, identifier:attribute; 75, identifier:value; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:reverse; 78, boolean_operator:or; 78, 79; 78, 80; 79, identifier:reverse_order; 80, False; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:sorted_children; 85, identifier:extend; 86, argument_list; 86, 87; 87, identifier:unsortable_children; 88, else_clause; 88, 89; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:sorted_children; 93, call; 93, 94; 93, 95; 94, identifier:sorted; 95, argument_list; 95, 96; 95, 99; 95, 108; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:children; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:key; 101, lambda; 101, 102; 101, 104; 102, lambda_parameters; 102, 103; 103, identifier:x; 104, parenthesized_expression; 104, 105; 105, attribute; 105, 106; 105, 107; 106, identifier:x; 107, identifier:name; 108, keyword_argument; 108, 109; 108, 110; 109, identifier:reverse; 110, boolean_operator:or; 110, 111; 110, 112; 111, identifier:reverse_order; 112, False; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:__children; 118, identifier:sorted_children; 119, for_statement; 119, 120; 119, 121; 119, 124; 120, identifier:child; 121, attribute; 121, 122; 121, 123; 122, identifier:self; 123, identifier:__children; 124, block; 124, 125; 125, expression_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:child; 129, identifier:sort_children; 130, argument_list; 130, 131; 130, 132; 131, identifier:attribute; 132, identifier:reverse_order; 133, return_statement; 133, 134; 134, True | def sort_children(self, attribute=None, reverse_order=False):
sorted_children = []
if attribute:
sortable_children = []
unsortable_children = []
for child in self.__children:
if child.attribute_exists(attribute):
sortable_children.append(child)
else:
unsortable_children.append(child)
sorted_children = sorted(sortable_children, key=lambda x: getattr(
x, attribute).value, reverse=reverse_order or False)
sorted_children.extend(unsortable_children)
else:
sorted_children = sorted(self.children, key=lambda x: (x.name), reverse=reverse_order or False)
self.__children = sorted_children
for child in self.__children:
child.sort_children(attribute, reverse_order)
return True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_sort_kw_matches; 3, parameters; 3, 4; 3, 5; 4, identifier:skw_matches; 5, default_parameter; 5, 6; 5, 7; 6, identifier:limit; 7, integer:0; 8, block; 8, 9; 8, 20; 8, 31; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sorted_keywords; 12, call; 12, 13; 12, 14; 13, identifier:list; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:skw_matches; 18, identifier:items; 19, argument_list; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:sorted; 23, argument_list; 23, 24; 23, 25; 24, identifier:sorted_keywords; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:key; 27, call; 27, 28; 27, 29; 28, identifier:cmp_to_key; 29, argument_list; 29, 30; 30, identifier:_skw_matches_comparator; 31, return_statement; 31, 32; 32, boolean_operator:or; 32, 33; 32, 40; 33, boolean_operator:and; 33, 34; 33, 35; 34, identifier:limit; 35, subscript; 35, 36; 35, 37; 36, identifier:sorted_keywords; 37, slice; 37, 38; 37, 39; 38, colon; 39, identifier:limit; 40, identifier:sorted_keywords | def _sort_kw_matches(skw_matches, limit=0):
sorted_keywords = list(skw_matches.items())
sorted(sorted_keywords, key=cmp_to_key(_skw_matches_comparator))
return limit and sorted_keywords[:limit] or sorted_keywords |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:trim; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:n_peaks; 6, block; 6, 7; 6, 13; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:sortByIntensity; 12, argument_list; 13, expression_statement; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:ims; 17, identifier:spectrum_trim; 18, argument_list; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:ptr; 22, identifier:n_peaks | def trim(self, n_peaks):
self.sortByIntensity()
ims.spectrum_trim(self.ptr, n_peaks) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:centroids; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:window_size; 7, integer:5; 8, block; 8, 9; 8, 15; 8, 25; 8, 35; 8, 41; 8, 60; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:sortByMass; 14, argument_list; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:mzs; 18, call; 18, 19; 18, 20; 19, identifier:_cffi_buffer; 20, argument_list; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:masses; 24, string:'d'; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:intensities; 28, call; 28, 29; 28, 30; 29, identifier:_cffi_buffer; 30, argument_list; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:intensities; 34, string:'f'; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:n; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:size; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:p; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:ims; 47, identifier:spectrum_new_from_raw; 48, argument_list; 48, 49; 48, 50; 48, 53; 48, 56; 49, identifier:n; 50, attribute; 50, 51; 50, 52; 51, identifier:mzs; 52, identifier:ptr; 53, attribute; 53, 54; 53, 55; 54, identifier:intensities; 55, identifier:ptr; 56, call; 56, 57; 56, 58; 57, identifier:int; 58, argument_list; 58, 59; 59, identifier:window_size; 60, return_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:_new_spectrum; 63, argument_list; 63, 64; 63, 65; 64, identifier:CentroidedSpectrum; 65, identifier:p | def centroids(self, window_size=5):
self.sortByMass()
mzs = _cffi_buffer(self.masses, 'd')
intensities = _cffi_buffer(self.intensities, 'f')
n = self.size
p = ims.spectrum_new_from_raw(n, mzs.ptr, intensities.ptr, int(window_size))
return _new_spectrum(CentroidedSpectrum, p) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:list_engines_by_priority; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:engines; 6, None; 7, block; 7, 8; 7, 17; 8, if_statement; 8, 9; 8, 12; 9, comparison_operator:is; 9, 10; 9, 11; 10, identifier:engines; 11, None; 12, block; 12, 13; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:engines; 16, identifier:ENGINES; 17, return_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 20, 21; 20, 22; 21, identifier:engines; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:key; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:operator; 27, identifier:methodcaller; 28, argument_list; 28, 29; 29, string:"priority" | def list_engines_by_priority(engines=None):
if engines is None:
engines = ENGINES
return sorted(engines, key=operator.methodcaller("priority")) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:union; 3, parameters; 3, 4; 3, 5; 4, identifier:dict1; 5, identifier:dict2; 6, block; 6, 7; 6, 48; 7, for_statement; 7, 8; 7, 11; 7, 16; 8, pattern_list; 8, 9; 8, 10; 9, identifier:key; 10, identifier:value; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:dict2; 14, identifier:items; 15, argument_list; 16, block; 16, 17; 17, if_statement; 17, 18; 17, 27; 17, 40; 18, boolean_operator:and; 18, 19; 18, 22; 19, comparison_operator:in; 19, 20; 19, 21; 20, identifier:key; 21, identifier:dict1; 22, call; 22, 23; 22, 24; 23, identifier:isinstance; 24, argument_list; 24, 25; 24, 26; 25, identifier:value; 26, identifier:dict; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:dict1; 32, identifier:key; 33, call; 33, 34; 33, 35; 34, identifier:union; 35, argument_list; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:dict1; 38, identifier:key; 39, identifier:value; 40, else_clause; 40, 41; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:dict1; 46, identifier:key; 47, identifier:value; 48, return_statement; 48, 49; 49, identifier:dict1 | def union(dict1, dict2):
for key, value in dict2.items():
if key in dict1 and isinstance(value, dict):
dict1[key] = union(dict1[key], value)
else:
dict1[key] = value
return dict1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_format_data; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:data; 6, block; 6, 7; 7, return_statement; 7, 8; 8, list_comprehension; 8, 9; 8, 10; 8, 37; 9, identifier:spectrum; 10, for_in_clause; 10, 11; 10, 12; 10, 13; 11, identifier:spectrum; 12, line_continuation:\; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 15, 27; 16, conditional_expression:if; 16, 17; 16, 18; 16, 25; 17, identifier:data; 18, call; 18, 19; 18, 20; 19, identifier:isinstance; 20, argument_list; 20, 21; 20, 22; 21, identifier:data; 22, tuple; 22, 23; 22, 24; 23, identifier:list; 24, identifier:tuple; 25, list:[data]; 25, 26; 26, identifier:data; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:key; 29, lambda; 29, 30; 29, 32; 30, lambda_parameters; 30, 31; 31, identifier:x; 32, subscript; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:x; 35, identifier:disp; 36, integer:0; 37, if_clause; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:np; 41, identifier:any; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:np; 46, identifier:isfinite; 47, argument_list; 47, 48; 48, attribute; 48, 49; 48, 50; 49, identifier:spectrum; 50, identifier:flux | def _format_data(self, data):
return [spectrum for spectrum in \
sorted(data if isinstance(data, (list, tuple)) else [data],
key=lambda x: x.disp[0]) if np.any(np.isfinite(spectrum.flux))] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_sorting; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:request; 6, dictionary_splat_pattern; 6, 7; 7, identifier:resources; 8, block; 8, 9; 8, 13; 8, 21; 8, 31; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sorting; 12, list:[]; 13, if_statement; 13, 14; 13, 18; 14, not_operator; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:request; 17, identifier:GET; 18, block; 18, 19; 19, return_statement; 19, 20; 20, identifier:sorting; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:prefix; 24, binary_operator:+; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_meta; 29, identifier:dyn_prefix; 30, string:'sort'; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:request; 36, identifier:GET; 37, identifier:getlist; 38, argument_list; 38, 39; 39, identifier:prefix | def get_sorting(self, request, **resources):
sorting = []
if not request.GET:
return sorting
prefix = self._meta.dyn_prefix + 'sort'
return request.GET.getlist(prefix) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:sort_tuples; 7, block; 7, 8; 7, 10; 7, 14; 7, 72; 8, expression_statement; 8, 9; 9, string:''' pymongo-style sorting. Accepts a list of tuples.
:param sort_tuples: varargs of sort tuples.
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:query; 13, identifier:self; 14, for_statement; 14, 15; 14, 18; 14, 19; 15, pattern_list; 15, 16; 15, 17; 16, identifier:name; 17, identifier:direction; 18, identifier:sort_tuples; 19, block; 19, 20; 19, 30; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:field; 23, call; 23, 24; 23, 25; 24, identifier:resolve_name; 25, argument_list; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:type; 29, identifier:name; 30, if_statement; 30, 31; 30, 36; 30, 46; 30, 63; 31, comparison_operator:in; 31, 32; 31, 33; 32, identifier:direction; 33, tuple; 33, 34; 33, 35; 34, identifier:ASCENDING; 35, integer:1; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:query; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:query; 43, identifier:ascending; 44, argument_list; 44, 45; 45, identifier:field; 46, elif_clause; 46, 47; 46, 53; 47, comparison_operator:in; 47, 48; 47, 49; 48, identifier:direction; 49, tuple; 49, 50; 49, 51; 50, identifier:DESCENDING; 51, unary_operator:-; 51, 52; 52, integer:1; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:query; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:query; 60, identifier:descending; 61, argument_list; 61, 62; 62, identifier:field; 63, else_clause; 63, 64; 64, block; 64, 65; 65, raise_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:BadQueryException; 68, argument_list; 68, 69; 69, binary_operator:%; 69, 70; 69, 71; 70, string:'Bad sort direction: %s'; 71, identifier:direction; 72, return_statement; 72, 73; 73, identifier:query | def sort(self, *sort_tuples):
''' pymongo-style sorting. Accepts a list of tuples.
:param sort_tuples: varargs of sort tuples.
'''
query = self
for name, direction in sort_tuples:
field = resolve_name(self.type, name)
if direction in (ASCENDING, 1):
query = query.ascending(field)
elif direction in (DESCENDING, -1):
query = query.descending(field)
else:
raise BadQueryException('Bad sort direction: %s' % direction)
return query |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_has_bad_coords; 3, parameters; 3, 4; 3, 5; 4, identifier:root; 5, identifier:stream; 6, block; 6, 7; 6, 14; 6, 29; 6, 38; 6, 55; 7, if_statement; 7, 8; 7, 11; 8, comparison_operator:==; 8, 9; 8, 10; 9, identifier:stream; 10, string:"com.dc3/dc3.broker"; 11, block; 11, 12; 12, return_statement; 12, 13; 13, True; 14, if_statement; 14, 15; 14, 26; 15, not_operator; 15, 16; 16, comparison_operator:==; 16, 17; 16, 25; 17, subscript; 17, 18; 17, 24; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:stream; 21, identifier:split; 22, argument_list; 22, 23; 23, string:'/'; 24, integer:0; 25, string:'nasa.gsfc.gcn'; 26, block; 26, 27; 27, return_statement; 27, 28; 28, False; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:toplevel_params; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:vp; 35, identifier:get_toplevel_params; 36, argument_list; 36, 37; 37, identifier:root; 38, if_statement; 38, 39; 38, 42; 39, comparison_operator:in; 39, 40; 39, 41; 40, string:"Coords_String"; 41, identifier:toplevel_params; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 52; 44, parenthesized_expression; 44, 45; 45, comparison_operator:==; 45, 46; 45, 51; 46, subscript; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:toplevel_params; 49, string:"Coords_String"; 50, string:'value'; 51, string:"unavailable/inappropriate"; 52, block; 52, 53; 53, return_statement; 53, 54; 54, True; 55, return_statement; 55, 56; 56, False | def _has_bad_coords(root, stream):
if stream == "com.dc3/dc3.broker":
return True
if not stream.split('/')[0] == 'nasa.gsfc.gcn':
return False
toplevel_params = vp.get_toplevel_params(root)
if "Coords_String" in toplevel_params:
if (toplevel_params["Coords_String"]['value'] ==
"unavailable/inappropriate"):
return True
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 1, 31; 2, function_name:sorted_chain; 3, parameters; 3, 4; 4, typed_parameter; 4, 5; 4, 7; 5, list_splat_pattern; 5, 6; 6, identifier:ranges; 7, type; 7, 8; 8, generic_type; 8, 9; 8, 10; 9, identifier:Iterable; 10, type_parameter; 10, 11; 11, type; 11, 12; 12, generic_type; 12, 13; 12, 14; 13, identifier:Tuple; 14, type_parameter; 14, 15; 14, 17; 15, type; 15, 16; 16, identifier:int; 17, type; 17, 18; 18, identifier:int; 19, type; 19, 20; 20, generic_type; 20, 21; 20, 22; 21, identifier:List; 22, type_parameter; 22, 23; 23, type; 23, 24; 24, generic_type; 24, 25; 24, 26; 25, identifier:Tuple; 26, type_parameter; 26, 27; 26, 29; 27, type; 27, 28; 28, identifier:int; 29, type; 29, 30; 30, identifier:int; 31, block; 31, 32; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:sorted; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:itertools; 39, identifier:chain; 40, argument_list; 40, 41; 41, list_splat; 41, 42; 42, identifier:ranges | def sorted_chain(*ranges: Iterable[Tuple[int, int]]) -> List[Tuple[int, int]]:
return sorted(itertools.chain(*ranges)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:partition_range; 3, parameters; 3, 4; 3, 5; 4, identifier:stop; 5, default_parameter; 5, 6; 5, 7; 6, identifier:annotations; 7, None; 8, block; 8, 9; 8, 15; 8, 19; 8, 27; 8, 127; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:annotations; 12, boolean_operator:or; 12, 13; 12, 14; 13, identifier:annotations; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:partitioning; 18, list:[]; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 24; 21, pattern_list; 21, 22; 21, 23; 22, identifier:part_start; 23, identifier:part_levels; 24, expression_list; 24, 25; 24, 26; 25, integer:0; 26, None; 27, for_statement; 27, 28; 27, 29; 27, 51; 28, identifier:p; 29, call; 29, 30; 29, 31; 30, identifier:sorted; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:set; 34, argument_list; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:itertools; 38, identifier:chain; 39, argument_list; 39, 40; 39, 43; 40, list:[0, stop]; 40, 41; 40, 42; 41, integer:0; 42, identifier:stop; 43, list_splat; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:itertools; 47, identifier:chain; 48, argument_list; 48, 49; 49, list_splat; 49, 50; 50, identifier:annotations; 51, block; 51, 52; 51, 68; 51, 94; 51, 104; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:==; 53, 54; 53, 55; 54, identifier:p; 55, identifier:stop; 56, block; 56, 57; 56, 67; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:partitioning; 61, identifier:append; 62, argument_list; 62, 63; 63, tuple; 63, 64; 63, 65; 63, 66; 64, identifier:part_start; 65, identifier:p; 66, identifier:part_levels; 67, break_statement; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:levels; 71, set_comprehension; 71, 72; 71, 73; 71, 81; 72, identifier:level; 73, for_in_clause; 73, 74; 73, 77; 74, pattern_list; 74, 75; 74, 76; 75, identifier:level; 76, identifier:regions; 77, call; 77, 78; 77, 79; 78, identifier:enumerate; 79, argument_list; 79, 80; 80, identifier:annotations; 81, if_clause; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:any; 84, generator_expression; 84, 85; 84, 89; 85, comparison_operator:<=; 85, 86; 85, 87; 85, 88; 86, identifier:x; 87, identifier:p; 88, identifier:y; 89, for_in_clause; 89, 90; 89, 93; 90, pattern_list; 90, 91; 90, 92; 91, identifier:x; 92, identifier:y; 93, identifier:regions; 94, if_statement; 94, 95; 94, 98; 95, comparison_operator:==; 95, 96; 95, 97; 96, identifier:p; 97, integer:0; 98, block; 98, 99; 98, 103; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:part_levels; 102, identifier:levels; 103, continue_statement; 104, if_statement; 104, 105; 104, 108; 105, comparison_operator:!=; 105, 106; 105, 107; 106, identifier:levels; 107, identifier:part_levels; 108, block; 108, 109; 108, 119; 109, expression_statement; 109, 110; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:partitioning; 113, identifier:append; 114, argument_list; 114, 115; 115, tuple; 115, 116; 115, 117; 115, 118; 116, identifier:part_start; 117, identifier:p; 118, identifier:part_levels; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 124; 121, pattern_list; 121, 122; 121, 123; 122, identifier:part_start; 123, identifier:part_levels; 124, expression_list; 124, 125; 124, 126; 125, identifier:p; 126, identifier:levels; 127, return_statement; 127, 128; 128, identifier:partitioning | def partition_range(stop, annotations=None):
annotations = annotations or []
partitioning = []
part_start, part_levels = 0, None
for p in sorted(set(itertools.chain([0, stop],
*itertools.chain(*annotations)))):
if p == stop:
partitioning.append( (part_start, p, part_levels) )
break
levels = {level for level, regions in enumerate(annotations)
if any(x <= p < y for x, y in regions)}
if p == 0:
part_levels = levels
continue
if levels != part_levels:
partitioning.append( (part_start, p, part_levels) )
part_start, part_levels = p, levels
return partitioning |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:pprint_sequence; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:sequence; 5, default_parameter; 5, 6; 5, 7; 6, identifier:annotations; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:block_length; 10, integer:10; 11, default_parameter; 11, 12; 11, 13; 12, identifier:blocks_per_line; 13, integer:6; 14, default_parameter; 14, 15; 14, 16; 15, identifier:format; 16, identifier:PlaintextFormat; 17, block; 17, 18; 17, 24; 17, 35; 17, 71; 17, 95; 17, 271; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:annotations; 21, boolean_operator:or; 21, 22; 21, 23; 22, identifier:annotations; 23, list:[]; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:partitioning; 27, call; 27, 28; 27, 29; 28, identifier:partition_range; 29, argument_list; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, identifier:sequence; 34, identifier:annotations; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:margin; 38, binary_operator:+; 38, 39; 38, 63; 39, call; 39, 40; 39, 41; 40, identifier:int; 41, argument_list; 41, 42; 42, binary_operator:+; 42, 43; 42, 62; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:math; 46, identifier:floor; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:math; 51, identifier:log; 52, argument_list; 52, 53; 52, 61; 53, call; 53, 54; 53, 55; 54, identifier:max; 55, argument_list; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:len; 58, argument_list; 58, 59; 59, identifier:sequence; 60, integer:1; 61, integer:10; 62, integer:1; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:format; 69, identifier:margin; 70, integer:0; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:result; 74, binary_operator:+; 74, 75; 74, 94; 75, binary_operator:+; 75, 76; 75, 89; 76, call; 76, 77; 76, 87; 77, attribute; 77, 78; 77, 86; 78, parenthesized_expression; 78, 79; 79, binary_operator:+; 79, 80; 79, 85; 80, subscript; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:format; 83, identifier:margin; 84, integer:0; 85, string:'1'; 86, identifier:rjust; 87, argument_list; 87, 88; 88, identifier:margin; 89, subscript; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:format; 92, identifier:margin; 93, integer:1; 94, string:' '; 95, for_statement; 95, 96; 95, 97; 95, 106; 96, identifier:p; 97, call; 97, 98; 97, 99; 98, identifier:range; 99, argument_list; 99, 100; 99, 101; 99, 105; 100, integer:0; 101, call; 101, 102; 101, 103; 102, identifier:len; 103, argument_list; 103, 104; 104, identifier:sequence; 105, identifier:block_length; 106, block; 106, 107; 106, 141; 106, 145; 106, 215; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:block; 110, list_comprehension; 110, 111; 110, 125; 110, 131; 111, tuple; 111, 112; 111, 117; 111, 124; 112, call; 112, 113; 112, 114; 113, identifier:max; 114, argument_list; 114, 115; 114, 116; 115, identifier:start; 116, identifier:p; 117, call; 117, 118; 117, 119; 118, identifier:min; 119, argument_list; 119, 120; 119, 121; 120, identifier:stop; 121, binary_operator:+; 121, 122; 121, 123; 122, identifier:p; 123, identifier:block_length; 124, identifier:levels; 125, for_in_clause; 125, 126; 125, 130; 126, pattern_list; 126, 127; 126, 128; 126, 129; 127, identifier:start; 128, identifier:stop; 129, identifier:levels; 130, identifier:partitioning; 131, if_clause; 131, 132; 132, boolean_operator:and; 132, 133; 132, 138; 133, comparison_operator:<; 133, 134; 133, 135; 134, identifier:start; 135, binary_operator:+; 135, 136; 135, 137; 136, identifier:p; 137, identifier:block_length; 138, comparison_operator:>; 138, 139; 138, 140; 139, identifier:stop; 140, identifier:p; 141, expression_statement; 141, 142; 142, augmented_assignment:+=; 142, 143; 142, 144; 143, identifier:result; 144, string:' '; 145, for_statement; 145, 146; 145, 150; 145, 151; 146, pattern_list; 146, 147; 146, 148; 146, 149; 147, identifier:start; 148, identifier:stop; 149, identifier:levels; 150, identifier:block; 151, block; 151, 152; 151, 175; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:delimiters; 155, list_comprehension; 155, 156; 155, 159; 155, 171; 156, tuple; 156, 157; 156, 158; 157, identifier:left; 158, identifier:right; 159, for_in_clause; 159, 160; 159, 165; 160, pattern_list; 160, 161; 160, 162; 161, identifier:level; 162, tuple_pattern; 162, 163; 162, 164; 163, identifier:left; 164, identifier:right; 165, call; 165, 166; 165, 167; 166, identifier:enumerate; 167, argument_list; 167, 168; 168, attribute; 168, 169; 168, 170; 169, identifier:format; 170, identifier:annotations; 171, if_clause; 171, 172; 172, comparison_operator:in; 172, 173; 172, 174; 173, identifier:level; 174, identifier:levels; 175, expression_statement; 175, 176; 176, augmented_assignment:+=; 176, 177; 176, 178; 177, identifier:result; 178, parenthesized_expression; 178, 179; 179, binary_operator:+; 179, 180; 179, 204; 180, binary_operator:+; 180, 181; 180, 195; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, string:''; 184, identifier:join; 185, generator_expression; 185, 186; 185, 187; 186, identifier:left; 187, for_in_clause; 187, 188; 187, 191; 188, pattern_list; 188, 189; 188, 190; 189, identifier:left; 190, identifier:right; 191, call; 191, 192; 191, 193; 192, identifier:reversed; 193, argument_list; 193, 194; 194, identifier:delimiters; 195, call; 195, 196; 195, 197; 196, identifier:str; 197, argument_list; 197, 198; 198, subscript; 198, 199; 198, 200; 199, identifier:sequence; 200, slice; 200, 201; 200, 202; 200, 203; 201, identifier:start; 202, colon; 203, identifier:stop; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, string:''; 207, identifier:join; 208, generator_expression; 208, 209; 208, 210; 209, identifier:right; 210, for_in_clause; 210, 211; 210, 214; 211, pattern_list; 211, 212; 211, 213; 212, identifier:left; 213, identifier:right; 214, identifier:delimiters; 215, if_statement; 215, 216; 215, 236; 216, parenthesized_expression; 216, 217; 217, boolean_operator:and; 217, 218; 217, 228; 218, not_operator; 218, 219; 219, binary_operator:%; 219, 220; 219, 224; 220, parenthesized_expression; 220, 221; 221, binary_operator:+; 221, 222; 221, 223; 222, identifier:p; 223, identifier:block_length; 224, parenthesized_expression; 224, 225; 225, binary_operator:*; 225, 226; 225, 227; 226, identifier:block_length; 227, identifier:blocks_per_line; 228, comparison_operator:<; 228, 229; 228, 232; 229, binary_operator:+; 229, 230; 229, 231; 230, identifier:p; 231, identifier:block_length; 232, call; 232, 233; 232, 234; 233, identifier:len; 234, argument_list; 234, 235; 235, identifier:sequence; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, augmented_assignment:+=; 238, 239; 238, 240; 239, identifier:result; 240, parenthesized_expression; 240, 241; 241, binary_operator:+; 241, 242; 241, 270; 242, binary_operator:+; 242, 243; 242, 265; 243, binary_operator:+; 243, 244; 243, 245; 244, string:'\n'; 245, call; 245, 246; 245, 263; 246, attribute; 246, 247; 246, 262; 247, parenthesized_expression; 247, 248; 248, binary_operator:+; 248, 249; 248, 254; 249, subscript; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:format; 252, identifier:margin; 253, integer:0; 254, call; 254, 255; 254, 256; 255, identifier:str; 256, argument_list; 256, 257; 257, binary_operator:+; 257, 258; 257, 261; 258, binary_operator:+; 258, 259; 258, 260; 259, identifier:p; 260, identifier:block_length; 261, integer:1; 262, identifier:rjust; 263, argument_list; 263, 264; 264, identifier:margin; 265, subscript; 265, 266; 265, 269; 266, attribute; 266, 267; 266, 268; 267, identifier:format; 268, identifier:margin; 269, integer:1; 270, string:' '; 271, return_statement; 271, 272; 272, identifier:result | def pprint_sequence(sequence, annotations=None, block_length=10,
blocks_per_line=6, format=PlaintextFormat):
annotations = annotations or []
partitioning = partition_range(len(sequence), annotations)
margin = int(math.floor(math.log(max(len(sequence), 1), 10))
+ 1) + len(format.margin[0])
result = (format.margin[0] + '1').rjust(margin) + format.margin[1] + ' '
for p in range(0, len(sequence), block_length):
block = [(max(start, p), min(stop, p + block_length), levels)
for start, stop, levels in partitioning
if start < p + block_length and stop > p]
result += ' '
for start, stop, levels in block:
delimiters = [(left, right) for level, (left, right)
in enumerate(format.annotations) if level in levels]
result += (''.join(left for left, right in reversed(delimiters)) +
str(sequence[start:stop]) +
''.join(right for left, right in delimiters))
if (not (p + block_length) % (block_length * blocks_per_line) and
p + block_length < len(sequence)):
result += ('\n' + (format.margin[0] +
str(p + block_length + 1)).rjust(margin) +
format.margin[1] + ' ')
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 32; 2, function_name:tabulate; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:obj; 5, default_parameter; 5, 6; 5, 7; 6, identifier:v_level_indexes; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:h_level_indexes; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:v_level_visibility; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:h_level_visibility; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:v_level_sort_keys; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:h_level_sort_keys; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:v_level_titles; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:h_level_titles; 28, None; 29, default_parameter; 29, 30; 29, 31; 30, identifier:empty; 31, string:""; 32, block; 32, 33; 32, 40; 32, 54; 32, 69; 32, 84; 32, 99; 32, 109; 32, 119; 32, 127; 32, 135; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:level_keys; 36, call; 36, 37; 36, 38; 37, identifier:breadth_first; 38, argument_list; 38, 39; 39, identifier:obj; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, pattern_list; 42, 43; 42, 44; 43, identifier:v_level_indexes; 44, identifier:h_level_indexes; 45, call; 45, 46; 45, 47; 46, identifier:validate_level_indexes; 47, argument_list; 47, 48; 47, 52; 47, 53; 48, call; 48, 49; 48, 50; 49, identifier:len; 50, argument_list; 50, 51; 51, identifier:level_keys; 52, identifier:v_level_indexes; 53, identifier:h_level_indexes; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:is; 55, 56; 55, 57; 56, identifier:v_level_visibility; 57, None; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:v_level_visibility; 62, binary_operator:*; 62, 63; 62, 65; 63, list:[True]; 63, 64; 64, True; 65, call; 65, 66; 65, 67; 66, identifier:len; 67, argument_list; 67, 68; 68, identifier:v_level_indexes; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:h_level_visibility; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:h_level_visibility; 77, binary_operator:*; 77, 78; 77, 80; 78, list:[True]; 78, 79; 79, True; 80, call; 80, 81; 80, 82; 81, identifier:len; 82, argument_list; 82, 83; 83, identifier:h_level_indexes; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 90; 86, pattern_list; 86, 87; 86, 88; 86, 89; 87, identifier:table; 88, identifier:v_key_tuples; 89, identifier:h_key_tuples; 90, call; 90, 91; 90, 92; 91, identifier:tabulate_body; 92, argument_list; 92, 93; 92, 94; 92, 95; 92, 96; 92, 97; 92, 98; 93, identifier:obj; 94, identifier:level_keys; 95, identifier:v_level_indexes; 96, identifier:h_level_indexes; 97, identifier:v_level_sort_keys; 98, identifier:h_level_sort_keys; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 104; 101, pattern_list; 101, 102; 101, 103; 102, identifier:table; 103, identifier:v_key_tuples; 104, call; 104, 105; 104, 106; 105, identifier:strip_missing_rows; 106, argument_list; 106, 107; 106, 108; 107, identifier:table; 108, identifier:v_key_tuples; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 114; 111, pattern_list; 111, 112; 111, 113; 112, identifier:table; 113, identifier:h_key_tuples; 114, call; 114, 115; 114, 116; 115, identifier:strip_missing_columns; 116, argument_list; 116, 117; 116, 118; 117, identifier:table; 118, identifier:h_key_tuples; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:v_key_tuples; 122, call; 122, 123; 122, 124; 123, identifier:strip_hidden; 124, argument_list; 124, 125; 124, 126; 125, identifier:v_key_tuples; 126, identifier:v_level_visibility; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:h_key_tuples; 130, call; 130, 131; 130, 132; 131, identifier:strip_hidden; 132, argument_list; 132, 133; 132, 134; 133, identifier:h_key_tuples; 134, identifier:h_level_visibility; 135, return_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:assemble_table; 138, argument_list; 138, 139; 138, 140; 138, 141; 138, 142; 138, 143; 138, 144; 139, identifier:table; 140, identifier:v_key_tuples; 141, identifier:h_key_tuples; 142, identifier:v_level_titles; 143, identifier:h_level_titles; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:empty; 146, identifier:empty | def tabulate(
obj,
v_level_indexes=None,
h_level_indexes=None,
v_level_visibility=None,
h_level_visibility=None,
v_level_sort_keys=None,
h_level_sort_keys=None,
v_level_titles=None,
h_level_titles=None,
empty="",
):
level_keys = breadth_first(obj)
v_level_indexes, h_level_indexes = validate_level_indexes(
len(level_keys), v_level_indexes, h_level_indexes
)
if v_level_visibility is None:
v_level_visibility = [True] * len(v_level_indexes)
if h_level_visibility is None:
h_level_visibility = [True] * len(h_level_indexes)
table, v_key_tuples, h_key_tuples = tabulate_body(
obj, level_keys, v_level_indexes, h_level_indexes, v_level_sort_keys, h_level_sort_keys
)
table, v_key_tuples = strip_missing_rows(table, v_key_tuples)
table, h_key_tuples = strip_missing_columns(table, h_key_tuples)
v_key_tuples = strip_hidden(v_key_tuples, v_level_visibility)
h_key_tuples = strip_hidden(h_key_tuples, h_level_visibility)
return assemble_table(
table, v_key_tuples, h_key_tuples, v_level_titles, h_level_titles, empty=empty
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_ordered_entries; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:queryset; 7, False; 8, block; 8, 9; 8, 32; 8, 155; 9, if_statement; 9, 10; 9, 11; 9, 18; 10, identifier:queryset; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:queryset; 17, identifier:queryset; 18, else_clause; 18, 19; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:queryset; 25, call; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:EntryCategory; 29, identifier:objects; 30, identifier:all; 31, argument_list; 32, if_statement; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:queryset; 36, block; 36, 37; 36, 133; 37, for_statement; 37, 38; 37, 39; 37, 42; 38, identifier:category; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:queryset; 42, block; 42, 43; 42, 51; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:entries; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:category; 49, identifier:get_entries; 50, argument_list; 51, if_statement; 51, 52; 51, 53; 51, 114; 52, identifier:entries; 53, block; 53, 54; 53, 64; 53, 76; 53, 88; 53, 100; 53, 108; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:amount_list; 57, list_comprehension; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:e; 60, identifier:amount_of_views; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:e; 63, identifier:entries; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:rating_list; 67, list_comprehension; 67, 68; 67, 73; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:e; 71, identifier:rating; 72, argument_list; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:e; 75, identifier:entries; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:views_per_entry; 79, binary_operator:/; 79, 80; 79, 84; 80, call; 80, 81; 80, 82; 81, identifier:fsum; 82, argument_list; 82, 83; 83, identifier:amount_list; 84, call; 84, 85; 84, 86; 85, identifier:len; 86, argument_list; 86, 87; 87, identifier:amount_list; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:rating_per_entry; 91, binary_operator:/; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:fsum; 94, argument_list; 94, 95; 95, identifier:rating_list; 96, call; 96, 97; 96, 98; 97, identifier:len; 98, argument_list; 98, 99; 99, identifier:rating_list; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:category; 104, identifier:last_rank; 105, binary_operator:*; 105, 106; 105, 107; 106, identifier:views_per_entry; 107, identifier:rating_per_entry; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:category; 112, identifier:save; 113, argument_list; 114, else_clause; 114, 115; 115, block; 115, 116; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:queryset; 121, call; 121, 122; 121, 127; 122, attribute; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:queryset; 126, identifier:exclude; 127, argument_list; 127, 128; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:pk; 130, attribute; 130, 131; 130, 132; 131, identifier:category; 132, identifier:pk; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:self; 137, identifier:queryset; 138, call; 138, 139; 138, 140; 139, identifier:sorted; 140, argument_list; 140, 141; 140, 144; 140, 152; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:queryset; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:key; 146, lambda; 146, 147; 146, 149; 147, lambda_parameters; 147, 148; 148, identifier:c; 149, attribute; 149, 150; 149, 151; 150, identifier:c; 151, identifier:last_rank; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:reverse; 154, True; 155, return_statement; 155, 156; 156, attribute; 156, 157; 156, 158; 157, identifier:self; 158, identifier:queryset | def get_ordered_entries(self, queryset=False):
if queryset:
self.queryset = queryset
else:
self.queryset = EntryCategory.objects.all()
if self.queryset:
for category in self.queryset:
entries = category.get_entries()
if entries:
amount_list = [e.amount_of_views for e in entries]
rating_list = [e.rating() for e in entries]
views_per_entry = fsum(amount_list) / len(amount_list)
rating_per_entry = fsum(rating_list) / len(rating_list)
category.last_rank = views_per_entry * rating_per_entry
category.save()
else:
self.queryset = self.queryset.exclude(pk=category.pk)
self.queryset = sorted(self.queryset, key=lambda c: c.last_rank,
reverse=True)
return self.queryset |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:parallel_progbar; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 4, identifier:mapper; 5, identifier:iterable; 6, default_parameter; 6, 7; 6, 8; 7, identifier:nprocs; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:starmap; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:flatmap; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:shuffle; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:verbose; 20, True; 21, default_parameter; 21, 22; 21, 23; 22, identifier:verbose_flatmap; 23, None; 24, dictionary_splat_pattern; 24, 25; 25, identifier:kwargs; 26, block; 26, 27; 26, 43; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:results; 30, call; 30, 31; 30, 32; 31, identifier:_parallel_progbar_launch; 32, argument_list; 32, 33; 32, 34; 32, 35; 32, 36; 32, 37; 32, 38; 32, 39; 32, 40; 32, 41; 33, identifier:mapper; 34, identifier:iterable; 35, identifier:nprocs; 36, identifier:starmap; 37, identifier:flatmap; 38, identifier:shuffle; 39, identifier:verbose; 40, identifier:verbose_flatmap; 41, dictionary_splat; 41, 42; 42, identifier:kwargs; 43, return_statement; 43, 44; 44, list_comprehension; 44, 45; 44, 46; 45, identifier:x; 46, for_in_clause; 46, 47; 46, 50; 47, pattern_list; 47, 48; 47, 49; 48, identifier:i; 49, identifier:x; 50, call; 50, 51; 50, 52; 51, identifier:sorted; 52, argument_list; 52, 53; 52, 54; 53, identifier:results; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:key; 56, lambda; 56, 57; 56, 59; 57, lambda_parameters; 57, 58; 58, identifier:p; 59, subscript; 59, 60; 59, 61; 60, identifier:p; 61, integer:0 | def parallel_progbar(mapper, iterable, nprocs=None, starmap=False, flatmap=False, shuffle=False,
verbose=True, verbose_flatmap=None, **kwargs):
results = _parallel_progbar_launch(mapper, iterable, nprocs, starmap, flatmap, shuffle, verbose, verbose_flatmap, **kwargs)
return [x for i, x in sorted(results, key=lambda p: p[0])] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 30; 2, function_name:iparallel_progbar; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 28; 4, identifier:mapper; 5, identifier:iterable; 6, default_parameter; 6, 7; 6, 8; 7, identifier:nprocs; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:starmap; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:flatmap; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:shuffle; 17, False; 18, default_parameter; 18, 19; 18, 20; 19, identifier:verbose; 20, True; 21, default_parameter; 21, 22; 21, 23; 22, identifier:verbose_flatmap; 23, None; 24, default_parameter; 24, 25; 24, 26; 25, identifier:max_cache; 26, unary_operator:-; 26, 27; 27, integer:1; 28, dictionary_splat_pattern; 28, 29; 29, identifier:kwargs; 30, block; 30, 31; 30, 48; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:results; 34, call; 34, 35; 34, 36; 35, identifier:_parallel_progbar_launch; 36, argument_list; 36, 37; 36, 38; 36, 39; 36, 40; 36, 41; 36, 42; 36, 43; 36, 44; 36, 45; 36, 46; 37, identifier:mapper; 38, identifier:iterable; 39, identifier:nprocs; 40, identifier:starmap; 41, identifier:flatmap; 42, identifier:shuffle; 43, identifier:verbose; 44, identifier:verbose_flatmap; 45, identifier:max_cache; 46, dictionary_splat; 46, 47; 47, identifier:kwargs; 48, return_statement; 48, 49; 49, generator_expression; 49, 50; 49, 51; 50, identifier:x; 51, for_in_clause; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:i; 54, identifier:x; 55, identifier:results | def iparallel_progbar(mapper, iterable, nprocs=None, starmap=False, flatmap=False, shuffle=False,
verbose=True, verbose_flatmap=None, max_cache=-1, **kwargs):
results = _parallel_progbar_launch(mapper, iterable, nprocs, starmap, flatmap, shuffle, verbose,
verbose_flatmap, max_cache, **kwargs)
return (x for i, x in results) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_creation_date_tags; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:url; 5, identifier:domain; 6, default_parameter; 6, 7; 6, 8; 7, identifier:as_dicts; 8, False; 9, block; 9, 10; 9, 22; 9, 41; 9, 47; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:creation_date_tags; 13, list:[
mementoweb_api_tags(url),
get_whois_tags(domain),
]; 13, 14; 13, 18; 14, call; 14, 15; 14, 16; 15, identifier:mementoweb_api_tags; 16, argument_list; 16, 17; 17, identifier:url; 18, call; 18, 19; 18, 20; 19, identifier:get_whois_tags; 20, argument_list; 20, 21; 21, identifier:domain; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:creation_date_tags; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 27, 33; 28, call; 28, 29; 28, 30; 29, identifier:sum; 30, argument_list; 30, 31; 30, 32; 31, identifier:creation_date_tags; 32, list:[]; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:key; 35, lambda; 35, 36; 35, 38; 36, lambda_parameters; 36, 37; 37, identifier:x; 38, attribute; 38, 39; 38, 40; 39, identifier:x; 40, identifier:date; 41, if_statement; 41, 42; 41, 44; 42, not_operator; 42, 43; 43, identifier:as_dicts; 44, block; 44, 45; 45, return_statement; 45, 46; 46, identifier:creation_date_tags; 47, return_statement; 47, 48; 48, list_comprehension; 48, 49; 48, 54; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:item; 52, identifier:_as_dict; 53, argument_list; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:item; 56, identifier:creation_date_tags | def get_creation_date_tags(url, domain, as_dicts=False):
creation_date_tags = [
mementoweb_api_tags(url),
get_whois_tags(domain),
]
creation_date_tags = sorted(
sum(creation_date_tags, []),
key=lambda x: x.date
)
if not as_dicts:
return creation_date_tags
return [
item._as_dict()
for item in creation_date_tags
] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:image_from_name; 3, parameters; 3, 4; 3, 5; 4, identifier:name; 5, identifier:images; 6, block; 6, 7; 6, 24; 6, 50; 6, 79; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:prefixed_images; 10, list_comprehension; 10, 11; 10, 12; 10, 15; 11, identifier:i; 12, for_in_clause; 12, 13; 12, 14; 13, identifier:i; 14, identifier:images; 15, if_clause; 15, 16; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:i; 20, identifier:name; 21, identifier:startswith; 22, argument_list; 22, 23; 23, identifier:name; 24, if_statement; 24, 25; 24, 34; 25, comparison_operator:in; 25, 26; 25, 27; 26, identifier:name; 27, list_comprehension; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:i; 30, identifier:name; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:i; 33, identifier:prefixed_images; 34, block; 34, 35; 35, return_statement; 35, 36; 36, subscript; 36, 37; 36, 48; 37, list_comprehension; 37, 38; 37, 39; 37, 42; 38, identifier:i; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:i; 41, identifier:prefixed_images; 42, if_clause; 42, 43; 43, comparison_operator:==; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:i; 46, identifier:name; 47, identifier:name; 48, unary_operator:-; 48, 49; 49, integer:1; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:decorated; 53, call; 53, 54; 53, 55; 54, identifier:sorted; 55, argument_list; 55, 56; 56, list_comprehension; 56, 57; 56, 76; 57, tuple; 57, 58; 57, 75; 58, call; 58, 59; 58, 60; 59, identifier:int; 60, argument_list; 60, 61; 61, call; 61, 62; 61, 73; 62, attribute; 62, 63; 62, 72; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:re; 66, identifier:search; 67, argument_list; 67, 68; 67, 69; 68, string:'\d+'; 69, attribute; 69, 70; 69, 71; 70, identifier:i; 71, identifier:name; 72, identifier:group; 73, argument_list; 73, 74; 74, integer:0; 75, identifier:i; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:i; 78, identifier:prefixed_images; 79, return_statement; 79, 80; 80, subscript; 80, 81; 80, 88; 81, list_comprehension; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:i; 84, integer:1; 85, for_in_clause; 85, 86; 85, 87; 86, identifier:i; 87, identifier:decorated; 88, unary_operator:-; 88, 89; 89, integer:1 | def image_from_name(name, images):
prefixed_images = [i for i in images if i.name.startswith(name)]
if name in [i.name for i in prefixed_images]:
return [i for i in prefixed_images if i.name == name][-1]
decorated = sorted(
[(int(re.search('\d+', i.name).group(0)), i) for i in prefixed_images])
return [i[1] for i in decorated][-1] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:func_on_enter; 3, parameters; 3, 4; 4, identifier:func; 5, block; 5, 6; 5, 29; 6, function_definition; 6, 7; 6, 8; 6, 10; 7, function_name:function_after_enter_pressed; 8, parameters; 8, 9; 9, identifier:ev; 10, block; 10, 11; 10, 17; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:ev; 15, identifier:stopPropagation; 16, argument_list; 17, if_statement; 17, 18; 17, 23; 18, comparison_operator:==; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:ev; 21, identifier:keyCode; 22, integer:13; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:func; 27, argument_list; 27, 28; 28, identifier:ev; 29, return_statement; 29, 30; 30, identifier:function_after_enter_pressed | def func_on_enter(func):
def function_after_enter_pressed(ev):
ev.stopPropagation()
if ev.keyCode == 13:
func(ev)
return function_after_enter_pressed |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:prev_next_group; 3, parameters; 3, 4; 3, 5; 4, identifier:project; 5, identifier:group; 6, block; 6, 7; 6, 23; 6, 41; 6, 54; 6, 72; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:groups; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, generator_expression; 12, 13; 12, 14; 12, 19; 13, identifier:x; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:x; 16, attribute; 16, 17; 16, 18; 17, identifier:project; 18, identifier:groups; 19, if_clause; 19, 20; 20, attribute; 20, 21; 20, 22; 21, identifier:x; 22, identifier:submissions; 23, try_statement; 23, 24; 23, 34; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:index; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:groups; 31, identifier:index; 32, argument_list; 32, 33; 33, identifier:group; 34, except_clause; 34, 35; 34, 36; 35, identifier:ValueError; 36, block; 36, 37; 37, return_statement; 37, 38; 38, expression_list; 38, 39; 38, 40; 39, None; 40, None; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:prev_group; 44, conditional_expression:if; 44, 45; 44, 50; 44, 53; 45, subscript; 45, 46; 45, 47; 46, identifier:groups; 47, binary_operator:-; 47, 48; 47, 49; 48, identifier:index; 49, integer:1; 50, comparison_operator:>; 50, 51; 50, 52; 51, identifier:index; 52, integer:0; 53, None; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:next_group; 57, conditional_expression:if; 57, 58; 57, 63; 57, 71; 58, subscript; 58, 59; 58, 60; 59, identifier:groups; 60, binary_operator:+; 60, 61; 60, 62; 61, identifier:index; 62, integer:1; 63, comparison_operator:<; 63, 64; 63, 67; 64, binary_operator:+; 64, 65; 64, 66; 65, identifier:index; 66, integer:1; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, identifier:groups; 71, None; 72, return_statement; 72, 73; 73, expression_list; 73, 74; 73, 75; 74, identifier:prev_group; 75, identifier:next_group | def prev_next_group(project, group):
groups = sorted(x for x in project.groups if x.submissions)
try:
index = groups.index(group)
except ValueError:
return None, None
prev_group = groups[index - 1] if index > 0 else None
next_group = groups[index + 1] if index + 1 < len(groups) else None
return prev_group, next_group |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:do_minus; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:parser; 6, identifier:group; 7, block; 7, 8; 7, 10; 7, 18; 7, 22; 7, 110; 7, 121; 8, expression_statement; 8, 9; 9, string:'''This filter sorts nodes in a flat group into "required", "default",
and "banned" subgroups based on the presence of plus and minus nodes.
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:grouper; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:group; 16, identifier:__class__; 17, argument_list; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:next_not; 21, None; 22, for_statement; 22, 23; 22, 24; 22, 25; 23, identifier:node; 24, identifier:group; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 34; 26, 60; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 31; 30, identifier:node; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:Minus; 34, block; 34, 35; 34, 41; 34, 53; 35, if_statement; 35, 36; 35, 39; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:next_not; 38, None; 39, block; 39, 40; 40, continue_statement; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:next_not; 44, call; 44, 45; 44, 52; 45, attribute; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:whoosh; 49, identifier:qparser; 50, identifier:syntax; 51, identifier:NotGroup; 52, argument_list; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:grouper; 57, identifier:append; 58, argument_list; 58, 59; 59, identifier:next_not; 60, else_clause; 60, 61; 61, block; 61, 62; 61, 85; 62, if_statement; 62, 63; 62, 74; 63, call; 63, 64; 63, 65; 64, identifier:isinstance; 65, argument_list; 65, 66; 65, 67; 66, identifier:node; 67, attribute; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:whoosh; 71, identifier:qparser; 72, identifier:syntax; 73, identifier:GroupNode; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:node; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:do_minus; 82, argument_list; 82, 83; 82, 84; 83, identifier:parser; 84, identifier:node; 85, if_statement; 85, 86; 85, 89; 85, 101; 86, comparison_operator:is; 86, 87; 86, 88; 87, identifier:next_not; 88, None; 89, block; 89, 90; 89, 97; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:next_not; 94, identifier:append; 95, argument_list; 95, 96; 96, identifier:node; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:next_not; 100, None; 101, else_clause; 101, 102; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:grouper; 107, identifier:append; 108, argument_list; 108, 109; 109, identifier:node; 110, if_statement; 110, 111; 110, 114; 111, comparison_operator:is; 111, 112; 111, 113; 112, identifier:next_not; 113, None; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:grouper; 119, identifier:pop; 120, argument_list; 121, return_statement; 121, 122; 122, identifier:grouper | def do_minus(self, parser, group):
'''This filter sorts nodes in a flat group into "required", "default",
and "banned" subgroups based on the presence of plus and minus nodes.
'''
grouper = group.__class__()
next_not = None
for node in group:
if isinstance(node, self.Minus):
if next_not is not None:
continue
next_not = whoosh.qparser.syntax.NotGroup()
grouper.append(next_not)
else:
if isinstance(node, whoosh.qparser.syntax.GroupNode):
node = self.do_minus(parser, node)
if next_not is not None:
next_not.append(node)
next_not = None
else:
grouper.append(node)
if next_not is not None:
grouper.pop()
return grouper |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:topological_sort; 3, parameters; 3, 4; 4, identifier:dependency_pairs; 5, block; 5, 6; 5, 8; 5, 15; 5, 22; 5, 26; 5, 68; 5, 80; 5, 109; 5, 125; 6, expression_statement; 6, 7; 7, string:"Sort values subject to dependency constraints"; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:num_heads; 11, call; 11, 12; 11, 13; 12, identifier:defaultdict; 13, argument_list; 13, 14; 14, identifier:int; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:tails; 18, call; 18, 19; 18, 20; 19, identifier:defaultdict; 20, argument_list; 20, 21; 21, identifier:list; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:heads; 25, list:[]; 26, for_statement; 26, 27; 26, 30; 26, 31; 27, pattern_list; 27, 28; 27, 29; 28, identifier:h; 29, identifier:t; 30, identifier:dependency_pairs; 31, block; 31, 32; 31, 38; 32, expression_statement; 32, 33; 33, augmented_assignment:+=; 33, 34; 33, 37; 34, subscript; 34, 35; 34, 36; 35, identifier:num_heads; 36, identifier:t; 37, integer:1; 38, if_statement; 38, 39; 38, 42; 38, 52; 39, comparison_operator:in; 39, 40; 39, 41; 40, identifier:h; 41, identifier:tails; 42, block; 42, 43; 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:tails; 48, identifier:h; 49, identifier:append; 50, argument_list; 50, 51; 51, identifier:t; 52, else_clause; 52, 53; 53, block; 53, 54; 53, 61; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:tails; 58, identifier:h; 59, list:[t]; 59, 60; 60, identifier:t; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:heads; 65, identifier:append; 66, argument_list; 66, 67; 67, identifier:h; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:ordered; 71, list_comprehension; 71, 72; 71, 73; 71, 76; 72, identifier:h; 73, for_in_clause; 73, 74; 73, 75; 74, identifier:h; 75, identifier:heads; 76, if_clause; 76, 77; 77, comparison_operator:not; 77, 78; 77, 79; 78, identifier:h; 79, identifier:num_heads; 80, for_statement; 80, 81; 80, 82; 80, 83; 81, identifier:h; 82, identifier:ordered; 83, block; 83, 84; 84, for_statement; 84, 85; 84, 86; 84, 89; 85, identifier:t; 86, subscript; 86, 87; 86, 88; 87, identifier:tails; 88, identifier:h; 89, block; 89, 90; 89, 96; 90, expression_statement; 90, 91; 91, augmented_assignment:-=; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:num_heads; 94, identifier:t; 95, integer:1; 96, if_statement; 96, 97; 96, 101; 97, not_operator; 97, 98; 98, subscript; 98, 99; 98, 100; 99, identifier:num_heads; 100, identifier:t; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:ordered; 106, identifier:append; 107, argument_list; 107, 108; 108, identifier:t; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:cyclic; 112, list_comprehension; 112, 113; 112, 114; 112, 123; 113, identifier:n; 114, for_in_clause; 114, 115; 114, 118; 115, pattern_list; 115, 116; 115, 117; 116, identifier:n; 117, identifier:heads; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:num_heads; 121, identifier:items; 122, argument_list; 123, if_clause; 123, 124; 124, identifier:heads; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:Results; 128, argument_list; 128, 129; 128, 130; 129, identifier:ordered; 130, identifier:cyclic | def topological_sort(dependency_pairs):
"Sort values subject to dependency constraints"
num_heads = defaultdict(int)
tails = defaultdict(list)
heads = []
for h, t in dependency_pairs:
num_heads[t] += 1
if h in tails:
tails[h].append(t)
else:
tails[h] = [t]
heads.append(h)
ordered = [h for h in heads if h not in num_heads]
for h in ordered:
for t in tails[h]:
num_heads[t] -= 1
if not num_heads[t]:
ordered.append(t)
cyclic = [n for n, heads in num_heads.items() if heads]
return Results(ordered, cyclic) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:multisorted; 3, parameters; 3, 4; 3, 5; 4, identifier:items; 5, list_splat_pattern; 5, 6; 6, identifier:keys; 7, block; 7, 8; 7, 23; 7, 47; 8, if_statement; 8, 9; 8, 15; 9, comparison_operator:==; 9, 10; 9, 14; 10, call; 10, 11; 10, 12; 11, identifier:len; 12, argument_list; 12, 13; 13, identifier:keys; 14, integer:0; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:keys; 19, list:[asc()]; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:asc; 22, argument_list; 23, for_statement; 23, 24; 23, 25; 23, 29; 24, identifier:key; 25, call; 25, 26; 25, 27; 26, identifier:reversed; 27, argument_list; 27, 28; 28, identifier:keys; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:items; 33, call; 33, 34; 33, 35; 34, identifier:sorted; 35, argument_list; 35, 36; 35, 37; 35, 42; 36, identifier:items; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:key; 39, attribute; 39, 40; 39, 41; 40, identifier:key; 41, identifier:func; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:reverse; 44, attribute; 44, 45; 44, 46; 45, identifier:key; 46, identifier:reverse; 47, return_statement; 47, 48; 48, identifier:items | def multisorted(items, *keys):
if len(keys) == 0:
keys = [asc()]
for key in reversed(keys):
items = sorted(items, key=key.func, reverse=key.reverse)
return items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:tuplesorted; 3, parameters; 3, 4; 3, 5; 4, identifier:items; 5, list_splat_pattern; 5, 6; 6, identifier:keys; 7, block; 7, 8; 7, 47; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:tuple_keys; 11, list_comprehension; 11, 12; 11, 39; 12, call; 12, 13; 12, 14; 13, identifier:Key; 14, argument_list; 14, 15; 14, 34; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:func; 17, lambda; 17, 18; 17, 26; 18, lambda_parameters; 18, 19; 18, 20; 18, 23; 19, identifier:t; 20, default_parameter; 20, 21; 20, 22; 21, identifier:i; 22, identifier:index; 23, default_parameter; 23, 24; 23, 25; 24, identifier:k; 25, identifier:key; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:k; 29, identifier:func; 30, argument_list; 30, 31; 31, subscript; 31, 32; 31, 33; 32, identifier:t; 33, identifier:i; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:reverse; 36, attribute; 36, 37; 36, 38; 37, identifier:key; 38, identifier:reverse; 39, for_in_clause; 39, 40; 39, 43; 40, pattern_list; 40, 41; 40, 42; 41, identifier:index; 42, identifier:key; 43, call; 43, 44; 43, 45; 44, identifier:enumerate; 45, argument_list; 45, 46; 46, identifier:keys; 47, return_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:multisorted; 50, argument_list; 50, 51; 50, 52; 51, identifier:items; 52, list_splat; 52, 53; 53, identifier:tuple_keys | def tuplesorted(items, *keys):
tuple_keys = [
Key(func=lambda t, i=index, k=key: k.func(t[i]), reverse=key.reverse)
for index, key in enumerate(keys)
]
return multisorted(items, *tuple_keys) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:list_formats; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:node; 6, default_parameter; 6, 7; 6, 8; 7, identifier:path; 8, tuple; 9, default_parameter; 9, 10; 9, 11; 10, identifier:formats; 11, None; 12, block; 12, 13; 12, 22; 12, 42; 12, 56; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:formats; 16, None; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:formats; 21, list:[]; 22, for_statement; 22, 23; 22, 24; 22, 27; 23, identifier:child; 24, attribute; 24, 25; 24, 26; 25, identifier:node; 26, identifier:children; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:list_formats; 33, argument_list; 33, 34; 33, 35; 33, 41; 34, identifier:child; 35, binary_operator:+; 35, 36; 35, 37; 36, identifier:path; 37, tuple; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:child; 40, identifier:name; 41, identifier:formats; 42, expression_statement; 42, 43; 43, boolean_operator:and; 43, 44; 43, 45; 44, identifier:path; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:formats; 48, identifier:append; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, string:"."; 53, identifier:join; 54, argument_list; 54, 55; 55, identifier:path; 56, return_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:sorted; 59, argument_list; 59, 60; 60, identifier:formats | def list_formats(self, node, path=(), formats=None):
if formats == None:
formats = []
for child in node.children:
self.list_formats(child, path + (child.name,), formats)
path and formats.append(".".join(path))
return sorted(formats) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:ls; 3, parameters; 3, 4; 3, 7; 3, 10; 4, default_parameter; 4, 5; 4, 6; 5, identifier:root; 6, string:"."; 7, default_parameter; 7, 8; 7, 9; 8, identifier:abspaths; 9, False; 10, default_parameter; 10, 11; 10, 12; 11, identifier:recursive; 12, False; 13, block; 13, 14; 13, 57; 14, function_definition; 14, 15; 14, 16; 14, 18; 15, function_name:_expand_subdirs; 16, parameters; 16, 17; 17, identifier:file; 18, block; 18, 19; 19, if_statement; 19, 20; 19, 28; 19, 52; 20, call; 20, 21; 20, 22; 21, identifier:isdir; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:path; 25, argument_list; 25, 26; 25, 27; 26, identifier:root; 27, identifier:file; 28, block; 28, 29; 29, return_statement; 29, 30; 30, binary_operator:+; 30, 31; 30, 33; 31, list:[file]; 31, 32; 32, identifier:file; 33, list_comprehension; 33, 34; 33, 39; 34, call; 34, 35; 34, 36; 35, identifier:path; 36, argument_list; 36, 37; 36, 38; 37, identifier:file; 38, identifier:x; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:x; 41, call; 41, 42; 41, 43; 42, identifier:ls; 43, argument_list; 43, 44; 43, 49; 44, call; 44, 45; 44, 46; 45, identifier:path; 46, argument_list; 46, 47; 46, 48; 47, identifier:root; 48, identifier:file; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:recursive; 51, True; 52, else_clause; 52, 53; 53, block; 53, 54; 54, return_statement; 54, 55; 55, list:[file]; 55, 56; 56, identifier:file; 57, if_statement; 57, 58; 57, 62; 57, 76; 57, 109; 57, 139; 58, call; 58, 59; 58, 60; 59, identifier:isfile; 60, argument_list; 60, 61; 61, identifier:root; 62, block; 62, 63; 63, return_statement; 63, 64; 64, conditional_expression:if; 64, 65; 64, 70; 64, 71; 65, list:[abspath(root)]; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:abspath; 68, argument_list; 68, 69; 69, identifier:root; 70, identifier:abspaths; 71, list:[basename(root)]; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:basename; 74, argument_list; 74, 75; 75, identifier:root; 76, elif_clause; 76, 77; 76, 78; 77, identifier:abspaths; 78, block; 78, 79; 78, 92; 78, 99; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:relpaths; 82, call; 82, 83; 82, 84; 83, identifier:ls; 84, argument_list; 84, 85; 84, 86; 84, 89; 85, identifier:root; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:recursive; 88, identifier:recursive; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:abspaths; 91, False; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:base; 95, call; 95, 96; 95, 97; 96, identifier:abspath; 97, argument_list; 97, 98; 98, identifier:root; 99, return_statement; 99, 100; 100, list_comprehension; 100, 101; 100, 106; 101, call; 101, 102; 101, 103; 102, identifier:path; 103, argument_list; 103, 104; 103, 105; 104, identifier:base; 105, identifier:relpath; 106, for_in_clause; 106, 107; 106, 108; 107, identifier:relpath; 108, identifier:relpaths; 109, elif_clause; 109, 110; 109, 111; 110, identifier:recursive; 111, block; 111, 112; 111, 125; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:paths; 115, call; 115, 116; 115, 117; 116, identifier:ls; 117, argument_list; 117, 118; 117, 119; 117, 122; 118, identifier:root; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:abspaths; 121, identifier:abspaths; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:recursive; 124, False; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:labtypes; 129, identifier:flatten; 130, argument_list; 130, 131; 131, list_comprehension; 131, 132; 131, 136; 132, call; 132, 133; 132, 134; 133, identifier:_expand_subdirs; 134, argument_list; 134, 135; 135, identifier:file; 136, for_in_clause; 136, 137; 136, 138; 137, identifier:file; 138, identifier:paths; 139, else_clause; 139, 140; 140, block; 140, 141; 141, return_statement; 141, 142; 142, call; 142, 143; 142, 144; 143, identifier:list; 144, argument_list; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:sorted; 147, argument_list; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:os; 151, identifier:listdir; 152, argument_list; 152, 153; 153, identifier:root | def ls(root=".", abspaths=False, recursive=False):
def _expand_subdirs(file):
if isdir(path(root, file)):
return [file] + [path(file, x) for x in
ls(path(root, file), recursive=True)]
else:
return [file]
if isfile(root):
return [abspath(root)] if abspaths else [basename(root)]
elif abspaths:
relpaths = ls(root, recursive=recursive, abspaths=False)
base = abspath(root)
return [path(base, relpath) for relpath in relpaths]
elif recursive:
paths = ls(root, abspaths=abspaths, recursive=False)
return labtypes.flatten([_expand_subdirs(file) for file in paths])
else:
return list(sorted(os.listdir(root))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:list; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:offset; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:limit; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:fields; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:sort; 16, None; 17, dictionary_splat_pattern; 17, 18; 18, identifier:kwargs; 19, block; 19, 20; 20, try_statement; 20, 21; 20, 55; 21, block; 21, 22; 21, 44; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:cursor; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_cursor; 29, argument_list; 29, 30; 29, 33; 29, 36; 29, 39; 29, 42; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:offset; 32, identifier:offset; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:limit; 35, identifier:limit; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:fields; 38, identifier:fields; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:sort; 41, identifier:sort; 42, dictionary_splat; 42, 43; 43, identifier:kwargs; 44, return_statement; 44, 45; 45, expression_list; 45, 46; 45, 50; 46, call; 46, 47; 46, 48; 47, identifier:list; 48, argument_list; 48, 49; 49, identifier:cursor; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:cursor; 53, identifier:count; 54, argument_list; 55, except_clause; 55, 56; 55, 64; 56, as_pattern; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:pymongo; 60, identifier:errors; 61, identifier:OperationFailure; 62, as_pattern_target; 62, 63; 63, identifier:exc; 64, block; 64, 65; 64, 84; 64, 91; 64, 102; 64, 110; 64, 132; 65, try_statement; 65, 66; 65, 77; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, subscript; 68, 69; 68, 76; 69, subscript; 69, 70; 69, 75; 70, subscript; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:kwargs; 73, string:'$or'; 74, integer:0; 75, string:'$text'; 76, string:'$search'; 77, except_clause; 77, 78; 77, 81; 78, tuple; 78, 79; 78, 80; 79, identifier:KeyError; 80, identifier:IndexError; 81, block; 81, 82; 82, raise_statement; 82, 83; 83, identifier:exc; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:LOG; 88, identifier:warn; 89, argument_list; 89, 90; 90, string:"Falling back to hard-coded mongo v2.4 search behavior"; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:kwargs; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:search_alternative; 98, argument_list; 98, 99; 98, 100; 99, identifier:limit; 100, dictionary_splat; 100, 101; 101, identifier:kwargs; 102, expression_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:LOG; 106, identifier:debug; 107, argument_list; 107, 108; 107, 109; 108, string:"Modified kwargs: %s"; 109, identifier:kwargs; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:cursor; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:_cursor; 117, argument_list; 117, 118; 117, 121; 117, 124; 117, 127; 117, 130; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:offset; 120, identifier:offset; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:limit; 123, identifier:limit; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:fields; 126, identifier:fields; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:sort; 129, identifier:sort; 130, dictionary_splat; 130, 131; 131, identifier:kwargs; 132, return_statement; 132, 133; 133, expression_list; 133, 134; 133, 138; 134, call; 134, 135; 134, 136; 135, identifier:list; 136, argument_list; 136, 137; 137, identifier:cursor; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:cursor; 141, identifier:count; 142, argument_list | def list(self, offset=0, limit=0, fields=None, sort=None, **kwargs):
try:
cursor = self._cursor(offset=offset, limit=limit, fields=fields,
sort=sort, **kwargs)
return list(cursor), cursor.count()
except pymongo.errors.OperationFailure as exc:
try:
kwargs['$or'][0]['$text']['$search']
except (KeyError, IndexError):
raise exc
LOG.warn("Falling back to hard-coded mongo v2.4 search behavior")
kwargs = self.search_alternative(limit, **kwargs)
LOG.debug("Modified kwargs: %s", kwargs)
cursor = self._cursor(offset=offset, limit=limit, fields=fields,
sort=sort, **kwargs)
return list(cursor), cursor.count() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:_cursor; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:offset; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:limit; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:fields; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:sort; 16, None; 17, dictionary_splat_pattern; 17, 18; 18, identifier:kwargs; 19, block; 19, 20; 19, 27; 19, 43; 19, 55; 19, 114; 19, 130; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:projection; 23, dictionary; 23, 24; 24, pair; 24, 25; 24, 26; 25, string:'_id'; 26, False; 27, if_statement; 27, 28; 27, 29; 28, identifier:fields; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:projection; 34, identifier:update; 35, argument_list; 35, 36; 36, dictionary_comprehension; 36, 37; 36, 40; 37, pair; 37, 38; 37, 39; 38, identifier:field; 39, True; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:field; 42, identifier:fields; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:results; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_collection; 51, identifier:find; 52, argument_list; 52, 53; 52, 54; 53, identifier:kwargs; 54, identifier:projection; 55, if_statement; 55, 56; 55, 57; 56, identifier:sort; 57, block; 57, 58; 57, 65; 57, 107; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:sort_pairs; 61, subscript; 61, 62; 61, 63; 62, identifier:sort; 63, slice; 63, 64; 64, colon; 65, for_statement; 65, 66; 65, 69; 65, 73; 66, pattern_list; 66, 67; 66, 68; 67, identifier:index; 68, identifier:field; 69, call; 69, 70; 69, 71; 70, identifier:enumerate; 71, argument_list; 71, 72; 72, identifier:sort; 73, block; 73, 74; 74, if_statement; 74, 75; 74, 80; 74, 95; 75, comparison_operator:==; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:field; 78, integer:0; 79, string:"-"; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 86; 83, subscript; 83, 84; 83, 85; 84, identifier:sort_pairs; 85, identifier:index; 86, tuple; 86, 87; 86, 92; 87, subscript; 87, 88; 87, 89; 88, identifier:field; 89, slice; 89, 90; 89, 91; 90, integer:1; 91, colon; 92, attribute; 92, 93; 92, 94; 93, identifier:pymongo; 94, identifier:DESCENDING; 95, else_clause; 95, 96; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:sort_pairs; 101, identifier:index; 102, tuple; 102, 103; 102, 104; 103, identifier:field; 104, attribute; 104, 105; 104, 106; 105, identifier:pymongo; 106, identifier:ASCENDING; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:results; 111, identifier:sort; 112, argument_list; 112, 113; 113, identifier:sort_pairs; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 126; 116, attribute; 116, 117; 116, 125; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:results; 120, identifier:skip; 121, argument_list; 121, 122; 122, boolean_operator:or; 122, 123; 122, 124; 123, identifier:offset; 124, integer:0; 125, identifier:limit; 126, argument_list; 126, 127; 127, boolean_operator:or; 127, 128; 127, 129; 128, identifier:limit; 129, integer:0; 130, return_statement; 130, 131; 131, identifier:results | def _cursor(self, offset=0, limit=0, fields=None, sort=None, **kwargs):
projection = {'_id': False}
if fields:
projection.update({field: True for field in fields})
results = self._collection.find(kwargs, projection)
if sort:
sort_pairs = sort[:]
for index, field in enumerate(sort):
if field[0] == "-":
sort_pairs[index] = (field[1:], pymongo.DESCENDING)
else:
sort_pairs[index] = (field, pymongo.ASCENDING)
results.sort(sort_pairs)
results.skip(offset or 0).limit(limit or 0)
return results |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:insert; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:item; 6, identifier:low_value; 7, block; 7, 8; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:c_void_p; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:lib; 15, identifier:zlistx_insert; 16, argument_list; 16, 17; 16, 20; 16, 21; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_as_parameter_; 20, identifier:item; 21, identifier:low_value | def insert(self, item, low_value):
return c_void_p(lib.zlistx_insert(self._as_parameter_, item, low_value)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:reorder; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:handle; 6, identifier:low_value; 7, block; 7, 8; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:lib; 12, identifier:zlistx_reorder; 13, argument_list; 13, 14; 13, 17; 13, 18; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_as_parameter_; 17, identifier:handle; 18, identifier:low_value | def reorder(self, handle, low_value):
return lib.zlistx_reorder(self._as_parameter_, handle, low_value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:process_params; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:request; 5, default_parameter; 5, 6; 5, 7; 6, identifier:standard_params; 7, identifier:STANDARD_QUERY_PARAMS; 8, default_parameter; 8, 9; 8, 10; 9, identifier:filter_fields; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:defaults; 13, None; 14, block; 14, 15; 14, 23; 14, 47; 14, 74; 14, 80; 14, 148; 14, 195; 14, 241; 15, if_statement; 15, 16; 15, 18; 16, not_operator; 16, 17; 17, identifier:filter_fields; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:filter_fields; 22, list:[]; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:unfilterable; 26, parenthesized_expression; 26, 27; 27, binary_operator:-; 27, 28; 27, 43; 28, binary_operator:-; 28, 29; 28, 39; 29, call; 29, 30; 29, 31; 30, identifier:set; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:request; 36, identifier:query; 37, identifier:keys; 38, argument_list; 39, call; 39, 40; 39, 41; 40, identifier:set; 41, argument_list; 41, 42; 42, identifier:filter_fields; 43, call; 43, 44; 43, 45; 44, identifier:set; 45, argument_list; 45, 46; 46, identifier:standard_params; 47, if_statement; 47, 48; 47, 49; 48, identifier:unfilterable; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:bottle; 54, identifier:abort; 55, argument_list; 55, 56; 55, 57; 56, integer:400; 57, binary_operator:%; 57, 58; 57, 61; 58, concatenated_string; 58, 59; 58, 60; 59, string:"The following query params were invalid: %s. "; 60, string:"Try one (or more) of %s."; 61, tuple; 61, 62; 61, 68; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, string:", "; 65, identifier:join; 66, argument_list; 66, 67; 67, identifier:unfilterable; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, string:", "; 71, identifier:join; 72, argument_list; 72, 73; 73, identifier:filter_fields; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:query_fields; 77, boolean_operator:or; 77, 78; 77, 79; 78, identifier:defaults; 79, dictionary; 80, for_statement; 80, 81; 80, 82; 80, 85; 81, identifier:key; 82, attribute; 82, 83; 82, 84; 83, identifier:request; 84, identifier:query; 85, block; 85, 86; 86, if_statement; 86, 87; 86, 90; 87, comparison_operator:in; 87, 88; 87, 89; 88, identifier:key; 89, identifier:filter_fields; 90, block; 90, 91; 90, 102; 90, 124; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:matches; 94, call; 94, 95; 94, 100; 95, attribute; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:request; 98, identifier:query; 99, identifier:getall; 100, argument_list; 100, 101; 101, identifier:key; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:matches; 105, call; 105, 106; 105, 107; 106, identifier:list; 107, argument_list; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:itertools; 111, identifier:chain; 112, argument_list; 112, 113; 113, list_splat; 113, 114; 114, generator_expression; 114, 115; 114, 121; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:k; 118, identifier:split; 119, argument_list; 119, 120; 120, string:','; 121, for_in_clause; 121, 122; 121, 123; 122, identifier:k; 123, identifier:matches; 124, if_statement; 124, 125; 124, 131; 124, 138; 125, comparison_operator:>; 125, 126; 125, 130; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, identifier:matches; 130, integer:1; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:query_fields; 136, identifier:key; 137, identifier:matches; 138, else_clause; 138, 139; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:query_fields; 144, identifier:key; 145, subscript; 145, 146; 145, 147; 146, identifier:matches; 147, integer:0; 148, if_statement; 148, 149; 148, 154; 149, comparison_operator:in; 149, 150; 149, 151; 150, string:'sort'; 151, attribute; 151, 152; 151, 153; 152, identifier:request; 153, identifier:query; 154, block; 154, 155; 154, 166; 154, 189; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:sort; 158, call; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:request; 162, identifier:query; 163, identifier:getall; 164, argument_list; 164, 165; 165, string:'sort'; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:sort; 169, call; 169, 170; 169, 171; 170, identifier:list; 171, argument_list; 171, 172; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:itertools; 175, identifier:chain; 176, argument_list; 176, 177; 177, list_splat; 177, 178; 178, generator_expression; 178, 179; 178, 186; 179, call; 179, 180; 179, 181; 180, identifier:comma_separated_strings; 181, argument_list; 181, 182; 182, call; 182, 183; 182, 184; 183, identifier:str; 184, argument_list; 184, 185; 185, identifier:k; 186, for_in_clause; 186, 187; 186, 188; 187, identifier:k; 188, identifier:sort; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 194; 191, subscript; 191, 192; 191, 193; 192, identifier:query_fields; 193, string:'sort'; 194, identifier:sort; 195, if_statement; 195, 196; 195, 201; 196, comparison_operator:in; 196, 197; 196, 198; 197, string:'q'; 198, attribute; 198, 199; 198, 200; 199, identifier:request; 200, identifier:query; 201, block; 201, 202; 201, 213; 201, 235; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:search; 205, call; 205, 206; 205, 211; 206, attribute; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:request; 209, identifier:query; 210, identifier:getall; 211, argument_list; 211, 212; 212, string:'q'; 213, expression_statement; 213, 214; 214, assignment; 214, 215; 214, 216; 215, identifier:search; 216, call; 216, 217; 216, 218; 217, identifier:list; 218, argument_list; 218, 219; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:itertools; 222, identifier:chain; 223, argument_list; 223, 224; 224, list_splat; 224, 225; 225, generator_expression; 225, 226; 225, 230; 225, 233; 226, call; 226, 227; 226, 228; 227, identifier:comma_separated_strings; 228, argument_list; 228, 229; 229, identifier:k; 230, for_in_clause; 230, 231; 230, 232; 231, identifier:k; 232, identifier:search; 233, if_clause; 233, 234; 234, identifier:k; 235, expression_statement; 235, 236; 236, assignment; 236, 237; 236, 240; 237, subscript; 237, 238; 237, 239; 238, identifier:query_fields; 239, string:'q'; 240, identifier:search; 241, return_statement; 241, 242; 242, identifier:query_fields | def process_params(request, standard_params=STANDARD_QUERY_PARAMS,
filter_fields=None, defaults=None):
if not filter_fields:
filter_fields = []
unfilterable = (set(request.query.keys()) - set(filter_fields) -
set(standard_params))
if unfilterable:
bottle.abort(400,
"The following query params were invalid: %s. "
"Try one (or more) of %s." %
(", ".join(unfilterable),
", ".join(filter_fields)))
query_fields = defaults or {}
for key in request.query:
if key in filter_fields:
matches = request.query.getall(key)
matches = list(itertools.chain(*(k.split(',') for k in matches)))
if len(matches) > 1:
query_fields[key] = matches
else:
query_fields[key] = matches[0]
if 'sort' in request.query:
sort = request.query.getall('sort')
sort = list(itertools.chain(*(
comma_separated_strings(str(k)) for k in sort)))
query_fields['sort'] = sort
if 'q' in request.query:
search = request.query.getall('q')
search = list(itertools.chain(*(
comma_separated_strings(k) for k in search
if k)))
query_fields['q'] = search
return query_fields |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:_weave_dohist; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 12; 4, identifier:data; 5, identifier:s; 6, identifier:binsize; 7, identifier:hist; 8, identifier:rev; 9, default_parameter; 9, 10; 9, 11; 10, identifier:dorev; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:verbose; 14, integer:0; 15, block; 15, 16; 15, 29; 15, 59; 16, if_statement; 16, 17; 16, 18; 16, 23; 17, identifier:dorev; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:dorev; 22, integer:1; 23, else_clause; 23, 24; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:dorev; 28, integer:0; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:code; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:scipy; 36, identifier:weave; 37, identifier:inline; 38, argument_list; 38, 39; 38, 40; 38, 47; 38, 56; 39, identifier:code; 40, list:['data','s','binsize','hist','rev','dorev']; 40, 41; 40, 42; 40, 43; 40, 44; 40, 45; 40, 46; 41, string:'data'; 42, string:'s'; 43, string:'binsize'; 44, string:'hist'; 45, string:'rev'; 46, string:'dorev'; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:type_converters; 49, attribute; 49, 50; 49, 55; 50, attribute; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:scipy; 53, identifier:weave; 54, identifier:converters; 55, identifier:blitz; 56, keyword_argument; 56, 57; 56, 58; 57, identifier:verbose; 58, identifier:verbose; 59, return_statement | def _weave_dohist(data, s, binsize, hist, rev, dorev=False, verbose=0):
if dorev:
dorev=1
else:
dorev=0
code =
scipy.weave.inline(code, ['data','s','binsize','hist','rev','dorev'],
type_converters = scipy.weave.converters.blitz, verbose=verbose)
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:loose_search; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:asset_manager_id; 6, default_parameter; 6, 7; 6, 8; 7, identifier:query; 8, string:''; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 22; 11, 38; 11, 45; 11, 90; 11, 104; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:logger; 18, identifier:info; 19, argument_list; 19, 20; 19, 21; 20, string:'Asset Search - Asset Manager: %s'; 21, identifier:asset_manager_id; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:url; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, string:'{endpoint}/assets/search/{asset_manager_id}'; 28, identifier:format; 29, argument_list; 29, 30; 29, 33; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:asset_manager_id; 32, identifier:asset_manager_id; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:endpoint; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:endpoint; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:params; 41, dictionary; 41, 42; 42, pair; 42, 43; 42, 44; 43, string:'query'; 44, identifier:query; 45, for_statement; 45, 46; 45, 49; 45, 54; 46, pattern_list; 46, 47; 46, 48; 47, identifier:k; 48, identifier:v; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:kwargs; 52, identifier:items; 53, argument_list; 54, block; 54, 55; 54, 84; 55, if_statement; 55, 56; 55, 68; 56, boolean_operator:and; 56, 57; 56, 63; 57, not_operator; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:isinstance; 60, argument_list; 60, 61; 60, 62; 61, identifier:v; 62, identifier:str; 63, call; 63, 64; 63, 65; 64, identifier:isinstance; 65, argument_list; 65, 66; 65, 67; 66, identifier:v; 67, identifier:Iterable; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:v; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, string:','; 75, identifier:join; 76, generator_expression; 76, 77; 76, 81; 77, call; 77, 78; 77, 79; 78, identifier:str; 79, argument_list; 79, 80; 80, identifier:i; 81, for_in_clause; 81, 82; 81, 83; 82, identifier:i; 83, identifier:v; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:params; 88, identifier:k; 89, identifier:v; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:response; 93, call; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:session; 98, identifier:get; 99, argument_list; 99, 100; 99, 101; 100, identifier:url; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:params; 103, identifier:params; 104, if_statement; 104, 105; 104, 108; 104, 149; 105, attribute; 105, 106; 105, 107; 106, identifier:response; 107, identifier:ok; 108, block; 108, 109; 108, 117; 108, 134; 108, 147; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:data; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:response; 115, identifier:json; 116, argument_list; 117, expression_statement; 117, 118; 118, assignment; 118, 119; 118, 120; 119, identifier:assets; 120, list_comprehension; 120, 121; 120, 125; 121, call; 121, 122; 121, 123; 122, identifier:json_to_asset; 123, argument_list; 123, 124; 124, identifier:json_asset; 125, for_in_clause; 125, 126; 125, 127; 126, identifier:json_asset; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:data; 130, identifier:get; 131, argument_list; 131, 132; 131, 133; 132, string:'hits'; 133, list:[]; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:logger; 140, identifier:info; 141, argument_list; 141, 142; 141, 143; 142, string:'Returned %s Assets.'; 143, call; 143, 144; 143, 145; 144, identifier:len; 145, argument_list; 145, 146; 146, identifier:assets; 147, return_statement; 147, 148; 148, identifier:assets; 149, else_clause; 149, 150; 150, block; 150, 151; 150, 162; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 158; 153, attribute; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:logger; 157, identifier:error; 158, argument_list; 158, 159; 159, attribute; 159, 160; 159, 161; 160, identifier:response; 161, identifier:text; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:response; 166, identifier:raise_for_status; 167, argument_list | def loose_search(self, asset_manager_id, query='', **kwargs):
self.logger.info('Asset Search - Asset Manager: %s', asset_manager_id)
url = '{endpoint}/assets/search/{asset_manager_id}'.format(
asset_manager_id=asset_manager_id,
endpoint=self.endpoint,
)
params = {'query': query}
for k, v in kwargs.items():
if not isinstance(v, str) and isinstance(v, Iterable):
v = ','.join(str(i) for i in v)
params[k] = v
response = self.session.get(url, params=params)
if response.ok:
data = response.json()
assets = [json_to_asset(json_asset) for json_asset in data.get('hits', [])]
self.logger.info('Returned %s Assets.', len(assets))
return assets
else:
self.logger.error(response.text)
response.raise_for_status() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:natural_sort; 3, parameters; 3, 4; 4, identifier:item; 5, block; 5, 6; 5, 13; 5, 30; 6, if_statement; 6, 7; 6, 10; 7, comparison_operator:is; 7, 8; 7, 9; 8, identifier:item; 9, None; 10, block; 10, 11; 11, return_statement; 11, 12; 12, integer:0; 13, function_definition; 13, 14; 13, 15; 13, 17; 14, function_name:try_int; 15, parameters; 15, 16; 16, identifier:s; 17, block; 17, 18; 18, try_statement; 18, 19; 18, 25; 19, block; 19, 20; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:int; 23, argument_list; 23, 24; 24, identifier:s; 25, except_clause; 25, 26; 25, 27; 26, identifier:ValueError; 27, block; 27, 28; 28, return_statement; 28, 29; 29, identifier:s; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:tuple; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:map; 36, argument_list; 36, 37; 36, 38; 37, identifier:try_int; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:re; 41, identifier:findall; 42, argument_list; 42, 43; 42, 44; 43, string:r'(\d+|\D+)'; 44, identifier:item | def natural_sort(item):
if item is None:
return 0
def try_int(s):
try:
return int(s)
except ValueError:
return s
return tuple(map(try_int, re.findall(r'(\d+|\D+)', item))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_html_attrs; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:kwargs; 6, None; 7, block; 7, 8; 7, 14; 7, 18; 7, 22; 7, 36; 7, 73; 7, 83; 7, 151; 7, 157; 7, 163; 7, 170; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:kwargs; 11, boolean_operator:or; 11, 12; 11, 13; 12, identifier:kwargs; 13, dictionary; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:attrs; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:props; 21, list:[]; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:classes; 25, call; 25, 26; 25, 35; 26, attribute; 26, 27; 26, 34; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:kwargs; 30, identifier:get; 31, argument_list; 31, 32; 31, 33; 32, string:'classes'; 33, string:''; 34, identifier:strip; 35, argument_list; 36, if_statement; 36, 37; 36, 38; 37, identifier:classes; 38, block; 38, 39; 38, 54; 38, 64; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:classes; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, string:' '; 45, identifier:join; 46, argument_list; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:re; 50, identifier:split; 51, argument_list; 51, 52; 51, 53; 52, string:r'\s+'; 53, identifier:classes; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:classes; 57, call; 57, 58; 57, 59; 58, identifier:to_unicode; 59, argument_list; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:quoteattr; 62, argument_list; 62, 63; 63, identifier:classes; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:attrs; 68, identifier:append; 69, argument_list; 69, 70; 70, binary_operator:%; 70, 71; 70, 72; 71, string:'class=%s'; 72, identifier:classes; 73, try_statement; 73, 74; 73, 79; 74, block; 74, 75; 75, delete_statement; 75, 76; 76, subscript; 76, 77; 76, 78; 77, identifier:kwargs; 78, string:'classes'; 79, except_clause; 79, 80; 79, 81; 80, identifier:KeyError; 81, block; 81, 82; 82, pass_statement; 83, for_statement; 83, 84; 83, 87; 83, 91; 84, pattern_list; 84, 85; 84, 86; 85, identifier:key; 86, identifier:value; 87, call; 87, 88; 87, 89; 88, identifier:iteritems; 89, argument_list; 89, 90; 90, identifier:kwargs; 91, block; 91, 92; 91, 102; 91, 109; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:key; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:key; 98, identifier:replace; 99, argument_list; 99, 100; 99, 101; 100, string:'_'; 101, string:'-'; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:key; 105, call; 105, 106; 105, 107; 106, identifier:to_unicode; 107, argument_list; 107, 108; 108, identifier:key; 109, if_statement; 109, 110; 109, 115; 109, 128; 110, call; 110, 111; 110, 112; 111, identifier:isinstance; 112, argument_list; 112, 113; 112, 114; 113, identifier:value; 114, identifier:bool; 115, block; 115, 116; 116, if_statement; 116, 117; 116, 120; 117, comparison_operator:is; 117, 118; 117, 119; 118, identifier:value; 119, True; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:props; 125, identifier:append; 126, argument_list; 126, 127; 127, identifier:key; 128, else_clause; 128, 129; 129, block; 129, 130; 129, 140; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:value; 133, call; 133, 134; 133, 135; 134, identifier:quoteattr; 135, argument_list; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:Markup; 138, argument_list; 138, 139; 139, identifier:value; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:attrs; 144, identifier:append; 145, argument_list; 145, 146; 146, binary_operator:%; 146, 147; 146, 148; 147, string:u'%s=%s'; 148, tuple; 148, 149; 148, 150; 149, identifier:key; 150, identifier:value; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:attrs; 155, identifier:sort; 156, argument_list; 157, expression_statement; 157, 158; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:props; 161, identifier:sort; 162, argument_list; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:attrs; 167, identifier:extend; 168, argument_list; 168, 169; 169, identifier:props; 170, return_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, string:u' '; 174, identifier:join; 175, argument_list; 175, 176; 176, identifier:attrs | def get_html_attrs(kwargs=None):
kwargs = kwargs or {}
attrs = []
props = []
classes = kwargs.get('classes', '').strip()
if classes:
classes = ' '.join(re.split(r'\s+', classes))
classes = to_unicode(quoteattr(classes))
attrs.append('class=%s' % classes)
try:
del kwargs['classes']
except KeyError:
pass
for key, value in iteritems(kwargs):
key = key.replace('_', '-')
key = to_unicode(key)
if isinstance(value, bool):
if value is True:
props.append(key)
else:
value = quoteattr(Markup(value))
attrs.append(u'%s=%s' % (key, value))
attrs.sort()
props.sort()
attrs.extend(props)
return u' '.join(attrs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_dependencies; 3, parameters; 3, 4; 4, identifier:objects; 5, block; 5, 6; 5, 13; 5, 17; 5, 23; 5, 29; 5, 36; 5, 62; 5, 172; 5, 178; 5, 182; 5, 308; 5, 312; 5, 325; 6, import_from_statement; 6, 7; 6, 11; 7, dotted_name; 7, 8; 7, 9; 7, 10; 8, identifier:django; 9, identifier:db; 10, identifier:models; 11, dotted_name; 11, 12; 12, identifier:get_model; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:model_dependencies; 16, list:[]; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:models; 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:model_list; 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:objs_by_model; 32, call; 32, 33; 32, 34; 33, identifier:defaultdict; 34, argument_list; 34, 35; 35, identifier:list; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:o; 38, identifier:objects; 39, block; 39, 40; 39, 46; 39, 55; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:model; 43, attribute; 43, 44; 43, 45; 44, identifier:o; 45, identifier:__class__; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:objs_by_model; 51, identifier:model; 52, identifier:append; 53, argument_list; 53, 54; 54, identifier:o; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:model_list; 59, identifier:add; 60, argument_list; 60, 61; 61, identifier:model; 62, for_statement; 62, 63; 62, 64; 62, 65; 63, identifier:model; 64, identifier:model_list; 65, block; 65, 66; 65, 73; 65, 117; 65, 163; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:models; 70, identifier:add; 71, argument_list; 71, 72; 72, identifier:model; 73, if_statement; 73, 74; 73, 79; 73, 111; 74, call; 74, 75; 74, 76; 75, identifier:hasattr; 76, argument_list; 76, 77; 76, 78; 77, identifier:model; 78, string:'natural_key'; 79, block; 79, 80; 79, 91; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:deps; 83, call; 83, 84; 83, 85; 84, identifier:getattr; 85, argument_list; 85, 86; 85, 89; 85, 90; 86, attribute; 86, 87; 86, 88; 87, identifier:model; 88, identifier:natural_key; 89, string:'dependencies'; 90, list:[]; 91, if_statement; 91, 92; 91, 93; 92, identifier:deps; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:deps; 97, list_comprehension; 97, 98; 97, 108; 98, call; 98, 99; 98, 100; 99, identifier:get_model; 100, argument_list; 100, 101; 101, list_splat; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:d; 105, identifier:split; 106, argument_list; 106, 107; 107, string:'.'; 108, for_in_clause; 108, 109; 108, 110; 109, identifier:d; 110, identifier:deps; 111, else_clause; 111, 112; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:deps; 116, list:[]; 117, for_statement; 117, 118; 117, 119; 117, 134; 118, identifier:field; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:itertools; 122, identifier:chain; 123, argument_list; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:model; 127, identifier:_meta; 128, identifier:fields; 129, attribute; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:model; 132, identifier:_meta; 133, identifier:many_to_many; 134, block; 134, 135; 135, if_statement; 135, 136; 135, 151; 136, boolean_operator:and; 136, 137; 136, 144; 137, call; 137, 138; 137, 139; 138, identifier:hasattr; 139, argument_list; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:field; 142, identifier:rel; 143, string:'to'; 144, comparison_operator:!=; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:field; 148, identifier:rel; 149, identifier:to; 150, identifier:model; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, identifier:deps; 156, identifier:append; 157, argument_list; 157, 158; 158, attribute; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:field; 161, identifier:rel; 162, identifier:to; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:model_dependencies; 167, identifier:append; 168, argument_list; 168, 169; 169, tuple; 169, 170; 169, 171; 170, identifier:model; 171, identifier:deps; 172, expression_statement; 172, 173; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:model_dependencies; 176, identifier:reverse; 177, argument_list; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:model_list; 181, list:[]; 182, while_statement; 182, 183; 182, 184; 183, identifier:model_dependencies; 184, block; 184, 185; 184, 189; 184, 193; 184, 258; 184, 304; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:skipped; 188, list:[]; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:changed; 192, False; 193, while_statement; 193, 194; 193, 195; 194, identifier:model_dependencies; 195, block; 195, 196; 195, 206; 195, 210; 195, 233; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 201; 198, pattern_list; 198, 199; 198, 200; 199, identifier:model; 200, identifier:deps; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:model_dependencies; 204, identifier:pop; 205, argument_list; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 209; 208, identifier:found; 209, True; 210, for_statement; 210, 211; 210, 212; 210, 224; 211, identifier:candidate; 212, generator_expression; 212, 213; 212, 221; 213, parenthesized_expression; 213, 214; 214, boolean_operator:or; 214, 215; 214, 218; 215, comparison_operator:not; 215, 216; 215, 217; 216, identifier:d; 217, identifier:models; 218, comparison_operator:in; 218, 219; 218, 220; 219, identifier:d; 220, identifier:model_list; 221, for_in_clause; 221, 222; 221, 223; 222, identifier:d; 223, identifier:deps; 224, block; 224, 225; 225, if_statement; 225, 226; 225, 228; 226, not_operator; 226, 227; 227, identifier:candidate; 228, block; 228, 229; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:found; 232, False; 233, if_statement; 233, 234; 233, 235; 233, 247; 234, identifier:found; 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:model_list; 240, identifier:append; 241, argument_list; 241, 242; 242, identifier:model; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:changed; 246, True; 247, else_clause; 247, 248; 248, block; 248, 249; 249, expression_statement; 249, 250; 250, call; 250, 251; 250, 254; 251, attribute; 251, 252; 251, 253; 252, identifier:skipped; 253, identifier:append; 254, argument_list; 254, 255; 255, tuple; 255, 256; 255, 257; 256, identifier:model; 257, identifier:deps; 258, if_statement; 258, 259; 258, 261; 259, not_operator; 259, 260; 260, identifier:changed; 261, block; 261, 262; 262, raise_statement; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:CommandError; 265, argument_list; 265, 266; 266, binary_operator:%; 266, 267; 266, 268; 267, string:"Can't resolve dependencies for %s in serialized app list."; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, string:', '; 271, identifier:join; 272, generator_expression; 272, 273; 272, 286; 273, binary_operator:%; 273, 274; 273, 275; 274, string:'%s.%s'; 275, tuple; 275, 276; 275, 281; 276, attribute; 276, 277; 276, 280; 277, attribute; 277, 278; 277, 279; 278, identifier:model; 279, identifier:_meta; 280, identifier:app_label; 281, attribute; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, identifier:model; 284, identifier:_meta; 285, identifier:object_name; 286, for_in_clause; 286, 287; 286, 290; 287, pattern_list; 287, 288; 287, 289; 288, identifier:model; 289, identifier:deps; 290, call; 290, 291; 290, 292; 291, identifier:sorted; 292, argument_list; 292, 293; 292, 294; 293, identifier:skipped; 294, keyword_argument; 294, 295; 294, 296; 295, identifier:key; 296, lambda; 296, 297; 296, 299; 297, lambda_parameters; 297, 298; 298, identifier:obj; 299, attribute; 299, 300; 299, 303; 300, subscript; 300, 301; 300, 302; 301, identifier:obj; 302, integer:0; 303, identifier:__name__; 304, expression_statement; 304, 305; 305, assignment; 305, 306; 305, 307; 306, identifier:model_dependencies; 307, identifier:skipped; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:sorted_results; 311, list:[]; 312, for_statement; 312, 313; 312, 314; 312, 315; 313, identifier:model; 314, identifier:model_list; 315, block; 315, 316; 316, expression_statement; 316, 317; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:sorted_results; 320, identifier:extend; 321, argument_list; 321, 322; 322, subscript; 322, 323; 322, 324; 323, identifier:objs_by_model; 324, identifier:model; 325, return_statement; 325, 326; 326, identifier:sorted_results | def sort_dependencies(objects):
from django.db.models import get_model
model_dependencies = []
models = set()
model_list = set()
objs_by_model = defaultdict(list)
for o in objects:
model = o.__class__
objs_by_model[model].append(o)
model_list.add(model)
for model in model_list:
models.add(model)
if hasattr(model, 'natural_key'):
deps = getattr(model.natural_key, 'dependencies', [])
if deps:
deps = [get_model(*d.split('.')) for d in deps]
else:
deps = []
for field in itertools.chain(model._meta.fields, model._meta.many_to_many):
if hasattr(field.rel, 'to') and field.rel.to != model:
deps.append(field.rel.to)
model_dependencies.append((model, deps))
model_dependencies.reverse()
model_list = []
while model_dependencies:
skipped = []
changed = False
while model_dependencies:
model, deps = model_dependencies.pop()
found = True
for candidate in ((d not in models or d in model_list) for d in deps):
if not candidate:
found = False
if found:
model_list.append(model)
changed = True
else:
skipped.append((model, deps))
if not changed:
raise CommandError("Can't resolve dependencies for %s in serialized app list." %
', '.join('%s.%s' % (model._meta.app_label, model._meta.object_name)
for model, deps in sorted(skipped, key=lambda obj: obj[0].__name__))
)
model_dependencies = skipped
sorted_results = []
for model in model_list:
sorted_results.extend(objs_by_model[model])
return sorted_results |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:sort_languages; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:order; 7, attribute; 7, 8; 7, 9; 8, identifier:Qt; 9, identifier:AscendingOrder; 10, block; 10, 11; 10, 17; 10, 40; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:beginResetModel; 16, argument_list; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:__languages; 22, call; 22, 23; 22, 24; 23, identifier:sorted; 24, argument_list; 24, 25; 24, 28; 24, 37; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:__languages; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:key; 30, lambda; 30, 31; 30, 33; 31, lambda_parameters; 31, 32; 32, identifier:x; 33, parenthesized_expression; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:x; 36, identifier:name; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:reverse; 39, identifier:order; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:endResetModel; 45, argument_list | def sort_languages(self, order=Qt.AscendingOrder):
self.beginResetModel()
self.__languages = sorted(self.__languages, key=lambda x: (x.name), reverse=order)
self.endResetModel() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:fmt_pairs; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:obj; 5, default_parameter; 5, 6; 5, 7; 6, identifier:indent; 7, integer:4; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort_key; 10, None; 11, block; 11, 12; 11, 25; 11, 31; 11, 38; 11, 48; 11, 58; 11, 79; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:lengths; 15, list_comprehension; 15, 16; 15, 22; 16, call; 16, 17; 16, 18; 17, identifier:len; 18, argument_list; 18, 19; 19, subscript; 19, 20; 19, 21; 20, identifier:x; 21, integer:0; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:x; 24, identifier:obj; 25, if_statement; 25, 26; 25, 28; 26, not_operator; 26, 27; 27, identifier:lengths; 28, block; 28, 29; 29, return_statement; 29, 30; 30, string:''; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:longest; 34, call; 34, 35; 34, 36; 35, identifier:max; 36, argument_list; 36, 37; 37, identifier:lengths; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:obj; 41, call; 41, 42; 41, 43; 42, identifier:sorted; 43, argument_list; 43, 44; 43, 45; 44, identifier:obj; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:key; 47, identifier:sort_key; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:formatter; 51, binary_operator:%; 51, 52; 51, 53; 52, string:'%s{: <%d} {}'; 53, tuple; 53, 54; 53, 57; 54, binary_operator:*; 54, 55; 54, 56; 55, string:' '; 56, identifier:indent; 57, identifier:longest; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:string; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, string:'\n'; 64, identifier:join; 65, argument_list; 65, 66; 66, list_comprehension; 66, 67; 66, 74; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:formatter; 70, identifier:format; 71, argument_list; 71, 72; 71, 73; 72, identifier:k; 73, identifier:v; 74, for_in_clause; 74, 75; 74, 78; 75, pattern_list; 75, 76; 75, 77; 76, identifier:k; 77, identifier:v; 78, identifier:obj; 79, return_statement; 79, 80; 80, identifier:string | def fmt_pairs(obj, indent=4, sort_key=None):
lengths = [len(x[0]) for x in obj]
if not lengths:
return ''
longest = max(lengths)
obj = sorted(obj, key=sort_key)
formatter = '%s{: <%d} {}' % (' ' * indent, longest)
string = '\n'.join([formatter.format(k, v) for k, v in obj])
return string |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:serialize; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:as_dict; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, None; 11, block; 11, 12; 11, 25; 11, 48; 11, 64; 11, 88; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:files; 15, call; 15, 16; 15, 17; 16, identifier:getattr; 17, argument_list; 17, 18; 17, 19; 17, 20; 18, identifier:self; 19, string:'files'; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:run; 24, argument_list; 25, if_statement; 25, 26; 25, 27; 26, identifier:as_dict; 27, block; 27, 28; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:dict; 31, generator_expression; 31, 32; 31, 39; 32, tuple; 32, 33; 32, 34; 33, identifier:fn; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:p; 37, identifier:to_dict; 38, argument_list; 39, for_in_clause; 39, 40; 39, 43; 40, pattern_list; 40, 41; 40, 42; 41, identifier:fn; 42, identifier:p; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:files; 46, identifier:items; 47, argument_list; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:data; 51, generator_expression; 51, 52; 51, 57; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:p; 55, identifier:to_dict; 56, argument_list; 57, for_in_clause; 57, 58; 57, 59; 58, identifier:p; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:files; 62, identifier:values; 63, argument_list; 64, if_statement; 64, 65; 64, 69; 64, 78; 65, call; 65, 66; 65, 67; 66, identifier:callable; 67, argument_list; 67, 68; 68, identifier:sort; 69, block; 69, 70; 70, return_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:sorted; 73, argument_list; 73, 74; 73, 75; 74, identifier:data; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:key; 77, identifier:sort; 78, elif_clause; 78, 79; 78, 82; 79, comparison_operator:is; 79, 80; 79, 81; 80, identifier:sort; 81, True; 82, block; 82, 83; 83, return_statement; 83, 84; 84, call; 84, 85; 84, 86; 85, identifier:sorted; 86, argument_list; 86, 87; 87, identifier:data; 88, return_statement; 88, 89; 89, call; 89, 90; 89, 91; 90, identifier:list; 91, argument_list; 91, 92; 92, identifier:data | def serialize(self, as_dict=False, sort=None):
files = getattr(self, 'files', self.run())
if as_dict:
return dict((fn, p.to_dict()) for fn, p in files.items())
data = (p.to_dict() for p in files.values())
if callable(sort):
return sorted(data, key=sort)
elif sort is True:
return sorted(data)
return list(data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:iteritems; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 28; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sorted_data; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, argument_list; 11, 12; 11, 19; 11, 22; 11, 25; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:data; 17, identifier:iteritems; 18, argument_list; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:cmp; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:key; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:reverse; 28, for_statement; 28, 29; 28, 32; 28, 33; 29, pattern_list; 29, 30; 29, 31; 30, identifier:k; 31, identifier:v; 32, identifier:sorted_data; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, yield; 35, 36; 36, expression_list; 36, 37; 36, 38; 37, identifier:k; 38, identifier:v | def iteritems(self):
sorted_data = sorted(self.data.iteritems(), self.cmp, self.key,
self.reverse)
for k,v in sorted_data:
yield k,v |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_posts; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:num; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:tag; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:private; 13, False; 14, block; 14, 15; 14, 21; 14, 37; 14, 54; 14, 63; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:posts; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:posts; 21, if_statement; 21, 22; 21, 24; 22, not_operator; 22, 23; 23, identifier:private; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:posts; 28, list_comprehension; 28, 29; 28, 30; 28, 33; 29, identifier:post; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:post; 32, identifier:posts; 33, if_clause; 33, 34; 34, attribute; 34, 35; 34, 36; 35, identifier:post; 36, identifier:public; 37, if_statement; 37, 38; 37, 39; 38, identifier:tag; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:posts; 43, list_comprehension; 43, 44; 43, 45; 43, 48; 44, identifier:post; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:post; 47, identifier:posts; 48, if_clause; 48, 49; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:tag; 51, attribute; 51, 52; 51, 53; 52, identifier:post; 53, identifier:tags; 54, if_statement; 54, 55; 54, 56; 55, identifier:num; 56, block; 56, 57; 57, return_statement; 57, 58; 58, subscript; 58, 59; 58, 60; 59, identifier:posts; 60, slice; 60, 61; 60, 62; 61, colon; 62, identifier:num; 63, return_statement; 63, 64; 64, identifier:posts | def get_posts(self, num=None, tag=None, private=False):
posts = self.posts
if not private:
posts = [post for post in posts if post.public]
if tag:
posts = [post for post in posts if tag in post.tags]
if num:
return posts[:num]
return posts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_sort_function; 3, parameters; 3, 4; 4, identifier:order; 5, block; 5, 6; 5, 26; 5, 71; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:stable; 9, call; 9, 10; 9, 11; 10, identifier:tuple; 11, generator_expression; 11, 12; 11, 23; 12, tuple; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:d; 15, string:'key'; 16, conditional_expression:if; 16, 17; 16, 19; 16, 22; 17, unary_operator:-; 17, 18; 18, integer:1; 19, subscript; 19, 20; 19, 21; 20, identifier:d; 21, string:'reverse'; 22, integer:1; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:d; 25, identifier:order; 26, function_definition; 26, 27; 26, 28; 26, 31; 27, function_name:sort_function; 28, parameters; 28, 29; 28, 30; 29, identifier:a; 30, identifier:b; 31, block; 31, 32; 31, 69; 32, for_statement; 32, 33; 32, 36; 32, 37; 33, pattern_list; 33, 34; 33, 35; 34, identifier:name; 35, identifier:direction; 36, identifier:stable; 37, block; 37, 38; 37, 60; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:v; 41, call; 41, 42; 41, 43; 42, identifier:cmp; 43, argument_list; 43, 44; 43, 52; 44, conditional_expression:if; 44, 45; 44, 50; 44, 51; 45, call; 45, 46; 45, 47; 46, identifier:getattr; 47, argument_list; 47, 48; 47, 49; 48, identifier:a; 49, identifier:name; 50, identifier:a; 51, identifier:a; 52, conditional_expression:if; 52, 53; 52, 58; 52, 59; 53, call; 53, 54; 53, 55; 54, identifier:getattr; 55, argument_list; 55, 56; 55, 57; 56, identifier:b; 57, identifier:name; 58, identifier:b; 59, identifier:b; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:!=; 61, 62; 61, 63; 62, identifier:v; 63, integer:0; 64, block; 64, 65; 65, return_statement; 65, 66; 66, binary_operator:*; 66, 67; 66, 68; 67, identifier:v; 68, identifier:direction; 69, return_statement; 69, 70; 70, integer:0; 71, return_statement; 71, 72; 72, identifier:sort_function | def get_sort_function(order):
stable = tuple((d['key'], -1 if d['reverse'] else 1) for d in order)
def sort_function(a, b):
for name, direction in stable:
v = cmp(getattr(a, name) if a else a, getattr(b, name) if b else b)
if v != 0:
return v * direction
return 0
return sort_function |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:create_proxy_model; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:model; 6, block; 6, 7; 6, 14; 6, 21; 6, 32; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:proxy; 10, call; 10, 11; 10, 12; 11, identifier:ReftrackSortFilterModel; 12, argument_list; 12, 13; 13, identifier:self; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:proxy; 18, identifier:setSourceModel; 19, argument_list; 19, 20; 20, identifier:model; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:model; 26, identifier:rowsInserted; 27, identifier:connect; 28, argument_list; 28, 29; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:sort_model; 32, return_statement; 32, 33; 33, identifier:proxy | def create_proxy_model(self, model):
proxy = ReftrackSortFilterModel(self)
proxy.setSourceModel(model)
model.rowsInserted.connect(self.sort_model)
return proxy |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort_model; 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:kwargs; 9, block; 9, 10; 9, 19; 9, 28; 9, 37; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:proxy; 16, identifier:sort; 17, argument_list; 17, 18; 18, integer:17; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:proxy; 25, identifier:sort; 26, argument_list; 26, 27; 27, integer:2; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:proxy; 34, identifier:sort; 35, argument_list; 35, 36; 36, integer:1; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:proxy; 43, identifier:sort; 44, argument_list; 44, 45; 45, integer:0 | def sort_model(self, *args, **kwargs):
self.proxy.sort(17)
self.proxy.sort(2)
self.proxy.sort(1)
self.proxy.sort(0) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:prepare_value; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:value; 6, block; 6, 7; 6, 41; 7, if_statement; 7, 8; 7, 15; 8, boolean_operator:and; 8, 9; 8, 12; 9, comparison_operator:is; 9, 10; 9, 11; 10, identifier:value; 11, None; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:required; 15, block; 15, 16; 15, 25; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:choices; 19, call; 19, 20; 19, 21; 20, identifier:list; 21, argument_list; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:choices; 25, if_statement; 25, 26; 25, 32; 26, comparison_operator:==; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:choices; 31, integer:1; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:value; 36, subscript; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:choices; 39, integer:0; 40, integer:0; 41, return_statement; 41, 42; 42, call; 42, 43; 42, 50; 43, attribute; 43, 44; 43, 49; 44, call; 44, 45; 44, 46; 45, identifier:super; 46, argument_list; 46, 47; 46, 48; 47, identifier:TemplateChoiceField; 48, identifier:self; 49, identifier:prepare_value; 50, argument_list; 50, 51; 51, identifier:value | def prepare_value(self, value):
if value is None and self.required:
choices =list(self.choices)
if len(choices) == 1:
value = choices[0][0]
return super(TemplateChoiceField, self).prepare_value(value) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sort; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 15; 5, 39; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 13; 8, attribute; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:_log; 12, identifier:debug; 13, argument_list; 13, 14; 14, string:'Sorting responses by priority'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_responses; 20, call; 20, 21; 20, 22; 21, identifier:OrderedDict; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:sorted; 25, argument_list; 25, 26; 25, 36; 26, call; 26, 27; 26, 28; 27, identifier:list; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_responses; 34, identifier:items; 35, argument_list; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:reverse; 38, True; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:sorted; 44, True | def _sort(self):
self._log.debug('Sorting responses by priority')
self._responses = OrderedDict(sorted(list(self._responses.items()), reverse=True))
self.sorted = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:csv_row_to_transaction; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:index; 5, identifier:row; 6, default_parameter; 6, 7; 6, 8; 7, identifier:source_encoding; 8, string:"latin1"; 9, default_parameter; 9, 10; 9, 11; 10, identifier:date_format; 11, string:"%d-%m-%Y"; 12, default_parameter; 12, 13; 12, 14; 13, identifier:thousand_sep; 14, string:"."; 15, default_parameter; 15, 16; 15, 17; 16, identifier:decimal_sep; 17, string:","; 18, block; 18, 19; 18, 28; 18, 37; 18, 46; 18, 56; 18, 65; 18, 74; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 27; 21, pattern_list; 21, 22; 21, 23; 21, 24; 21, 25; 21, 26; 22, identifier:xfer; 23, identifier:posted; 24, identifier:message; 25, identifier:amount; 26, identifier:total; 27, identifier:row; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:xfer; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:Parse; 34, identifier:date; 35, argument_list; 35, 36; 36, identifier:xfer; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:posted; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:Parse; 43, identifier:date; 44, argument_list; 44, 45; 45, identifier:posted; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:message; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:Parse; 52, identifier:to_utf8; 53, argument_list; 53, 54; 53, 55; 54, identifier:message; 55, identifier:source_encoding; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:amount; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:Parse; 62, identifier:money; 63, argument_list; 63, 64; 64, identifier:amount; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:total; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:Parse; 71, identifier:money; 72, argument_list; 72, 73; 73, identifier:total; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:Transaction; 77, argument_list; 77, 78; 77, 79; 77, 80; 77, 81; 77, 82; 77, 83; 78, identifier:index; 79, identifier:xfer; 80, identifier:posted; 81, identifier:message; 82, identifier:amount; 83, identifier:total | def csv_row_to_transaction(index, row, source_encoding="latin1",
date_format="%d-%m-%Y", thousand_sep=".", decimal_sep=","):
xfer, posted, message, amount, total = row
xfer = Parse.date(xfer)
posted = Parse.date(posted)
message = Parse.to_utf8(message, source_encoding)
amount = Parse.money(amount)
total = Parse.money(total)
return Transaction(index, xfer, posted, message, amount, total) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:csv_to_transactions; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:handle; 5, default_parameter; 5, 6; 5, 7; 6, identifier:source_encoding; 7, string:"latin1"; 8, default_parameter; 8, 9; 8, 10; 9, identifier:date_format; 10, string:"%d-%m-%Y"; 11, default_parameter; 11, 12; 11, 13; 12, identifier:thousand_sep; 13, string:"."; 14, default_parameter; 14, 15; 14, 16; 15, identifier:decimal_sep; 16, string:","; 17, block; 17, 18; 17, 24; 17, 39; 17, 61; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:trans; 21, call; 21, 22; 21, 23; 22, identifier:Transactions; 23, argument_list; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:rows; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:csv; 30, identifier:reader; 31, argument_list; 31, 32; 31, 33; 31, 36; 32, identifier:handle; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:delimiter; 35, string:";"; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:quotechar; 38, string:"\""; 39, for_statement; 39, 40; 39, 43; 39, 47; 40, pattern_list; 40, 41; 40, 42; 41, identifier:index; 42, identifier:row; 43, call; 43, 44; 43, 45; 44, identifier:enumerate; 45, argument_list; 45, 46; 46, identifier:rows; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:trans; 52, identifier:append; 53, argument_list; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:Parse; 57, identifier:csv_row_to_transaction; 58, argument_list; 58, 59; 58, 60; 59, identifier:index; 60, identifier:row; 61, return_statement; 61, 62; 62, identifier:trans | def csv_to_transactions(handle, source_encoding="latin1",
date_format="%d-%m-%Y", thousand_sep=".", decimal_sep=","):
trans = Transactions()
rows = csv.reader(handle, delimiter=";", quotechar="\"")
for index, row in enumerate(rows):
trans.append(Parse.csv_row_to_transaction(index, row))
return trans |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:filterAcceptsRow; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:row; 6, identifier:parentindex; 7, block; 7, 8; 7, 24; 7, 49; 7, 60; 7, 69; 8, if_statement; 8, 9; 8, 21; 9, not_operator; 9, 10; 10, call; 10, 11; 10, 18; 11, attribute; 11, 12; 11, 17; 12, call; 12, 13; 12, 14; 13, identifier:super; 14, argument_list; 14, 15; 14, 16; 15, identifier:ReftrackSortFilterModel; 16, identifier:self; 17, identifier:filterAcceptsRow; 18, argument_list; 18, 19; 18, 20; 19, identifier:row; 20, identifier:parentindex; 21, block; 21, 22; 22, return_statement; 22, 23; 23, False; 24, if_statement; 24, 25; 24, 30; 24, 39; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:parentindex; 28, identifier:isValid; 29, argument_list; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:m; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:parentindex; 37, identifier:model; 38, argument_list; 39, else_clause; 39, 40; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:m; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:sourceModel; 48, argument_list; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:i; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:m; 55, identifier:index; 56, argument_list; 56, 57; 56, 58; 56, 59; 57, identifier:row; 58, integer:18; 59, identifier:parentindex; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:reftrack; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:i; 66, identifier:data; 67, argument_list; 67, 68; 68, identifier:REFTRACK_OBJECT_ROLE; 69, if_statement; 69, 70; 69, 72; 69, 75; 70, not_operator; 70, 71; 71, identifier:reftrack; 72, block; 72, 73; 73, return_statement; 73, 74; 74, True; 75, else_clause; 75, 76; 76, block; 76, 77; 77, return_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:self; 81, identifier:filter_accept_reftrack; 82, argument_list; 82, 83; 83, identifier:reftrack | def filterAcceptsRow(self, row, parentindex):
if not super(ReftrackSortFilterModel, self).filterAcceptsRow(row, parentindex):
return False
if parentindex.isValid():
m = parentindex.model()
else:
m = self.sourceModel()
i = m.index(row, 18, parentindex)
reftrack = i.data(REFTRACK_OBJECT_ROLE)
if not reftrack:
return True
else:
return self.filter_accept_reftrack(reftrack) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:load_grid_data; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:file_list; 5, default_parameter; 5, 6; 5, 7; 6, identifier:data_type; 7, string:"binary"; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:delim; 13, string:" "; 14, block; 14, 15; 14, 54; 14, 64; 14, 72; 14, 218; 15, if_statement; 15, 16; 15, 23; 15, 29; 16, not_operator; 16, 17; 17, comparison_operator:is; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:type; 20, argument_list; 20, 21; 21, identifier:file_list; 22, identifier:list; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:file_list; 27, list:[file_list]; 27, 28; 28, identifier:file_list; 29, elif_clause; 29, 30; 29, 31; 30, identifier:sort; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:file_list; 36, identifier:sort; 37, argument_list; 37, 38; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:key; 40, lambda; 40, 41; 40, 43; 41, lambda_parameters; 41, 42; 42, identifier:f; 43, call; 43, 44; 43, 45; 44, identifier:int; 45, argument_list; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:re; 49, identifier:sub; 50, argument_list; 50, 51; 50, 52; 50, 53; 51, string:"[^0-9]"; 52, string:""; 53, identifier:f; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:world_size; 57, call; 57, 58; 57, 59; 58, identifier:get_world_dimensions; 59, argument_list; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:file_list; 62, integer:0; 63, identifier:delim; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:data; 67, call; 67, 68; 67, 69; 68, identifier:initialize_grid; 69, argument_list; 69, 70; 69, 71; 70, identifier:world_size; 71, list:[]; 72, for_statement; 72, 73; 72, 74; 72, 75; 73, identifier:f; 74, identifier:file_list; 75, block; 75, 76; 75, 83; 75, 91; 75, 212; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:infile; 79, call; 79, 80; 79, 81; 80, identifier:open; 81, argument_list; 81, 82; 82, identifier:f; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:lines; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:infile; 89, identifier:readlines; 90, argument_list; 91, for_statement; 91, 92; 91, 93; 91, 99; 92, identifier:i; 93, call; 93, 94; 93, 95; 94, identifier:range; 95, argument_list; 95, 96; 96, subscript; 96, 97; 96, 98; 97, identifier:world_size; 98, integer:1; 99, block; 99, 100; 99, 117; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:lines; 104, identifier:i; 105, call; 105, 106; 105, 115; 106, attribute; 106, 107; 106, 114; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:lines; 111, identifier:i; 112, identifier:strip; 113, argument_list; 114, identifier:split; 115, argument_list; 115, 116; 116, identifier:delim; 117, for_statement; 117, 118; 117, 119; 117, 125; 118, identifier:j; 119, call; 119, 120; 119, 121; 120, identifier:range; 121, argument_list; 121, 122; 122, subscript; 122, 123; 122, 124; 123, identifier:world_size; 124, integer:0; 125, block; 125, 126; 125, 201; 126, if_statement; 126, 127; 126, 130; 126, 145; 126, 161; 126, 177; 126, 193; 127, comparison_operator:==; 127, 128; 127, 129; 128, identifier:data_type; 129, string:"binary"; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:val; 134, call; 134, 135; 134, 136; 135, identifier:bin; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:int; 139, argument_list; 139, 140; 140, subscript; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:lines; 143, identifier:i; 144, identifier:j; 145, elif_clause; 145, 146; 145, 149; 146, comparison_operator:==; 146, 147; 146, 148; 147, identifier:data_type; 148, string:"float"; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:val; 153, call; 153, 154; 153, 155; 154, identifier:float; 155, argument_list; 155, 156; 156, subscript; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:lines; 159, identifier:i; 160, identifier:j; 161, elif_clause; 161, 162; 161, 165; 162, comparison_operator:==; 162, 163; 162, 164; 163, identifier:data_type; 164, string:"int"; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:val; 169, call; 169, 170; 169, 171; 170, identifier:int; 171, argument_list; 171, 172; 172, subscript; 172, 173; 172, 176; 173, subscript; 173, 174; 173, 175; 174, identifier:lines; 175, identifier:i; 176, identifier:j; 177, elif_clause; 177, 178; 177, 181; 178, comparison_operator:==; 178, 179; 178, 180; 179, identifier:data_type; 180, string:"string"; 181, block; 181, 182; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:val; 185, call; 185, 186; 185, 187; 186, identifier:str; 187, argument_list; 187, 188; 188, subscript; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:lines; 191, identifier:i; 192, identifier:j; 193, else_clause; 193, 194; 194, block; 194, 195; 194, 200; 195, expression_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:print; 198, argument_list; 198, 199; 199, string:"Unsupported data_type passed to load_grid"; 200, return_statement; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 210; 203, attribute; 203, 204; 203, 209; 204, subscript; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:data; 207, identifier:i; 208, identifier:j; 209, identifier:append; 210, argument_list; 210, 211; 211, identifier:val; 212, expression_statement; 212, 213; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:infile; 216, identifier:close; 217, argument_list; 218, return_statement; 218, 219; 219, identifier:data | def load_grid_data(file_list, data_type="binary", sort=True, delim=" "):
if not type(file_list) is list:
file_list = [file_list]
elif sort:
file_list.sort(key=lambda f: int(re.sub("[^0-9]", "", f)))
world_size = get_world_dimensions(file_list[0], delim)
data = initialize_grid(world_size, [])
for f in file_list:
infile = open(f)
lines = infile.readlines()
for i in range(world_size[1]):
lines[i] = lines[i].strip().split(delim)
for j in range(world_size[0]):
if data_type == "binary":
val = bin(int(lines[i][j]))
elif data_type == "float":
val = float(lines[i][j])
elif data_type == "int":
val = int(lines[i][j])
elif data_type == "string":
val = str(lines[i][j])
else:
print("Unsupported data_type passed to load_grid")
return
data[i][j].append(val)
infile.close()
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 113; 5, 119; 5, 156; 6, for_statement; 6, 7; 6, 10; 6, 17; 7, pattern_list; 7, 8; 7, 9; 8, identifier:priority; 9, identifier:triggers; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_triggers; 15, identifier:items; 16, argument_list; 17, block; 17, 18; 17, 34; 17, 46; 17, 59; 17, 81; 17, 103; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_log; 24, identifier:debug; 25, argument_list; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, string:'Sorting priority {priority} triggers'; 29, identifier:format; 30, argument_list; 30, 31; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:priority; 33, identifier:priority; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:atomics; 37, list_comprehension; 37, 38; 37, 39; 37, 42; 38, identifier:trigger; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:trigger; 41, identifier:triggers; 42, if_clause; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:trigger; 45, identifier:pattern_is_atomic; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:wildcards; 49, list_comprehension; 49, 50; 49, 51; 49, 54; 50, identifier:trigger; 51, for_in_clause; 51, 52; 51, 53; 52, identifier:trigger; 53, identifier:triggers; 54, if_clause; 54, 55; 55, not_operator; 55, 56; 56, attribute; 56, 57; 56, 58; 57, identifier:trigger; 58, identifier:pattern_is_atomic; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:atomics; 62, call; 62, 63; 62, 64; 63, identifier:sorted; 64, argument_list; 64, 65; 64, 66; 64, 78; 65, identifier:atomics; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:key; 68, lambda; 68, 69; 68, 71; 69, lambda_parameters; 69, 70; 70, identifier:trigger; 71, tuple; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:trigger; 74, identifier:pattern_words; 75, attribute; 75, 76; 75, 77; 76, identifier:trigger; 77, identifier:pattern_len; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:reverse; 80, True; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:wildcards; 84, call; 84, 85; 84, 86; 85, identifier:sorted; 86, argument_list; 86, 87; 86, 88; 86, 100; 87, identifier:wildcards; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:key; 90, lambda; 90, 91; 90, 93; 91, lambda_parameters; 91, 92; 92, identifier:trigger; 93, tuple; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:trigger; 96, identifier:pattern_words; 97, attribute; 97, 98; 97, 99; 98, identifier:trigger; 99, identifier:pattern_len; 100, keyword_argument; 100, 101; 100, 102; 101, identifier:reverse; 102, True; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 110; 105, subscript; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:_triggers; 109, identifier:priority; 110, binary_operator:+; 110, 111; 110, 112; 111, identifier:atomics; 112, identifier:wildcards; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:_sorted_triggers; 118, list:[]; 119, for_statement; 119, 120; 119, 121; 119, 142; 120, identifier:triggers; 121, list_comprehension; 121, 122; 121, 127; 122, subscript; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:_triggers; 126, identifier:priority; 127, for_in_clause; 127, 128; 127, 129; 128, identifier:priority; 129, call; 129, 130; 129, 131; 130, identifier:sorted; 131, argument_list; 131, 132; 131, 139; 132, call; 132, 133; 132, 138; 133, attribute; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:_triggers; 137, identifier:keys; 138, argument_list; 139, keyword_argument; 139, 140; 139, 141; 140, identifier:reverse; 141, True; 142, block; 142, 143; 143, for_statement; 143, 144; 143, 145; 143, 146; 144, identifier:trigger; 145, identifier:triggers; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 154; 149, attribute; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:self; 152, identifier:_sorted_triggers; 153, identifier:append; 154, argument_list; 154, 155; 155, identifier:trigger; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:sorted; 161, True | def sort(self):
for priority, triggers in self._triggers.items():
self._log.debug('Sorting priority {priority} triggers'.format(priority=priority))
atomics = [trigger for trigger in triggers if trigger.pattern_is_atomic]
wildcards = [trigger for trigger in triggers if not trigger.pattern_is_atomic]
atomics = sorted(atomics, key=lambda trigger: (trigger.pattern_words, trigger.pattern_len), reverse=True)
wildcards = sorted(wildcards, key=lambda trigger: (trigger.pattern_words, trigger.pattern_len),
reverse=True)
self._triggers[priority] = atomics + wildcards
self._sorted_triggers = []
for triggers in [self._triggers[priority] for priority in sorted(self._triggers.keys(), reverse=True)]:
for trigger in triggers:
self._sorted_triggers.append(trigger)
self.sorted = True |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:log_message; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:user; 6, identifier:message; 7, block; 7, 8; 7, 36; 7, 44; 7, 56; 8, if_statement; 8, 9; 8, 14; 8, 21; 9, call; 9, 10; 9, 11; 10, identifier:isinstance; 11, argument_list; 11, 12; 11, 13; 12, identifier:user; 13, identifier:SeshetUser; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:user; 18, attribute; 18, 19; 18, 20; 19, identifier:user; 20, identifier:nick; 21, elif_clause; 21, 22; 21, 28; 22, not_operator; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:isinstance; 25, argument_list; 25, 26; 25, 27; 26, identifier:user; 27, identifier:IRCstr; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:user; 32, call; 32, 33; 32, 34; 33, identifier:IRCstr; 34, argument_list; 34, 35; 35, identifier:user; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:time; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:datetime; 42, identifier:utcnow; 43, argument_list; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:message_log; 50, identifier:append; 51, argument_list; 51, 52; 52, tuple; 52, 53; 52, 54; 52, 55; 53, identifier:time; 54, identifier:user; 55, identifier:message; 56, while_statement; 56, 57; 56, 67; 57, comparison_operator:>; 57, 58; 57, 64; 58, call; 58, 59; 58, 60; 59, identifier:len; 60, argument_list; 60, 61; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:message_log; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:_log_size; 67, block; 67, 68; 68, delete_statement; 68, 69; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:message_log; 73, integer:0 | def log_message(self, user, message):
if isinstance(user, SeshetUser):
user = user.nick
elif not isinstance(user, IRCstr):
user = IRCstr(user)
time = datetime.utcnow()
self.message_log.append((time, user, message))
while len(self.message_log) > self._log_size:
del self.message_log[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:add_item; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 4, identifier:self; 5, identifier:path; 6, identifier:name; 7, default_parameter; 7, 8; 7, 9; 8, identifier:icon; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:url; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:order; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:permission; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:active_regex; 21, None; 22, block; 22, 23; 22, 40; 22, 46; 22, 50; 22, 127; 22, 140; 22, 157; 23, if_statement; 23, 24; 23, 29; 24, comparison_operator:is; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:root_item; 28, None; 29, block; 29, 30; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:root_item; 35, call; 35, 36; 35, 37; 36, identifier:MenuItem; 37, argument_list; 37, 38; 37, 39; 38, string:'ROOT'; 39, string:'ROOT'; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:root_item; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:root_item; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:current_path; 49, string:''; 50, for_statement; 50, 51; 50, 52; 50, 63; 51, identifier:node; 52, subscript; 52, 53; 52, 59; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:path; 56, identifier:split; 57, argument_list; 57, 58; 58, string:'/'; 59, slice; 59, 60; 59, 61; 60, colon; 61, unary_operator:-; 61, 62; 62, integer:1; 63, block; 63, 64; 63, 69; 63, 86; 63, 95; 63, 123; 64, if_statement; 64, 65; 64, 67; 65, not_operator; 65, 66; 66, identifier:node; 67, block; 67, 68; 68, continue_statement; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:current_path; 72, binary_operator:+; 72, 73; 72, 74; 73, string:'/'; 74, call; 74, 75; 74, 84; 75, attribute; 75, 76; 75, 83; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, string:'{}/{}'; 79, identifier:format; 80, argument_list; 80, 81; 80, 82; 81, identifier:current_path; 82, identifier:node; 83, identifier:strip; 84, argument_list; 84, 85; 85, string:'/'; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:new_root; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:root_item; 92, identifier:child_by_code; 93, argument_list; 93, 94; 94, identifier:node; 95, if_statement; 95, 96; 95, 98; 96, not_operator; 96, 97; 97, identifier:new_root; 98, block; 98, 99; 98, 116; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:new_root; 102, call; 102, 103; 102, 104; 103, identifier:MenuItem; 104, argument_list; 104, 105; 104, 106; 105, identifier:current_path; 106, keyword_argument; 106, 107; 106, 108; 107, identifier:name; 108, call; 108, 109; 108, 115; 109, attribute; 109, 110; 109, 114; 110, call; 110, 111; 110, 112; 111, identifier:str; 112, argument_list; 112, 113; 113, identifier:node; 114, identifier:capitalize; 115, argument_list; 116, expression_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:root_item; 120, identifier:add_child; 121, argument_list; 121, 122; 122, identifier:new_root; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:root_item; 126, identifier:new_root; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:new_item; 130, call; 130, 131; 130, 132; 131, identifier:MenuItem; 132, argument_list; 132, 133; 132, 134; 132, 135; 132, 136; 132, 137; 132, 138; 132, 139; 133, identifier:path; 134, identifier:name; 135, identifier:icon; 136, identifier:url; 137, identifier:order; 138, identifier:permission; 139, identifier:active_regex; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:current_item; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:root_item; 146, identifier:child_by_code; 147, argument_list; 147, 148; 148, subscript; 148, 149; 148, 155; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, identifier:path; 152, identifier:split; 153, argument_list; 153, 154; 154, string:'/'; 155, unary_operator:-; 155, 156; 156, integer:1; 157, if_statement; 157, 158; 157, 159; 157, 167; 158, identifier:current_item; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:current_item; 164, identifier:merge; 165, argument_list; 165, 166; 166, identifier:new_item; 167, else_clause; 167, 168; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:root_item; 173, identifier:add_child; 174, argument_list; 174, 175; 175, identifier:new_item | def add_item(self, path, name, icon=None, url=None, order=None, permission=None, active_regex=None):
if self.root_item is None:
self.root_item = MenuItem('ROOT', 'ROOT')
root_item = self.root_item
current_path = ''
for node in path.split('/')[:-1]:
if not node:
continue
current_path = '/' + '{}/{}'.format(current_path, node).strip('/')
new_root = root_item.child_by_code(node)
if not new_root:
new_root = MenuItem(current_path, name=str(node).capitalize())
root_item.add_child(new_root)
root_item = new_root
new_item = MenuItem(path, name, icon, url, order, permission, active_regex)
current_item = root_item.child_by_code(path.split('/')[-1])
if current_item:
current_item.merge(new_item)
else:
root_item.add_child(new_item) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:assist; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:project_path; 6, identifier:source; 7, identifier:position; 8, identifier:filename; 9, block; 9, 10; 10, return_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_call; 15, argument_list; 15, 16; 15, 17; 15, 18; 15, 19; 15, 20; 16, string:'assist'; 17, identifier:project_path; 18, identifier:source; 19, identifier:position; 20, identifier:filename | def assist(self, project_path, source, position, filename):
return self._call('assist', project_path, source, position, filename) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_key_list; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 18; 5, 41; 5, 51; 6, if_statement; 6, 7; 6, 11; 7, not_operator; 7, 8; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:is_baked; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:bake; 17, argument_list; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:key_value_tuple; 21, call; 21, 22; 21, 23; 22, identifier:sorted; 23, argument_list; 23, 24; 23, 31; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:dct; 29, identifier:items; 30, argument_list; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:key; 33, lambda; 33, 34; 33, 36; 34, lambda_parameters; 34, 35; 35, identifier:x; 36, subscript; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:x; 39, integer:1; 40, string:'__abs_time__'; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:skl; 44, list_comprehension; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:k; 47, integer:0; 48, for_in_clause; 48, 49; 48, 50; 49, identifier:k; 50, identifier:key_value_tuple; 51, return_statement; 51, 52; 52, identifier:skl | def sorted_key_list(self):
if not self.is_baked:
self.bake()
key_value_tuple = sorted(self.dct.items(),
key=lambda x: x[1]['__abs_time__'])
skl = [k[0] for k in key_value_tuple]
return skl |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_used_key_frames; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 16; 5, 20; 5, 48; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:skl; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:key_frame_list; 14, identifier:sorted_key_list; 15, argument_list; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:used_key_frames; 19, list:[]; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:kf; 22, identifier:skl; 23, block; 23, 24; 24, if_statement; 24, 25; 24, 32; 25, comparison_operator:in; 25, 26; 25, 27; 26, identifier:kf; 27, subscript; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:dct; 31, string:'keys'; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:used_key_frames; 37, identifier:append; 38, argument_list; 38, 39; 39, tuple; 39, 40; 39, 41; 40, identifier:kf; 41, subscript; 41, 42; 41, 47; 42, subscript; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:dct; 46, string:'keys'; 47, identifier:kf; 48, return_statement; 48, 49; 49, identifier:used_key_frames | def get_used_key_frames(self):
skl = self.key_frame_list.sorted_key_list()
used_key_frames = []
for kf in skl:
if kf in self.dct['keys']:
used_key_frames.append((kf, self.dct['keys'][kf]))
return used_key_frames |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:flds_firstsort; 3, parameters; 3, 4; 4, identifier:d; 5, block; 5, 6; 5, 8; 5, 29; 5, 47; 6, expression_statement; 6, 7; 7, string:'''
Perform a lexsort and return the sort indices and shape as a tuple.
'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:shape; 11, list_comprehension; 11, 12; 11, 23; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:np; 18, identifier:unique; 19, argument_list; 19, 20; 20, subscript; 20, 21; 20, 22; 21, identifier:d; 22, identifier:l; 23, for_in_clause; 23, 24; 23, 25; 24, identifier:l; 25, list:['xs', 'ys', 'zs']; 25, 26; 25, 27; 25, 28; 26, string:'xs'; 27, string:'ys'; 28, string:'zs'; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:si; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:np; 35, identifier:lexsort; 36, argument_list; 36, 37; 37, tuple; 37, 38; 37, 41; 37, 44; 38, subscript; 38, 39; 38, 40; 39, identifier:d; 40, string:'z'; 41, subscript; 41, 42; 41, 43; 42, identifier:d; 43, string:'y'; 44, subscript; 44, 45; 44, 46; 45, identifier:d; 46, string:'x'; 47, return_statement; 47, 48; 48, expression_list; 48, 49; 48, 50; 49, identifier:si; 50, identifier:shape | def flds_firstsort(d):
'''
Perform a lexsort and return the sort indices and shape as a tuple.
'''
shape = [ len( np.unique(d[l]) )
for l in ['xs', 'ys', 'zs'] ];
si = np.lexsort((d['z'],d['y'],d['x']));
return si,shape; |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:flds_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:d; 5, identifier:s; 6, block; 6, 7; 6, 9; 6, 31; 6, 37; 6, 69; 7, expression_statement; 7, 8; 8, string:'''
Sort based on position. Sort with s as a tuple of the sort
indices and shape from first sort.
Parameters:
-----------
d -- the flds/sclr data
s -- (si, shape) sorting and shaping data from firstsort.
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:labels; 12, list_comprehension; 12, 13; 12, 14; 12, 21; 13, identifier:key; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:key; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:d; 19, identifier:keys; 20, argument_list; 21, if_clause; 21, 22; 22, comparison_operator:not; 22, 23; 22, 24; 23, identifier:key; 24, list:['t', 'xs', 'ys', 'zs', 'fd', 'sd']; 24, 25; 24, 26; 24, 27; 24, 28; 24, 29; 24, 30; 25, string:'t'; 26, string:'xs'; 27, string:'ys'; 28, string:'zs'; 29, string:'fd'; 30, string:'sd'; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 36; 33, pattern_list; 33, 34; 33, 35; 34, identifier:si; 35, identifier:shape; 36, identifier:s; 37, for_statement; 37, 38; 37, 39; 37, 40; 38, identifier:l; 39, identifier:labels; 40, block; 40, 41; 40, 56; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 46; 43, subscript; 43, 44; 43, 45; 44, identifier:d; 45, identifier:l; 46, call; 46, 47; 46, 54; 47, attribute; 47, 48; 47, 53; 48, subscript; 48, 49; 48, 52; 49, subscript; 49, 50; 49, 51; 50, identifier:d; 51, identifier:l; 52, identifier:si; 53, identifier:reshape; 54, argument_list; 54, 55; 55, identifier:shape; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:d; 60, identifier:l; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:np; 64, identifier:squeeze; 65, argument_list; 65, 66; 66, subscript; 66, 67; 66, 68; 67, identifier:d; 68, identifier:l; 69, return_statement; 69, 70; 70, identifier:d | def flds_sort(d,s):
'''
Sort based on position. Sort with s as a tuple of the sort
indices and shape from first sort.
Parameters:
-----------
d -- the flds/sclr data
s -- (si, shape) sorting and shaping data from firstsort.
'''
labels = [ key for key in d.keys()
if key not in ['t', 'xs', 'ys', 'zs', 'fd', 'sd'] ];
si,shape = s;
for l in labels:
d[l] = d[l][si].reshape(shape);
d[l] = np.squeeze(d[l]);
return d; |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:read; 3, parameters; 3, 4; 3, 5; 4, identifier:fname; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kw; 7, block; 7, 8; 7, 10; 7, 37; 7, 50; 7, 324; 8, expression_statement; 8, 9; 9, string:'''
Reads an lsp output file and returns a raw dump of data,
sectioned into quantities either as an dictionary or a typed numpy array.
Parameters:
-----------
fname -- filename of thing to read
Keyword Arguments:
------------------
vprint -- Verbose printer. Used in scripts
override -- (type, start) => A tuple of a dump type and a place to start
in the passed file, useful to attempting to read semicorrupted
files.
gzip -- Read as a gzip file.
flds/sclr Specific Arguments:
-----------------------------
var -- list of quantities to be read. For fields, this can consist
of strings that include vector components, e.g., 'Ex'. If
None (default), read all quantities.
keep_edges -- If set to truthy, then don't remove the edges from domains before
concatenation and don't reshape the flds data.
sort -- If not None, sort using these indices, useful for avoiding
resorting. If True and not an ndarray, just sort.
first_sort -- If truthy, sort, and return the sort data for future flds
that should have the same shape.
keep_xs -- Keep the xs's, that is, the grid information. Usually redundant
with x,y,z returned.
return_array -- If set to truthy, then try to return a numpy array with a dtype.
Requires of course that the quantities have the same shape.
'''; 10, if_statement; 10, 11; 10, 22; 11, boolean_operator:and; 11, 12; 11, 17; 12, call; 12, 13; 12, 14; 13, identifier:test; 14, argument_list; 14, 15; 14, 16; 15, identifier:kw; 16, string:'gzip'; 17, comparison_operator:==; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:kw; 20, string:'gzip'; 21, string:'guess'; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:kw; 27, string:'gzip'; 28, comparison_operator:is; 28, 29; 28, 36; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:re; 32, identifier:search; 33, argument_list; 33, 34; 33, 35; 34, string:r'\.gz$'; 35, identifier:fname; 36, None; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:openf; 40, conditional_expression:if; 40, 41; 40, 44; 40, 49; 41, attribute; 41, 42; 41, 43; 42, identifier:gzip; 43, identifier:open; 44, call; 44, 45; 44, 46; 45, identifier:test; 46, argument_list; 46, 47; 46, 48; 47, identifier:kw; 48, string:'gzip'; 49, identifier:open; 50, with_statement; 50, 51; 50, 61; 51, with_clause; 51, 52; 52, with_item; 52, 53; 53, as_pattern; 53, 54; 53, 59; 54, call; 54, 55; 54, 56; 55, identifier:openf; 56, argument_list; 56, 57; 56, 58; 57, identifier:fname; 58, string:'rb'; 59, as_pattern_target; 59, 60; 60, identifier:file; 61, block; 61, 62; 61, 120; 61, 136; 61, 223; 61, 304; 62, if_statement; 62, 63; 62, 68; 62, 111; 63, call; 63, 64; 63, 65; 64, identifier:test; 65, argument_list; 65, 66; 65, 67; 66, identifier:kw; 67, string:'override'; 68, block; 68, 69; 68, 77; 68, 84; 68, 91; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, pattern_list; 71, 72; 71, 73; 72, identifier:dump; 73, identifier:start; 74, subscript; 74, 75; 74, 76; 75, identifier:kw; 76, string:'override'; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:file; 81, identifier:seek; 82, argument_list; 82, 83; 83, identifier:start; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:header; 87, dictionary; 87, 88; 88, pair; 88, 89; 88, 90; 89, string:'dump_type'; 90, identifier:dump; 91, if_statement; 91, 92; 91, 105; 92, boolean_operator:and; 92, 93; 92, 99; 93, not_operator; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:test; 96, argument_list; 96, 97; 96, 98; 97, identifier:kw; 98, string:'var'; 99, comparison_operator:<=; 99, 100; 99, 101; 99, 104; 100, integer:2; 101, subscript; 101, 102; 101, 103; 102, identifier:header; 103, string:'dump_type'; 104, integer:3; 105, block; 105, 106; 106, raise_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:ValueError; 109, argument_list; 109, 110; 110, string:"If you want to force to read as a scalar, you need to supply the quantities"; 111, else_clause; 111, 112; 112, block; 112, 113; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:header; 116, call; 116, 117; 116, 118; 117, identifier:get_header; 118, argument_list; 118, 119; 119, identifier:file; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:vprint; 123, conditional_expression:if; 123, 124; 123, 127; 123, 132; 124, subscript; 124, 125; 124, 126; 125, identifier:kw; 126, string:'vprint'; 127, call; 127, 128; 127, 129; 128, identifier:test; 129, argument_list; 129, 130; 129, 131; 130, identifier:kw; 131, string:'vprint'; 132, lambda; 132, 133; 132, 135; 133, lambda_parameters; 133, 134; 134, identifier:s; 135, None; 136, if_statement; 136, 137; 136, 143; 137, comparison_operator:<=; 137, 138; 137, 139; 137, 142; 138, integer:2; 139, subscript; 139, 140; 139, 141; 140, identifier:header; 141, string:'dump_type'; 142, integer:3; 143, block; 143, 144; 143, 172; 143, 180; 143, 188; 143, 207; 143, 215; 144, if_statement; 144, 145; 144, 151; 144, 164; 145, not_operator; 145, 146; 146, call; 146, 147; 146, 148; 147, identifier:test; 148, argument_list; 148, 149; 148, 150; 149, identifier:kw; 150, string:'var'; 151, block; 151, 152; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:var; 155, list_comprehension; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:i; 158, integer:0; 159, for_in_clause; 159, 160; 159, 161; 160, identifier:i; 161, subscript; 161, 162; 161, 163; 162, identifier:header; 163, string:'quantities'; 164, else_clause; 164, 165; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:var; 169, subscript; 169, 170; 169, 171; 170, identifier:kw; 171, string:'var'; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:keep_edges; 175, call; 175, 176; 175, 177; 176, identifier:test; 177, argument_list; 177, 178; 177, 179; 178, identifier:kw; 179, string:'keep_edges'; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 183; 182, identifier:first_sort; 183, call; 183, 184; 183, 185; 184, identifier:test; 185, argument_list; 185, 186; 185, 187; 186, identifier:kw; 187, string:'first_sort'; 188, if_statement; 188, 189; 188, 194; 188, 201; 189, call; 189, 190; 189, 191; 190, identifier:test; 191, argument_list; 191, 192; 191, 193; 192, identifier:kw; 193, string:'sort'; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:sort; 198, subscript; 198, 199; 198, 200; 199, identifier:kw; 200, string:'sort'; 201, else_clause; 201, 202; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:sort; 206, None; 207, expression_statement; 207, 208; 208, assignment; 208, 209; 208, 210; 209, identifier:keep_xs; 210, call; 210, 211; 210, 212; 211, identifier:test; 212, argument_list; 212, 213; 212, 214; 213, identifier:kw; 214, string:'keep_xs'; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:return_array; 218, call; 218, 219; 218, 220; 219, identifier:test; 220, argument_list; 220, 221; 220, 222; 221, identifier:kw; 222, string:'return_array'; 223, expression_statement; 223, 224; 224, assignment; 224, 225; 224, 226; 225, identifier:readers; 226, dictionary; 226, 227; 226, 235; 226, 260; 226, 288; 226, 296; 227, pair; 227, 228; 227, 229; 228, integer:1; 229, lambda; 229, 230; 230, call; 230, 231; 230, 232; 231, identifier:read_particles; 232, argument_list; 232, 233; 232, 234; 233, identifier:file; 234, identifier:header; 235, pair; 235, 236; 235, 237; 236, integer:2; 237, lambda; 237, 238; 238, call; 238, 239; 238, 240; 239, identifier:read_flds; 240, argument_list; 240, 241; 240, 242; 240, 243; 240, 244; 240, 245; 240, 248; 240, 251; 240, 254; 240, 257; 241, identifier:file; 242, identifier:header; 243, identifier:var; 244, identifier:vprint; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:keep_edges; 247, identifier:keep_edges; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:first_sort; 250, identifier:first_sort; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:sort; 253, identifier:sort; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:keep_xs; 256, identifier:keep_xs; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:return_array; 259, identifier:return_array; 260, pair; 260, 261; 260, 262; 261, integer:3; 262, lambda; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:read_flds; 265, argument_list; 265, 266; 265, 267; 265, 268; 265, 269; 265, 270; 265, 273; 265, 276; 265, 279; 265, 282; 265, 285; 266, identifier:file; 267, identifier:header; 268, identifier:var; 269, identifier:vprint; 270, keyword_argument; 270, 271; 270, 272; 271, identifier:keep_edges; 272, identifier:keep_edges; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:first_sort; 275, identifier:first_sort; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:sort; 278, identifier:sort; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:keep_xs; 281, identifier:keep_xs; 282, keyword_argument; 282, 283; 282, 284; 283, identifier:return_array; 284, identifier:return_array; 285, keyword_argument; 285, 286; 285, 287; 286, identifier:vector; 287, False; 288, pair; 288, 289; 288, 290; 289, integer:6; 290, lambda; 290, 291; 291, call; 291, 292; 291, 293; 292, identifier:read_movie; 293, argument_list; 293, 294; 293, 295; 294, identifier:file; 295, identifier:header; 296, pair; 296, 297; 296, 298; 297, integer:10; 298, lambda; 298, 299; 299, call; 299, 300; 299, 301; 300, identifier:read_pext; 301, argument_list; 301, 302; 301, 303; 302, identifier:file; 303, identifier:header; 304, try_statement; 304, 305; 304, 316; 305, block; 305, 306; 306, expression_statement; 306, 307; 307, assignment; 307, 308; 307, 309; 308, identifier:d; 309, call; 309, 310; 309, 315; 310, subscript; 310, 311; 310, 312; 311, identifier:readers; 312, subscript; 312, 313; 312, 314; 313, identifier:header; 314, string:'dump_type'; 315, argument_list; 316, except_clause; 316, 317; 316, 318; 317, identifier:KeyError; 318, block; 318, 319; 319, raise_statement; 319, 320; 320, call; 320, 321; 320, 322; 321, identifier:NotImplementedError; 322, argument_list; 322, 323; 323, string:"Other file types not implemented yet!"; 324, return_statement; 324, 325; 325, identifier:d | def read(fname,**kw):
'''
Reads an lsp output file and returns a raw dump of data,
sectioned into quantities either as an dictionary or a typed numpy array.
Parameters:
-----------
fname -- filename of thing to read
Keyword Arguments:
------------------
vprint -- Verbose printer. Used in scripts
override -- (type, start) => A tuple of a dump type and a place to start
in the passed file, useful to attempting to read semicorrupted
files.
gzip -- Read as a gzip file.
flds/sclr Specific Arguments:
-----------------------------
var -- list of quantities to be read. For fields, this can consist
of strings that include vector components, e.g., 'Ex'. If
None (default), read all quantities.
keep_edges -- If set to truthy, then don't remove the edges from domains before
concatenation and don't reshape the flds data.
sort -- If not None, sort using these indices, useful for avoiding
resorting. If True and not an ndarray, just sort.
first_sort -- If truthy, sort, and return the sort data for future flds
that should have the same shape.
keep_xs -- Keep the xs's, that is, the grid information. Usually redundant
with x,y,z returned.
return_array -- If set to truthy, then try to return a numpy array with a dtype.
Requires of course that the quantities have the same shape.
'''
if test(kw,'gzip') and kw['gzip'] == 'guess':
kw['gzip'] = re.search(r'\.gz$', fname) is not None;
openf = gzip.open if test(kw, 'gzip') else open;
with openf(fname,'rb') as file:
if test(kw,'override'):
dump, start = kw['override'];
file.seek(start);
header = {'dump_type': dump};
if not test(kw, 'var') and 2 <= header['dump_type'] <= 3 :
raise ValueError(
"If you want to force to read as a scalar, you need to supply the quantities"
);
else:
header = get_header(file);
vprint = kw['vprint'] if test(kw, 'vprint') else lambda s: None;
if 2 <= header['dump_type'] <= 3 :
if not test(kw, 'var'):
var=[i[0] for i in header['quantities']];
else:
var=kw['var'];
keep_edges = test(kw, 'keep_edges');
first_sort = test(kw, 'first_sort');
if test(kw,'sort'):
sort = kw['sort']
else:
sort = None;
keep_xs = test(kw, 'keep_xs');
return_array = test(kw, 'return_array');
readers = {
1: lambda: read_particles(file, header),
2: lambda: read_flds(
file,header,var,vprint,
keep_edges=keep_edges,
first_sort=first_sort,
sort=sort,
keep_xs=keep_xs,
return_array=return_array),
3: lambda: read_flds(
file,header,var, vprint,
keep_edges=keep_edges,
first_sort=first_sort,
sort=sort,
keep_xs=keep_xs,
return_array=return_array,
vector=False),
6: lambda: read_movie(file, header),
10:lambda: read_pext(file,header)
};
try:
d = readers[header['dump_type']]();
except KeyError:
raise NotImplementedError("Other file types not implemented yet!");
return d; |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_region_nt_counts; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:region; 5, identifier:bam; 6, default_parameter; 6, 7; 6, 8; 7, identifier:stranded; 8, False; 9, block; 9, 10; 9, 28; 9, 182; 9, 191; 9, 218; 9, 233; 9, 468; 10, if_statement; 10, 11; 10, 17; 11, comparison_operator:==; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:type; 14, argument_list; 14, 15; 15, identifier:bam; 16, identifier:str; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:bam; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:pysam; 24, identifier:AlignmentFile; 25, argument_list; 25, 26; 25, 27; 26, identifier:bam; 27, string:'rb'; 28, if_statement; 28, 29; 28, 35; 28, 122; 29, comparison_operator:is; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:type; 32, argument_list; 32, 33; 33, identifier:region; 34, identifier:str; 35, block; 35, 36; 35, 43; 35, 74; 35, 81; 35, 88; 35, 108; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:r; 39, call; 39, 40; 39, 41; 40, identifier:parse_region; 41, argument_list; 41, 42; 42, identifier:region; 43, if_statement; 43, 44; 43, 50; 43, 58; 44, comparison_operator:==; 44, 45; 44, 49; 45, call; 45, 46; 45, 47; 46, identifier:len; 47, argument_list; 47, 48; 48, identifier:r; 49, integer:3; 50, block; 50, 51; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 57; 53, pattern_list; 53, 54; 53, 55; 53, 56; 54, identifier:chrom; 55, identifier:start; 56, identifier:end; 57, identifier:r; 58, elif_clause; 58, 59; 58, 65; 59, comparison_operator:==; 59, 60; 59, 64; 60, call; 60, 61; 60, 62; 61, identifier:len; 62, argument_list; 62, 63; 63, identifier:r; 64, integer:4; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 73; 68, pattern_list; 68, 69; 68, 70; 68, 71; 68, 72; 69, identifier:chrom; 70, identifier:start; 71, identifier:end; 72, identifier:strand; 73, identifier:r; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:start; 77, call; 77, 78; 77, 79; 78, identifier:int; 79, argument_list; 79, 80; 80, identifier:start; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:end; 84, call; 84, 85; 84, 86; 85, identifier:int; 86, argument_list; 86, 87; 87, identifier:end; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:ind; 91, list_comprehension; 91, 92; 91, 99; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, string:'{}:{}'; 95, identifier:format; 96, argument_list; 96, 97; 96, 98; 97, identifier:chrom; 98, identifier:x; 99, for_in_clause; 99, 100; 99, 101; 100, identifier:x; 101, call; 101, 102; 101, 103; 102, identifier:range; 103, argument_list; 103, 104; 103, 105; 104, identifier:start; 105, binary_operator:+; 105, 106; 105, 107; 106, identifier:end; 107, integer:1; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:pp; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:bam; 114, identifier:pileup; 115, argument_list; 115, 116; 115, 119; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:region; 118, identifier:region; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:truncate; 121, True; 122, elif_clause; 122, 123; 122, 132; 123, comparison_operator:is; 123, 124; 123, 128; 124, call; 124, 125; 124, 126; 125, identifier:type; 126, argument_list; 126, 127; 127, identifier:region; 128, parenthesized_expression; 128, 129; 129, boolean_operator:or; 129, 130; 129, 131; 130, identifier:list; 131, identifier:tuple; 132, block; 132, 133; 132, 140; 132, 168; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 139; 135, pattern_list; 135, 136; 135, 137; 135, 138; 136, identifier:chrom; 137, identifier:start; 138, identifier:end; 139, identifier:region; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:ind; 143, list_comprehension; 143, 144; 143, 151; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, string:'{}:{}'; 147, identifier:format; 148, argument_list; 148, 149; 148, 150; 149, identifier:chrom; 150, identifier:x; 151, for_in_clause; 151, 152; 151, 153; 152, identifier:x; 153, call; 153, 154; 153, 155; 154, identifier:range; 155, argument_list; 155, 156; 155, 162; 156, binary_operator:+; 156, 157; 156, 161; 157, call; 157, 158; 157, 159; 158, identifier:int; 159, argument_list; 159, 160; 160, identifier:start; 161, integer:1; 162, binary_operator:+; 162, 163; 162, 167; 163, call; 163, 164; 163, 165; 164, identifier:int; 165, argument_list; 165, 166; 166, identifier:end; 167, integer:1; 168, expression_statement; 168, 169; 169, assignment; 169, 170; 169, 171; 170, identifier:pp; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:bam; 174, identifier:pileup; 175, argument_list; 175, 176; 175, 177; 175, 178; 175, 179; 176, identifier:chrom; 177, identifier:start; 178, identifier:end; 179, keyword_argument; 179, 180; 179, 181; 180, identifier:truncate; 181, True; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:cols; 185, list:['A', 'T', 'C', 'G', 'N']; 185, 186; 185, 187; 185, 188; 185, 189; 185, 190; 186, string:'A'; 187, string:'T'; 188, string:'C'; 189, string:'G'; 190, string:'N'; 191, if_statement; 191, 192; 191, 193; 192, identifier:stranded; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:cols; 197, binary_operator:+; 197, 198; 197, 208; 198, list_comprehension; 198, 199; 198, 205; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, string:'{}+'; 202, identifier:format; 203, argument_list; 203, 204; 204, identifier:x; 205, for_in_clause; 205, 206; 205, 207; 206, identifier:x; 207, identifier:cols; 208, list_comprehension; 208, 209; 208, 215; 209, call; 209, 210; 209, 213; 210, attribute; 210, 211; 210, 212; 211, string:'{}-'; 212, identifier:format; 213, argument_list; 213, 214; 214, identifier:x; 215, for_in_clause; 215, 216; 215, 217; 216, identifier:x; 217, identifier:cols; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:counts; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:pd; 224, identifier:DataFrame; 225, argument_list; 225, 226; 225, 227; 225, 230; 226, integer:0; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:index; 229, identifier:ind; 230, keyword_argument; 230, 231; 230, 232; 231, identifier:columns; 232, identifier:cols; 233, for_statement; 233, 234; 233, 235; 233, 236; 234, identifier:pc; 235, identifier:pp; 236, block; 236, 237; 236, 245; 236, 249; 236, 253; 236, 257; 236, 261; 236, 323; 236, 335; 236, 347; 236, 365; 236, 384; 236, 392; 236, 396; 236, 409; 236, 422; 236, 434; 236, 447; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 240; 239, identifier:pos; 240, binary_operator:+; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:pc; 243, identifier:reference_pos; 244, integer:1; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:r1_qnames; 248, list:[]; 249, expression_statement; 249, 250; 250, assignment; 250, 251; 250, 252; 251, identifier:r1_nts; 252, list:[]; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 255, identifier:r2_qnames; 256, list:[]; 257, expression_statement; 257, 258; 258, assignment; 258, 259; 258, 260; 259, identifier:r2_nts; 260, list:[]; 261, for_statement; 261, 262; 261, 263; 261, 266; 262, identifier:pr; 263, attribute; 263, 264; 263, 265; 264, identifier:pc; 265, identifier:pileups; 266, block; 266, 267; 266, 279; 266, 291; 266, 302; 267, expression_statement; 267, 268; 268, assignment; 268, 269; 268, 270; 269, identifier:qnames; 270, subscript; 270, 271; 270, 274; 271, list:[r1_qnames, r2_qnames]; 271, 272; 271, 273; 272, identifier:r1_qnames; 273, identifier:r2_qnames; 274, attribute; 274, 275; 274, 278; 275, attribute; 275, 276; 275, 277; 276, identifier:pr; 277, identifier:alignment; 278, identifier:is_read2; 279, expression_statement; 279, 280; 280, assignment; 280, 281; 280, 282; 281, identifier:nts; 282, subscript; 282, 283; 282, 286; 283, list:[r1_nts, r2_nts]; 283, 284; 283, 285; 284, identifier:r1_nts; 285, identifier:r2_nts; 286, attribute; 286, 287; 286, 290; 287, attribute; 287, 288; 287, 289; 288, identifier:pr; 289, identifier:alignment; 290, identifier:is_read2; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:nt; 294, call; 294, 295; 294, 296; 295, identifier:_pos_nt; 296, argument_list; 296, 297; 296, 298; 296, 301; 297, identifier:pr; 298, attribute; 298, 299; 298, 300; 299, identifier:pc; 300, identifier:reference_pos; 301, identifier:stranded; 302, if_statement; 302, 303; 302, 304; 303, identifier:nt; 304, block; 304, 305; 304, 316; 305, expression_statement; 305, 306; 306, call; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:qnames; 309, identifier:append; 310, argument_list; 310, 311; 311, attribute; 311, 312; 311, 315; 312, attribute; 312, 313; 312, 314; 313, identifier:pr; 314, identifier:alignment; 315, identifier:qname; 316, expression_statement; 316, 317; 317, call; 317, 318; 317, 321; 318, attribute; 318, 319; 318, 320; 319, identifier:nts; 320, identifier:append; 321, argument_list; 321, 322; 322, identifier:nt; 323, expression_statement; 323, 324; 324, assignment; 324, 325; 324, 326; 325, identifier:r1; 326, call; 326, 327; 326, 330; 327, attribute; 327, 328; 327, 329; 328, identifier:pd; 329, identifier:Series; 330, argument_list; 330, 331; 330, 332; 331, identifier:r1_nts; 332, keyword_argument; 332, 333; 332, 334; 333, identifier:index; 334, identifier:r1_qnames; 335, expression_statement; 335, 336; 336, assignment; 336, 337; 336, 338; 337, identifier:r2; 338, call; 338, 339; 338, 342; 339, attribute; 339, 340; 339, 341; 340, identifier:pd; 341, identifier:Series; 342, argument_list; 342, 343; 342, 344; 343, identifier:r2_nts; 344, keyword_argument; 344, 345; 344, 346; 345, identifier:index; 346, identifier:r2_qnames; 347, expression_statement; 347, 348; 348, assignment; 348, 349; 348, 350; 349, identifier:df; 350, attribute; 350, 351; 350, 364; 351, call; 351, 352; 351, 355; 352, attribute; 352, 353; 352, 354; 353, identifier:pd; 354, identifier:DataFrame; 355, argument_list; 355, 356; 355, 359; 356, list:[r1, r2]; 356, 357; 356, 358; 357, identifier:r1; 358, identifier:r2; 359, keyword_argument; 359, 360; 359, 361; 360, identifier:index; 361, list:['R1', 'R2']; 361, 362; 361, 363; 362, string:'R1'; 363, string:'R2'; 364, identifier:T; 365, expression_statement; 365, 366; 366, assignment; 366, 367; 366, 368; 367, identifier:singles; 368, subscript; 368, 369; 368, 370; 369, identifier:df; 370, comparison_operator:==; 370, 371; 370, 383; 371, call; 371, 372; 371, 379; 372, attribute; 372, 373; 372, 378; 373, call; 373, 374; 373, 377; 374, attribute; 374, 375; 374, 376; 375, identifier:df; 376, identifier:isnull; 377, argument_list; 378, identifier:sum; 379, argument_list; 379, 380; 380, keyword_argument; 380, 381; 380, 382; 381, identifier:axis; 382, integer:1; 383, integer:1; 384, expression_statement; 384, 385; 385, assignment; 385, 386; 385, 387; 386, identifier:doubles; 387, call; 387, 388; 387, 391; 388, attribute; 388, 389; 388, 390; 389, identifier:df; 390, identifier:dropna; 391, argument_list; 392, expression_statement; 392, 393; 393, assignment; 393, 394; 393, 395; 394, identifier:vcs; 395, list:[]; 396, expression_statement; 396, 397; 397, call; 397, 398; 397, 401; 398, attribute; 398, 399; 398, 400; 399, identifier:vcs; 400, identifier:append; 401, argument_list; 401, 402; 402, call; 402, 403; 402, 408; 403, attribute; 403, 404; 403, 407; 404, subscript; 404, 405; 404, 406; 405, identifier:singles; 406, string:'R1'; 407, identifier:value_counts; 408, argument_list; 409, expression_statement; 409, 410; 410, call; 410, 411; 410, 414; 411, attribute; 411, 412; 411, 413; 412, identifier:vcs; 413, identifier:append; 414, argument_list; 414, 415; 415, call; 415, 416; 415, 421; 416, attribute; 416, 417; 416, 420; 417, subscript; 417, 418; 417, 419; 418, identifier:singles; 419, string:'R2'; 420, identifier:value_counts; 421, argument_list; 422, expression_statement; 422, 423; 423, assignment; 423, 424; 423, 425; 424, identifier:doubles; 425, subscript; 425, 426; 425, 427; 426, identifier:doubles; 427, comparison_operator:==; 427, 428; 427, 431; 428, attribute; 428, 429; 428, 430; 429, identifier:doubles; 430, identifier:R1; 431, attribute; 431, 432; 431, 433; 432, identifier:doubles; 433, identifier:R2; 434, expression_statement; 434, 435; 435, call; 435, 436; 435, 439; 436, attribute; 436, 437; 436, 438; 437, identifier:vcs; 438, identifier:append; 439, argument_list; 439, 440; 440, call; 440, 441; 440, 446; 441, attribute; 441, 442; 441, 445; 442, attribute; 442, 443; 442, 444; 443, identifier:doubles; 444, identifier:R1; 445, identifier:value_counts; 446, argument_list; 447, for_statement; 447, 448; 447, 449; 447, 450; 448, identifier:vc; 449, identifier:vcs; 450, block; 450, 451; 451, expression_statement; 451, 452; 452, augmented_assignment:+=; 452, 453; 452, 467; 453, subscript; 453, 454; 453, 457; 453, 464; 454, attribute; 454, 455; 454, 456; 455, identifier:counts; 456, identifier:ix; 457, call; 457, 458; 457, 461; 458, attribute; 458, 459; 458, 460; 459, string:'{}:{}'; 460, identifier:format; 461, argument_list; 461, 462; 461, 463; 462, identifier:chrom; 463, identifier:pos; 464, attribute; 464, 465; 464, 466; 465, identifier:vc; 466, identifier:index; 467, identifier:vc; 468, return_statement; 468, 469; 469, identifier:counts | def get_region_nt_counts(region, bam, stranded=False):
if type(bam) == str:
bam = pysam.AlignmentFile(bam, 'rb')
if type(region) is str:
r = parse_region(region)
if len(r) == 3:
chrom, start, end = r
elif len(r) == 4:
chrom, start, end, strand = r
start = int(start)
end = int(end)
ind = ['{}:{}'.format(chrom, x) for
x in range(start, end + 1)]
pp = bam.pileup(region=region, truncate=True)
elif type(region) is (list or tuple):
chrom, start, end = region
ind = ['{}:{}'.format(chrom, x) for
x in range(int(start) + 1, int(end) + 1)]
pp = bam.pileup(chrom, start, end, truncate=True)
cols = ['A', 'T', 'C', 'G', 'N']
if stranded:
cols = ['{}+'.format(x) for x in cols] + ['{}-'.format(x) for x in cols]
counts = pd.DataFrame(0, index=ind, columns=cols)
for pc in pp:
pos = pc.reference_pos + 1
r1_qnames = []
r1_nts = []
r2_qnames = []
r2_nts = []
for pr in pc.pileups:
qnames = [r1_qnames, r2_qnames][pr.alignment.is_read2]
nts = [r1_nts, r2_nts][pr.alignment.is_read2]
nt = _pos_nt(pr, pc.reference_pos, stranded)
if nt:
qnames.append(pr.alignment.qname)
nts.append(nt)
r1 = pd.Series(r1_nts, index=r1_qnames)
r2 = pd.Series(r2_nts, index=r2_qnames)
df = pd.DataFrame([r1, r2], index=['R1', 'R2']).T
singles = df[df.isnull().sum(axis=1) == 1]
doubles = df.dropna()
vcs = []
vcs.append(singles['R1'].value_counts())
vcs.append(singles['R2'].value_counts())
doubles = doubles[doubles.R1 == doubles.R2]
vcs.append(doubles.R1.value_counts())
for vc in vcs:
counts.ix['{}:{}'.format(chrom, pos), vc.index] += vc
return counts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:nt_counts; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:bam; 5, identifier:positions; 6, default_parameter; 6, 7; 6, 8; 7, identifier:stranded; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:vcf; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:bed; 14, False; 15, block; 15, 16; 15, 84; 15, 154; 15, 158; 15, 198; 15, 207; 16, if_statement; 16, 17; 16, 22; 17, boolean_operator:and; 17, 18; 17, 20; 18, not_operator; 18, 19; 19, identifier:bed; 20, not_operator; 20, 21; 21, identifier:vcf; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 34; 23, 43; 23, 57; 23, 71; 24, comparison_operator:==; 24, 25; 24, 29; 25, call; 25, 26; 25, 27; 26, identifier:type; 27, argument_list; 27, 28; 28, identifier:positions; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:pbt; 32, identifier:bedtool; 33, identifier:BedTool; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:df; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:positions; 41, identifier:to_dataframe; 42, argument_list; 43, elif_clause; 43, 44; 43, 52; 44, comparison_operator:==; 44, 45; 44, 51; 45, subscript; 45, 46; 45, 47; 46, identifier:positions; 47, slice; 47, 48; 47, 50; 48, unary_operator:-; 48, 49; 49, integer:4; 50, colon; 51, string:'.bed'; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:bed; 56, True; 57, elif_clause; 57, 58; 57, 66; 58, comparison_operator:==; 58, 59; 58, 65; 59, subscript; 59, 60; 59, 61; 60, identifier:positions; 61, slice; 61, 62; 61, 64; 62, unary_operator:-; 62, 63; 63, integer:4; 64, colon; 65, string:'.vcf'; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:vcf; 70, True; 71, else_clause; 71, 72; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 80; 75, attribute; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:sys; 78, identifier:stderr; 79, identifier:write; 80, argument_list; 80, 81; 81, concatenated_string; 81, 82; 81, 83; 82, string:'Positions must be BedTool, bed file, or vcf '; 83, string:'file.\n'; 84, if_statement; 84, 85; 84, 86; 84, 100; 85, identifier:bed; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:df; 90, call; 90, 91; 90, 99; 91, attribute; 91, 92; 91, 98; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:pbt; 95, identifier:BedTool; 96, argument_list; 96, 97; 97, identifier:positions; 98, identifier:to_dataframe; 99, argument_list; 100, elif_clause; 100, 101; 100, 102; 101, identifier:vcf; 102, block; 102, 103; 102, 108; 102, 115; 102, 128; 102, 136; 102, 146; 103, import_from_statement; 103, 104; 103, 106; 104, dotted_name; 104, 105; 105, identifier:variants; 106, dotted_name; 106, 107; 107, identifier:vcf_as_df; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:tdf; 111, call; 111, 112; 111, 113; 112, identifier:vcf_as_df; 113, argument_list; 113, 114; 114, identifier:positions; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:df; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:pd; 121, identifier:DataFrame; 122, argument_list; 122, 123; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:index; 125, attribute; 125, 126; 125, 127; 126, identifier:tdf; 127, identifier:index; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:df; 132, string:'chrom'; 133, attribute; 133, 134; 133, 135; 134, identifier:tdf; 135, identifier:CHROM; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:df; 140, string:'start'; 141, binary_operator:-; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:tdf; 144, identifier:POS; 145, integer:1; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:df; 150, string:'end'; 151, attribute; 151, 152; 151, 153; 152, identifier:tdf; 153, identifier:POS; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:res; 157, list:[]; 158, for_statement; 158, 159; 158, 160; 158, 163; 159, identifier:i; 160, attribute; 160, 161; 160, 162; 161, identifier:df; 162, identifier:index; 163, block; 163, 164; 163, 186; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:region; 167, list:[df.ix[i, 'chrom'], df.ix[i, 'start'], df.ix[i, 'end']]; 167, 168; 167, 174; 167, 180; 168, subscript; 168, 169; 168, 172; 168, 173; 169, attribute; 169, 170; 169, 171; 170, identifier:df; 171, identifier:ix; 172, identifier:i; 173, string:'chrom'; 174, subscript; 174, 175; 174, 178; 174, 179; 175, attribute; 175, 176; 175, 177; 176, identifier:df; 177, identifier:ix; 178, identifier:i; 179, string:'start'; 180, subscript; 180, 181; 180, 184; 180, 185; 181, attribute; 181, 182; 181, 183; 182, identifier:df; 183, identifier:ix; 184, identifier:i; 185, string:'end'; 186, expression_statement; 186, 187; 187, call; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:res; 190, identifier:append; 191, argument_list; 191, 192; 192, call; 192, 193; 192, 194; 193, identifier:get_region_nt_counts; 194, argument_list; 194, 195; 194, 196; 194, 197; 195, identifier:region; 196, identifier:bam; 197, identifier:stranded; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:res; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:pd; 204, identifier:concat; 205, argument_list; 205, 206; 206, identifier:res; 207, return_statement; 207, 208; 208, identifier:res | def nt_counts(bam, positions, stranded=False, vcf=False, bed=False):
if not bed and not vcf:
if type(positions) == pbt.bedtool.BedTool:
df = positions.to_dataframe()
elif positions[-4:] == '.bed':
bed = True
elif positions[-4:] == '.vcf':
vcf = True
else:
sys.stderr.write('Positions must be BedTool, bed file, or vcf '
'file.\n')
if bed:
df = pbt.BedTool(positions).to_dataframe()
elif vcf:
from variants import vcf_as_df
tdf = vcf_as_df(positions)
df = pd.DataFrame(index=tdf.index)
df['chrom'] = tdf.CHROM
df['start'] = tdf.POS - 1
df['end'] = tdf.POS
res = []
for i in df.index:
region = [df.ix[i, 'chrom'], df.ix[i, 'start'], df.ix[i, 'end']]
res.append(get_region_nt_counts(region, bam, stranded))
res = pd.concat(res)
return res |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add_host; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:host; 6, default_parameter; 6, 7; 6, 8; 7, identifier:group_names; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:host_vars; 11, None; 12, block; 12, 13; 12, 20; 12, 27; 12, 33; 12, 43; 12, 53; 12, 70; 12, 80; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:gnames; 16, conditional_expression:if; 16, 17; 16, 18; 16, 19; 17, identifier:group_names; 18, identifier:group_names; 19, list:[]; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:hvars; 23, conditional_expression:if; 23, 24; 23, 25; 23, 26; 24, identifier:host_vars; 25, identifier:host_vars; 26, dictionary; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:gnames; 31, identifier:sort; 32, argument_list; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 42; 35, subscript; 35, 36; 35, 37; 36, identifier:hvars; 37, attribute; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:A; 40, identifier:server; 41, identifier:GROUP_NAMES; 42, identifier:gnames; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 52; 45, subscript; 45, 46; 45, 47; 46, identifier:hvars; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:A; 50, identifier:server; 51, identifier:INV_NAME; 52, identifier:host; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 62; 55, subscript; 55, 56; 55, 57; 56, identifier:hvars; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:A; 60, identifier:server; 61, identifier:INV_NAME_SHORT; 62, subscript; 62, 63; 62, 69; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:host; 66, identifier:split; 67, argument_list; 67, 68; 68, string:'.'; 69, integer:0; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:groups_and_vars; 76, identifier:merge; 77, argument_list; 77, 78; 77, 79; 78, identifier:host; 79, identifier:hvars; 80, for_statement; 80, 81; 80, 82; 80, 83; 81, identifier:gname; 82, identifier:group_names; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:groups_and_vars; 90, identifier:append; 91, argument_list; 91, 92; 91, 93; 92, identifier:gname; 93, identifier:host | def add_host(self, host, group_names=None, host_vars=None):
gnames = group_names if group_names else []
hvars = host_vars if host_vars else {}
gnames.sort()
hvars[A.server.GROUP_NAMES] = gnames
hvars[A.server.INV_NAME] = host
hvars[A.server.INV_NAME_SHORT] = host.split('.')[0]
self.groups_and_vars.merge(host, hvars)
for gname in group_names:
self.groups_and_vars.append(gname, host) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:beds_to_boolean; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:beds; 5, default_parameter; 5, 6; 5, 7; 6, identifier:ref; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:beds_sorted; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:ref_sorted; 13, False; 14, dictionary_splat_pattern; 14, 15; 15, identifier:kwargs; 16, block; 16, 17; 16, 26; 16, 30; 16, 92; 16, 100; 16, 141; 16, 145; 16, 169; 16, 184; 16, 247; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:beds; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:copy; 23, identifier:deepcopy; 24, argument_list; 24, 25; 25, identifier:beds; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:fns; 29, list:[]; 30, for_statement; 30, 31; 30, 34; 30, 38; 31, pattern_list; 31, 32; 31, 33; 32, identifier:i; 33, identifier:v; 34, call; 34, 35; 34, 36; 35, identifier:enumerate; 36, argument_list; 36, 37; 37, identifier:beds; 38, block; 38, 39; 38, 76; 39, if_statement; 39, 40; 39, 46; 39, 65; 40, comparison_operator:==; 40, 41; 40, 45; 41, call; 41, 42; 41, 43; 42, identifier:type; 43, argument_list; 43, 44; 44, identifier:v; 45, identifier:str; 46, block; 46, 47; 46, 54; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:fns; 51, identifier:append; 52, argument_list; 52, 53; 53, identifier:v; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:beds; 58, identifier:i; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:pbt; 62, identifier:BedTool; 63, argument_list; 63, 64; 64, identifier:v; 65, else_clause; 65, 66; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:fns; 71, identifier:append; 72, argument_list; 72, 73; 73, attribute; 73, 74; 73, 75; 74, identifier:v; 75, identifier:fn; 76, if_statement; 76, 77; 76, 79; 77, not_operator; 77, 78; 78, identifier:beds_sorted; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, subscript; 82, 83; 82, 84; 83, identifier:beds; 84, identifier:i; 85, call; 85, 86; 85, 91; 86, attribute; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:beds; 89, identifier:i; 90, identifier:sort; 91, argument_list; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:names; 95, call; 95, 96; 95, 97; 96, identifier:_sample_names; 97, argument_list; 97, 98; 97, 99; 98, identifier:fns; 99, identifier:kwargs; 100, if_statement; 100, 101; 100, 102; 100, 132; 101, identifier:ref; 102, block; 102, 103; 102, 120; 103, if_statement; 103, 104; 103, 110; 104, comparison_operator:==; 104, 105; 104, 109; 105, call; 105, 106; 105, 107; 106, identifier:type; 107, argument_list; 107, 108; 108, identifier:ref; 109, identifier:str; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:ref; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:pbt; 117, identifier:BedTool; 118, argument_list; 118, 119; 119, identifier:ref; 120, if_statement; 120, 121; 120, 123; 121, not_operator; 121, 122; 122, identifier:ref_sorted; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:ref; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:ref; 130, identifier:sort; 131, argument_list; 132, else_clause; 132, 133; 133, block; 133, 134; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:ref; 137, call; 137, 138; 137, 139; 138, identifier:combine; 139, argument_list; 139, 140; 140, identifier:beds; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:ind; 144, list:[]; 145, for_statement; 145, 146; 145, 147; 145, 148; 146, identifier:r; 147, identifier:ref; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:ind; 153, identifier:append; 154, argument_list; 154, 155; 155, call; 155, 156; 155, 159; 156, attribute; 156, 157; 156, 158; 157, string:'{}:{}-{}'; 158, identifier:format; 159, argument_list; 159, 160; 159, 163; 159, 166; 160, attribute; 160, 161; 160, 162; 161, identifier:r; 162, identifier:chrom; 163, attribute; 163, 164; 163, 165; 164, identifier:r; 165, identifier:start; 166, attribute; 166, 167; 166, 168; 167, identifier:r; 168, identifier:stop; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:bdf; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:pd; 175, identifier:DataFrame; 176, argument_list; 176, 177; 176, 178; 176, 181; 177, integer:0; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:index; 180, identifier:ind; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:columns; 183, identifier:names; 184, for_statement; 184, 185; 184, 188; 184, 192; 185, pattern_list; 185, 186; 185, 187; 186, identifier:i; 187, identifier:bed; 188, call; 188, 189; 188, 190; 189, identifier:enumerate; 190, argument_list; 190, 191; 191, identifier:beds; 192, block; 192, 193; 192, 208; 192, 212; 192, 236; 193, expression_statement; 193, 194; 194, assignment; 194, 195; 194, 196; 195, identifier:res; 196, call; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:ref; 199, identifier:intersect; 200, argument_list; 200, 201; 200, 202; 200, 205; 201, identifier:bed; 202, keyword_argument; 202, 203; 202, 204; 203, identifier:sorted; 204, True; 205, keyword_argument; 205, 206; 205, 207; 206, identifier:wa; 207, True; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:ind; 211, list:[]; 212, for_statement; 212, 213; 212, 214; 212, 215; 213, identifier:r; 214, identifier:res; 215, block; 215, 216; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:ind; 220, identifier:append; 221, argument_list; 221, 222; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, string:'{}:{}-{}'; 225, identifier:format; 226, argument_list; 226, 227; 226, 230; 226, 233; 227, attribute; 227, 228; 227, 229; 228, identifier:r; 229, identifier:chrom; 230, attribute; 230, 231; 230, 232; 231, identifier:r; 232, identifier:start; 233, attribute; 233, 234; 233, 235; 234, identifier:r; 235, identifier:stop; 236, expression_statement; 236, 237; 237, assignment; 237, 238; 237, 246; 238, subscript; 238, 239; 238, 242; 238, 243; 239, attribute; 239, 240; 239, 241; 240, identifier:bdf; 241, identifier:ix; 242, identifier:ind; 243, subscript; 243, 244; 243, 245; 244, identifier:names; 245, identifier:i; 246, integer:1; 247, return_statement; 247, 248; 248, identifier:bdf | def beds_to_boolean(beds, ref=None, beds_sorted=False, ref_sorted=False,
**kwargs):
beds = copy.deepcopy(beds)
fns = []
for i,v in enumerate(beds):
if type(v) == str:
fns.append(v)
beds[i] = pbt.BedTool(v)
else:
fns.append(v.fn)
if not beds_sorted:
beds[i] = beds[i].sort()
names = _sample_names(fns, kwargs)
if ref:
if type(ref) == str:
ref = pbt.BedTool(ref)
if not ref_sorted:
ref = ref.sort()
else:
ref = combine(beds)
ind = []
for r in ref:
ind.append('{}:{}-{}'.format(r.chrom, r.start, r.stop))
bdf = pd.DataFrame(0, index=ind, columns=names)
for i,bed in enumerate(beds):
res = ref.intersect(bed, sorted=True, wa=True)
ind = []
for r in res:
ind.append('{}:{}-{}'.format(r.chrom,
r.start,
r.stop))
bdf.ix[ind, names[i]] = 1
return bdf |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:combine; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:beds; 5, default_parameter; 5, 6; 5, 7; 6, identifier:beds_sorted; 7, False; 8, default_parameter; 8, 9; 8, 10; 9, identifier:postmerge; 10, True; 11, block; 11, 12; 11, 21; 11, 65; 11, 85; 11, 93; 11, 104; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:beds; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:copy; 18, identifier:deepcopy; 19, argument_list; 19, 20; 20, identifier:beds; 21, for_statement; 21, 22; 21, 25; 21, 29; 22, pattern_list; 22, 23; 22, 24; 23, identifier:i; 24, identifier:v; 25, call; 25, 26; 25, 27; 26, identifier:enumerate; 27, argument_list; 27, 28; 28, identifier:beds; 29, block; 29, 30; 29, 49; 30, if_statement; 30, 31; 30, 37; 31, comparison_operator:==; 31, 32; 31, 36; 32, call; 32, 33; 32, 34; 33, identifier:type; 34, argument_list; 34, 35; 35, identifier:v; 36, identifier:str; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 43; 40, subscript; 40, 41; 40, 42; 41, identifier:beds; 42, identifier:i; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:pbt; 46, identifier:BedTool; 47, argument_list; 47, 48; 48, identifier:v; 49, if_statement; 49, 50; 49, 52; 50, not_operator; 50, 51; 51, identifier:beds_sorted; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:beds; 57, identifier:i; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, subscript; 60, 61; 60, 62; 61, identifier:beds; 62, identifier:i; 63, identifier:sort; 64, argument_list; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:out; 68, call; 68, 69; 68, 70; 69, identifier:reduce; 70, argument_list; 70, 71; 70, 84; 71, lambda; 71, 72; 71, 75; 72, lambda_parameters; 72, 73; 72, 74; 73, identifier:x; 74, identifier:y; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:x; 78, identifier:cat; 79, argument_list; 79, 80; 79, 81; 80, identifier:y; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:postmerge; 83, False; 84, identifier:beds; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:out; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:out; 91, identifier:sort; 92, argument_list; 93, if_statement; 93, 94; 93, 95; 94, identifier:postmerge; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 99; 98, identifier:out; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:out; 102, identifier:merge; 103, argument_list; 104, return_statement; 104, 105; 105, identifier:out | def combine(beds, beds_sorted=False, postmerge=True):
beds = copy.deepcopy(beds)
for i,v in enumerate(beds):
if type(v) == str:
beds[i] = pbt.BedTool(v)
if not beds_sorted:
beds[i] = beds[i].sort()
out = reduce(lambda x,y : x.cat(y, postmerge=False), beds)
out = out.sort()
if postmerge:
out = out.merge()
return out |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sanitize_config_loglevel; 3, parameters; 3, 4; 4, identifier:level; 5, block; 5, 6; 5, 8; 5, 31; 5, 35; 5, 53; 5, 64; 6, expression_statement; 6, 7; 7, string:'''
Kinda sorta backport of loglevel sanitization for Python 2.6.
'''; 8, if_statement; 8, 9; 8, 28; 9, boolean_operator:or; 9, 10; 9, 21; 10, comparison_operator:!=; 10, 11; 10, 18; 11, subscript; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:sys; 14, identifier:version_info; 15, slice; 15, 16; 15, 17; 16, colon; 17, integer:2; 18, tuple; 18, 19; 18, 20; 19, integer:2; 20, integer:6; 21, call; 21, 22; 21, 23; 22, identifier:isinstance; 23, argument_list; 23, 24; 23, 25; 24, identifier:level; 25, tuple; 25, 26; 25, 27; 26, identifier:int; 27, identifier:long; 28, block; 28, 29; 29, return_statement; 29, 30; 30, identifier:level; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:lvl; 34, None; 35, if_statement; 35, 36; 35, 41; 36, call; 36, 37; 36, 38; 37, identifier:isinstance; 38, argument_list; 38, 39; 38, 40; 39, identifier:level; 40, identifier:basestring; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:lvl; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:logging; 49, identifier:_levelNames; 50, identifier:get; 51, argument_list; 51, 52; 52, identifier:level; 53, if_statement; 53, 54; 53, 56; 54, not_operator; 54, 55; 55, identifier:lvl; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:ValueError; 60, argument_list; 60, 61; 61, binary_operator:%; 61, 62; 61, 63; 62, string:'Invalid log level, %s'; 63, identifier:level; 64, return_statement; 64, 65; 65, identifier:lvl | def sanitize_config_loglevel(level):
'''
Kinda sorta backport of loglevel sanitization for Python 2.6.
'''
if sys.version_info[:2] != (2, 6) or isinstance(level, (int, long)):
return level
lvl = None
if isinstance(level, basestring):
lvl = logging._levelNames.get(level)
if not lvl:
raise ValueError('Invalid log level, %s' % level)
return lvl |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:prt_js; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:js; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_keys; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:indent; 10, integer:4; 11, block; 11, 12; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:print; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:js2str; 18, argument_list; 18, 19; 18, 20; 18, 21; 19, identifier:js; 20, identifier:sort_keys; 21, identifier:indent | def prt_js(js, sort_keys=True, indent=4):
print(js2str(js, sort_keys, indent)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:find_field_names; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:fields; 5, default_parameter; 5, 6; 5, 7; 6, identifier:model; 7, identifier:DEFAULT_MODEL; 8, default_parameter; 8, 9; 8, 10; 9, identifier:app; 10, identifier:DEFAULT_APP; 11, default_parameter; 11, 12; 11, 13; 12, identifier:score_cutoff; 13, integer:50; 14, default_parameter; 14, 15; 14, 16; 15, identifier:pad_with_none; 16, False; 17, block; 17, 18; 17, 27; 17, 35; 17, 45; 17, 49; 17, 96; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:fields; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:util; 24, identifier:listify; 25, argument_list; 25, 26; 26, identifier:fields; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:model; 30, call; 30, 31; 30, 32; 31, identifier:get_model; 32, argument_list; 32, 33; 32, 34; 33, identifier:model; 34, identifier:app; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:available_field_names; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:model; 42, identifier:_meta; 43, identifier:get_all_field_names; 44, argument_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:matched_fields; 48, list:[]; 49, for_statement; 49, 50; 49, 51; 49, 52; 50, identifier:field_name; 51, identifier:fields; 52, block; 52, 53; 52, 66; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:match; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:fuzzy; 59, identifier:extractOne; 60, argument_list; 60, 61; 60, 65; 61, call; 61, 62; 61, 63; 62, identifier:str; 63, argument_list; 63, 64; 64, identifier:field_name; 65, identifier:available_field_names; 66, if_statement; 66, 67; 66, 80; 66, 88; 67, boolean_operator:and; 67, 68; 67, 75; 68, boolean_operator:and; 68, 69; 68, 70; 69, identifier:match; 70, comparison_operator:is; 70, 71; 70, 74; 71, subscript; 71, 72; 71, 73; 72, identifier:match; 73, integer:1; 74, None; 75, comparison_operator:>=; 75, 76; 75, 79; 76, subscript; 76, 77; 76, 78; 77, identifier:match; 78, integer:1; 79, identifier:score_cutoff; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, augmented_assignment:+=; 82, 83; 82, 84; 83, identifier:matched_fields; 84, list:[match[0]]; 84, 85; 85, subscript; 85, 86; 85, 87; 86, identifier:match; 87, integer:0; 88, elif_clause; 88, 89; 88, 90; 89, identifier:pad_with_none; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, augmented_assignment:+=; 92, 93; 92, 94; 93, identifier:matched_fields; 94, list:[None]; 94, 95; 95, None; 96, return_statement; 96, 97; 97, identifier:matched_fields | def find_field_names(fields, model=DEFAULT_MODEL, app=DEFAULT_APP, score_cutoff=50, pad_with_none=False):
fields = util.listify(fields)
model = get_model(model, app)
available_field_names = model._meta.get_all_field_names()
matched_fields = []
for field_name in fields:
match = fuzzy.extractOne(str(field_name), available_field_names)
if match and match[1] is not None and match[1] >= score_cutoff:
matched_fields += [match[0]]
elif pad_with_none:
matched_fields += [None]
return matched_fields |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 34; 2, function_name:lagged_in_date; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 3, 31; 4, default_parameter; 4, 5; 4, 6; 5, identifier:x; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:y; 9, None; 10, default_parameter; 10, 11; 10, 12; 11, identifier:filter_dict; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:model; 15, string:'WikiItem'; 16, default_parameter; 16, 17; 16, 18; 17, identifier:app; 18, identifier:DEFAULT_APP; 19, default_parameter; 19, 20; 19, 21; 20, identifier:sort; 21, True; 22, default_parameter; 22, 23; 22, 24; 23, identifier:limit; 24, integer:30000; 25, default_parameter; 25, 26; 25, 27; 26, identifier:lag; 27, integer:1; 28, default_parameter; 28, 29; 28, 30; 29, identifier:pad; 30, integer:0; 31, default_parameter; 31, 32; 31, 33; 32, identifier:truncate; 33, True; 34, block; 34, 35; 34, 44; 34, 87; 34, 161; 34, 235; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:lag; 38, call; 38, 39; 38, 40; 39, identifier:int; 40, argument_list; 40, 41; 41, boolean_operator:or; 41, 42; 41, 43; 42, identifier:lag; 43, integer:0; 44, if_statement; 44, 45; 44, 56; 45, boolean_operator:and; 45, 46; 45, 51; 46, call; 46, 47; 46, 48; 47, identifier:isinstance; 48, argument_list; 48, 49; 48, 50; 49, identifier:x; 50, identifier:basestring; 51, call; 51, 52; 51, 53; 52, identifier:isinstance; 53, argument_list; 53, 54; 53, 55; 54, identifier:y; 55, identifier:basestring; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:x; 61, identifier:y; 62, call; 62, 63; 62, 64; 63, identifier:sequence_from_filter_spec; 64, argument_list; 64, 65; 64, 74; 64, 75; 64, 78; 64, 81; 64, 84; 65, list:[find_synonymous_field(x), find_synonymous_field(y)]; 65, 66; 65, 70; 66, call; 66, 67; 66, 68; 67, identifier:find_synonymous_field; 68, argument_list; 68, 69; 69, identifier:x; 70, call; 70, 71; 70, 72; 71, identifier:find_synonymous_field; 72, argument_list; 72, 73; 73, identifier:y; 74, identifier:filter_dict; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:model; 77, identifier:model; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:app; 80, identifier:app; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:sort; 83, identifier:sort; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:limit; 86, identifier:limit; 87, if_statement; 87, 88; 87, 99; 88, boolean_operator:and; 88, 89; 88, 90; 89, identifier:y; 90, comparison_operator:==; 90, 91; 90, 95; 91, call; 91, 92; 91, 93; 92, identifier:len; 93, argument_list; 93, 94; 94, identifier:y; 95, call; 95, 96; 95, 97; 96, identifier:len; 97, argument_list; 97, 98; 98, identifier:x; 99, block; 99, 100; 99, 145; 100, if_statement; 100, 101; 100, 102; 101, identifier:sort; 102, block; 102, 103; 102, 125; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:xy; 106, call; 106, 107; 106, 108; 107, identifier:sorted; 108, argument_list; 108, 109; 108, 114; 109, call; 109, 110; 109, 111; 110, identifier:zip; 111, argument_list; 111, 112; 111, 113; 112, identifier:x; 113, identifier:y; 114, keyword_argument; 114, 115; 114, 116; 115, identifier:reverse; 116, call; 116, 117; 116, 118; 117, identifier:bool; 118, argument_list; 118, 119; 119, comparison_operator:<; 119, 120; 119, 124; 120, call; 120, 121; 120, 122; 121, identifier:int; 122, argument_list; 122, 123; 123, identifier:sort; 124, integer:0; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 130; 127, pattern_list; 127, 128; 127, 129; 128, identifier:x; 129, identifier:y; 130, expression_list; 130, 131; 130, 138; 131, list_comprehension; 131, 132; 131, 133; 132, identifier:col1; 133, for_in_clause; 133, 134; 133, 137; 134, pattern_list; 134, 135; 134, 136; 135, identifier:col1; 136, identifier:col2; 137, identifier:xy; 138, list_comprehension; 138, 139; 138, 140; 139, identifier:col2; 140, for_in_clause; 140, 141; 140, 144; 141, pattern_list; 141, 142; 141, 143; 142, identifier:col1; 143, identifier:col2; 144, identifier:xy; 145, return_statement; 145, 146; 146, expression_list; 146, 147; 146, 148; 147, identifier:x; 148, call; 148, 149; 148, 150; 149, identifier:lagged_seq; 150, argument_list; 150, 151; 150, 152; 150, 155; 150, 158; 151, identifier:y; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:lag; 154, identifier:lag; 155, keyword_argument; 155, 156; 155, 157; 156, identifier:pad; 157, identifier:pad; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:truncate; 160, identifier:truncate; 161, if_statement; 161, 162; 161, 181; 162, boolean_operator:and; 162, 163; 162, 169; 163, boolean_operator:and; 163, 164; 163, 165; 164, identifier:x; 165, call; 165, 166; 165, 167; 166, identifier:len; 167, argument_list; 167, 168; 168, identifier:x; 169, comparison_operator:==; 169, 170; 169, 171; 169, 175; 170, integer:2; 171, call; 171, 172; 171, 173; 172, identifier:len; 173, argument_list; 173, 174; 174, identifier:x; 175, call; 175, 176; 175, 177; 176, identifier:len; 177, argument_list; 177, 178; 178, subscript; 178, 179; 178, 180; 179, identifier:x; 180, integer:0; 181, block; 181, 182; 181, 206; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 187; 184, pattern_list; 184, 185; 184, 186; 185, identifier:x; 186, identifier:y; 187, expression_list; 187, 188; 187, 191; 188, subscript; 188, 189; 188, 190; 189, identifier:x; 190, integer:0; 191, call; 191, 192; 191, 193; 192, identifier:lagged_seq; 193, argument_list; 193, 194; 193, 197; 193, 200; 193, 203; 194, subscript; 194, 195; 194, 196; 195, identifier:x; 196, integer:1; 197, keyword_argument; 197, 198; 197, 199; 198, identifier:lag; 199, identifier:lag; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:pad; 202, identifier:pad; 203, keyword_argument; 203, 204; 203, 205; 204, identifier:truncate; 205, identifier:truncate; 206, if_statement; 206, 207; 206, 208; 207, identifier:truncate; 208, block; 208, 209; 208, 212; 209, print_statement; 209, 210; 209, 211; 210, identifier:truncate; 211, identifier:lag; 212, if_statement; 212, 213; 212, 216; 212, 225; 213, comparison_operator:>=; 213, 214; 213, 215; 214, identifier:lag; 215, integer:0; 216, block; 216, 217; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:x; 220, subscript; 220, 221; 220, 222; 221, identifier:x; 222, slice; 222, 223; 222, 224; 223, identifier:lag; 224, colon; 225, else_clause; 225, 226; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:x; 230, subscript; 230, 231; 230, 232; 231, identifier:x; 232, slice; 232, 233; 232, 234; 233, colon; 234, identifier:lag; 235, return_statement; 235, 236; 236, expression_list; 236, 237; 236, 238; 237, identifier:x; 238, identifier:y | def lagged_in_date(x=None, y=None, filter_dict=None, model='WikiItem', app=DEFAULT_APP, sort=True, limit=30000, lag=1, pad=0, truncate=True):
lag = int(lag or 0)
if isinstance(x, basestring) and isinstance(y, basestring):
x, y = sequence_from_filter_spec([find_synonymous_field(x), find_synonymous_field(y)], filter_dict, model=model,
app=app, sort=sort, limit=limit)
if y and len(y) == len(x):
if sort:
xy = sorted(zip(x,y), reverse=bool(int(sort) < 0))
x, y = [col1 for col1, col2 in xy], [col2 for col1, col2 in xy]
return x, lagged_seq(y, lag=lag, pad=pad, truncate=truncate)
if x and len(x) and 2 == len(x) <= len(x[0]):
x, y = x[0], lagged_seq(x[1], lag=lag, pad=pad, truncate=truncate)
if truncate:
print truncate, lag
if lag >= 0:
x = x[lag:]
else:
x = x[:lag]
return x, y |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:percentile; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:sorted_list; 5, identifier:percent; 6, default_parameter; 6, 7; 6, 8; 7, identifier:key; 8, lambda; 8, 9; 8, 11; 9, lambda_parameters; 9, 10; 10, identifier:x; 11, identifier:x; 12, block; 12, 13; 12, 19; 12, 32; 12, 44; 12, 51; 12, 57; 12, 85; 13, if_statement; 13, 14; 13, 16; 14, not_operator; 14, 15; 15, identifier:sorted_list; 16, block; 16, 17; 17, return_statement; 17, 18; 18, None; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:==; 20, 21; 20, 22; 21, identifier:percent; 22, integer:1; 23, block; 23, 24; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:float; 27, argument_list; 27, 28; 28, subscript; 28, 29; 28, 30; 29, identifier:sorted_list; 30, unary_operator:-; 30, 31; 31, integer:1; 32, if_statement; 32, 33; 32, 36; 33, comparison_operator:==; 33, 34; 33, 35; 34, identifier:percent; 35, integer:0; 36, block; 36, 37; 37, return_statement; 37, 38; 38, call; 38, 39; 38, 40; 39, identifier:float; 40, argument_list; 40, 41; 41, subscript; 41, 42; 41, 43; 42, identifier:sorted_list; 43, integer:0; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:n; 47, call; 47, 48; 47, 49; 48, identifier:len; 49, argument_list; 49, 50; 50, identifier:sorted_list; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:i; 54, binary_operator:*; 54, 55; 54, 56; 55, identifier:percent; 56, identifier:n; 57, if_statement; 57, 58; 57, 64; 58, comparison_operator:==; 58, 59; 58, 63; 59, call; 59, 60; 59, 61; 60, identifier:ceil; 61, argument_list; 61, 62; 62, identifier:i; 63, identifier:i; 64, block; 64, 65; 64, 72; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:i; 68, call; 68, 69; 68, 70; 69, identifier:int; 70, argument_list; 70, 71; 71, identifier:i; 72, return_statement; 72, 73; 73, binary_operator:/; 73, 74; 73, 84; 74, parenthesized_expression; 74, 75; 75, binary_operator:+; 75, 76; 75, 81; 76, subscript; 76, 77; 76, 78; 77, identifier:sorted_list; 78, binary_operator:-; 78, 79; 78, 80; 79, identifier:i; 80, integer:1; 81, subscript; 81, 82; 81, 83; 82, identifier:sorted_list; 83, identifier:i; 84, integer:2; 85, return_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:float; 88, argument_list; 88, 89; 89, subscript; 89, 90; 89, 91; 90, identifier:sorted_list; 91, binary_operator:-; 91, 92; 91, 96; 92, call; 92, 93; 92, 94; 93, identifier:ceil; 94, argument_list; 94, 95; 95, identifier:i; 96, integer:1 | def percentile(sorted_list, percent, key=lambda x: x):
if not sorted_list:
return None
if percent == 1:
return float(sorted_list[-1])
if percent == 0:
return float(sorted_list[0])
n = len(sorted_list)
i = percent * n
if ceil(i) == i:
i = int(i)
return (sorted_list[i-1] + sorted_list[i]) / 2
return float(sorted_list[ceil(i)-1]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:tags; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 21; 5, 30; 5, 43; 5, 56; 5, 64; 6, expression_statement; 6, 7; 7, string:'''Return a list of all tags that have this semantic tag, sorted by name.
:rtype: list of ckan.model.tag.Tag objects
'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:q; 11, call; 11, 12; 11, 17; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:meta; 15, identifier:Session; 16, identifier:query; 17, argument_list; 17, 18; 18, attribute; 18, 19; 18, 20; 19, identifier:_tag; 20, identifier:Tag; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:q; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:q; 27, identifier:join; 28, argument_list; 28, 29; 29, identifier:TagSemanticTag; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:q; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:q; 36, identifier:filter_by; 37, argument_list; 37, 38; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:tag_id; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:id; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:q; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:q; 49, identifier:order_by; 50, argument_list; 50, 51; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:_tag; 54, identifier:Tag; 55, identifier:name; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:tags; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:q; 62, identifier:all; 63, argument_list; 64, return_statement; 64, 65; 65, identifier:tags | def tags(self):
'''Return a list of all tags that have this semantic tag, sorted by name.
:rtype: list of ckan.model.tag.Tag objects
'''
q = meta.Session.query(_tag.Tag)
q = q.join(TagSemanticTag)
q = q.filter_by(tag_id=self.id)
q = q.order_by(_tag.Tag.name)
tags = q.all()
return tags |
0, module; 0, 1; 1, ERROR; 1, 2; 1, 178; 1, 195; 1, 203; 1, 213; 2, function_definition; 2, 3; 2, 4; 2, 10; 3, function_name:make_feature_bed; 4, parameters; 4, 5; 4, 6; 4, 7; 5, identifier:gtf; 6, identifier:feature; 7, default_parameter; 7, 8; 7, 9; 8, identifier:out; 9, None; 10, block; 10, 11; 10, 15; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:bed_lines; 14, list:[]; 15, with_statement; 15, 16; 15, 25; 16, with_clause; 16, 17; 17, with_item; 17, 18; 18, as_pattern; 18, 19; 18, 23; 19, call; 19, 20; 19, 21; 20, identifier:open; 21, argument_list; 21, 22; 22, identifier:gtf; 23, as_pattern_target; 23, 24; 24, identifier:f; 25, block; 25, 26; 25, 38; 25, 166; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:line; 29, call; 29, 30; 29, 37; 30, attribute; 30, 31; 30, 36; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:f; 34, identifier:readline; 35, argument_list; 36, identifier:strip; 37, argument_list; 38, while_statement; 38, 39; 38, 42; 38, 49; 39, comparison_operator:!=; 39, 40; 39, 41; 40, identifier:line; 41, string:''; 42, ERROR; 42, 43; 42, 46; 42, 47; 43, subscript; 43, 44; 43, 45; 44, identifier:line; 45, integer:0; 46, string:'
line = line.split('; 47, ERROR; 47, 48; 48, escape_sequence:\t; 49, block; 49, 50; 50, if_statement; 50, 51; 50, 56; 51, comparison_operator:==; 51, 52; 51, 55; 52, subscript; 52, 53; 52, 54; 53, identifier:line; 54, integer:2; 55, identifier:feature; 56, block; 56, 57; 56, 63; 56, 77; 56, 83; 56, 140; 56, 146; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:chrom; 60, subscript; 60, 61; 60, 62; 61, identifier:line; 62, integer:0; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:start; 66, call; 66, 67; 66, 68; 67, identifier:str; 68, argument_list; 68, 69; 69, binary_operator:-; 69, 70; 69, 76; 70, call; 70, 71; 70, 72; 71, identifier:int; 72, argument_list; 72, 73; 73, subscript; 73, 74; 73, 75; 74, identifier:line; 75, integer:3; 76, integer:1; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:end; 80, subscript; 80, 81; 80, 82; 81, identifier:line; 82, integer:4; 83, if_statement; 83, 84; 83, 87; 83, 113; 84, comparison_operator:==; 84, 85; 84, 86; 85, identifier:feature; 86, string:'gene'; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:name; 91, call; 91, 92; 91, 111; 92, attribute; 92, 93; 92, 110; 93, subscript; 93, 94; 93, 109; 94, call; 94, 95; 94, 107; 95, attribute; 95, 96; 95, 106; 96, subscript; 96, 97; 96, 105; 97, call; 97, 98; 97, 103; 98, attribute; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:line; 101, integer:8; 102, identifier:split; 103, argument_list; 103, 104; 104, string:';'; 105, integer:0; 106, identifier:split; 107, argument_list; 107, 108; 108, string:' '; 109, integer:1; 110, identifier:strip; 111, argument_list; 111, 112; 112, string:'"'; 113, else_clause; 113, 114; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:name; 118, call; 118, 119; 118, 138; 119, attribute; 119, 120; 119, 137; 120, subscript; 120, 121; 120, 136; 121, call; 121, 122; 121, 134; 122, attribute; 122, 123; 122, 133; 123, subscript; 123, 124; 123, 132; 124, call; 124, 125; 124, 130; 125, attribute; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:line; 128, integer:8; 129, identifier:split; 130, argument_list; 130, 131; 131, string:';'; 132, integer:1; 133, identifier:split; 134, argument_list; 134, 135; 135, string:' '; 136, integer:2; 137, identifier:strip; 138, argument_list; 138, 139; 139, string:'"'; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 143; 142, identifier:strand; 143, subscript; 143, 144; 143, 145; 144, identifier:line; 145, integer:6; 146, expression_statement; 146, 147; 147, call; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:bed_lines; 150, identifier:append; 151, argument_list; 151, 152; 152, binary_operator:+; 152, 153; 152, 165; 153, call; 153, 154; 153, 157; 154, attribute; 154, 155; 154, 156; 155, string:'\t'; 156, identifier:join; 157, argument_list; 157, 158; 158, list:[chrom, start, end, name, '.',
strand]; 158, 159; 158, 160; 158, 161; 158, 162; 158, 163; 158, 164; 159, identifier:chrom; 160, identifier:start; 161, identifier:end; 162, identifier:name; 163, string:'.'; 164, identifier:strand; 165, string:'\n'; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:line; 169, call; 169, 170; 169, 177; 170, attribute; 170, 171; 170, 176; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:f; 174, identifier:readline; 175, argument_list; 176, identifier:strip; 177, argument_list; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:bt; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:pbt; 184, identifier:BedTool; 185, argument_list; 185, 186; 185, 192; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, string:''; 189, identifier:join; 190, argument_list; 190, 191; 191, identifier:bed_lines; 192, keyword_argument; 192, 193; 192, 194; 193, identifier:from_string; 194, True; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 198; 197, identifier:bt; 198, call; 198, 199; 198, 202; 199, attribute; 199, 200; 199, 201; 200, identifier:bt; 201, identifier:sort; 202, argument_list; 203, if_statement; 203, 204; 203, 205; 204, identifier:out; 205, block; 205, 206; 206, expression_statement; 206, 207; 207, call; 207, 208; 207, 211; 208, attribute; 208, 209; 208, 210; 209, identifier:bt; 210, identifier:saveas; 211, argument_list; 211, 212; 212, identifier:out; 213, return_statement; 213, 214; 214, identifier:bt | def make_feature_bed(gtf, feature, out=None):
bed_lines = []
with open(gtf) as f:
line = f.readline().strip()
while line != '':
if line[0] != '
line = line.split('\t')
if line[2] == feature:
chrom = line[0]
start = str(int(line[3]) - 1)
end = line[4]
if feature == 'gene':
name = line[8].split(';')[0].split(' ')[1].strip('"')
else:
name = line[8].split(';')[1].split(' ')[2].strip('"')
strand = line[6]
bed_lines.append('\t'.join([chrom, start, end, name, '.',
strand]) + '\n')
line = f.readline().strip()
bt = pbt.BedTool(''.join(bed_lines), from_string=True)
bt = bt.sort()
if out:
bt.saveas(out)
return bt |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:filter; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:order_by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:limit; 10, integer:0; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 14, with_statement; 14, 15; 14, 23; 15, with_clause; 15, 16; 16, with_item; 16, 17; 17, as_pattern; 17, 18; 17, 21; 18, call; 18, 19; 18, 20; 19, identifier:rconnect; 20, argument_list; 21, as_pattern_target; 21, 22; 22, identifier:conn; 23, block; 23, 24; 23, 34; 24, if_statement; 24, 25; 24, 31; 25, comparison_operator:==; 25, 26; 25, 30; 26, call; 26, 27; 26, 28; 27, identifier:len; 28, argument_list; 28, 29; 29, identifier:kwargs; 30, integer:0; 31, block; 31, 32; 32, raise_statement; 32, 33; 33, identifier:ValueError; 34, try_statement; 34, 35; 34, 99; 34, 113; 34, 127; 35, block; 35, 36; 35, 44; 35, 53; 35, 68; 35, 83; 35, 90; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:query; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_base; 43, argument_list; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:query; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:query; 50, identifier:filter; 51, argument_list; 51, 52; 52, identifier:kwargs; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:order_by; 56, None; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:query; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_order_by; 65, argument_list; 65, 66; 65, 67; 66, identifier:query; 67, identifier:order_by; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:>; 69, 70; 69, 71; 70, identifier:limit; 71, integer:0; 72, block; 72, 73; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:query; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:_limit; 80, argument_list; 80, 81; 80, 82; 81, identifier:query; 82, identifier:limit; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:log; 87, identifier:debug; 88, argument_list; 88, 89; 89, identifier:query; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:rv; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:query; 96, identifier:run; 97, argument_list; 97, 98; 98, identifier:conn; 99, except_clause; 99, 100; 99, 104; 100, as_pattern; 100, 101; 100, 102; 101, identifier:ReqlOpFailedError; 102, as_pattern_target; 102, 103; 103, identifier:e; 104, block; 104, 105; 104, 112; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:log; 109, identifier:warn; 110, argument_list; 110, 111; 111, identifier:e; 112, raise_statement; 113, except_clause; 113, 114; 113, 118; 114, as_pattern; 114, 115; 114, 116; 115, identifier:Exception; 116, as_pattern_target; 116, 117; 117, identifier:e; 118, block; 118, 119; 118, 126; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:log; 123, identifier:warn; 124, argument_list; 124, 125; 125, identifier:e; 126, raise_statement; 127, else_clause; 127, 128; 128, block; 128, 129; 128, 142; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:data; 132, list_comprehension; 132, 133; 132, 139; 133, call; 133, 134; 133, 137; 134, attribute; 134, 135; 134, 136; 135, identifier:self; 136, identifier:_model; 137, argument_list; 137, 138; 138, identifier:_; 139, for_in_clause; 139, 140; 139, 141; 140, identifier:_; 141, identifier:rv; 142, return_statement; 142, 143; 143, identifier:data | def filter(self, order_by=None, limit=0, **kwargs):
with rconnect() as conn:
if len(kwargs) == 0:
raise ValueError
try:
query = self._base()
query = query.filter(kwargs)
if order_by is not None:
query = self._order_by(query, order_by)
if limit > 0:
query = self._limit(query, limit)
log.debug(query)
rv = query.run(conn)
except ReqlOpFailedError as e:
log.warn(e)
raise
except Exception as e:
log.warn(e)
raise
else:
data = [self._model(_) for _ in rv]
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:all; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:order_by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:limit; 10, integer:0; 11, block; 11, 12; 12, with_statement; 12, 13; 12, 21; 13, with_clause; 13, 14; 14, with_item; 14, 15; 15, as_pattern; 15, 16; 15, 19; 16, call; 16, 17; 16, 18; 17, identifier:rconnect; 18, argument_list; 19, as_pattern_target; 19, 20; 20, identifier:conn; 21, block; 21, 22; 22, try_statement; 22, 23; 22, 78; 22, 92; 23, block; 23, 24; 23, 32; 23, 47; 23, 62; 23, 69; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:query; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_base; 31, argument_list; 32, if_statement; 32, 33; 32, 36; 33, comparison_operator:is; 33, 34; 33, 35; 34, identifier:order_by; 35, None; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:query; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_order_by; 44, argument_list; 44, 45; 44, 46; 45, identifier:query; 46, identifier:order_by; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:>; 48, 49; 48, 50; 49, identifier:limit; 50, integer:0; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:query; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_limit; 59, argument_list; 59, 60; 59, 61; 60, identifier:query; 61, identifier:limit; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:log; 66, identifier:debug; 67, argument_list; 67, 68; 68, identifier:query; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:rv; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:query; 75, identifier:run; 76, argument_list; 76, 77; 77, identifier:conn; 78, except_clause; 78, 79; 78, 83; 79, as_pattern; 79, 80; 79, 81; 80, identifier:Exception; 81, as_pattern_target; 81, 82; 82, identifier:e; 83, block; 83, 84; 83, 91; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:log; 88, identifier:warn; 89, argument_list; 89, 90; 90, identifier:e; 91, raise_statement; 92, else_clause; 92, 93; 93, block; 93, 94; 93, 107; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:data; 97, list_comprehension; 97, 98; 97, 104; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:self; 101, identifier:_model; 102, argument_list; 102, 103; 103, identifier:_; 104, for_in_clause; 104, 105; 104, 106; 105, identifier:_; 106, identifier:rv; 107, return_statement; 107, 108; 108, identifier:data | def all(self, order_by=None, limit=0):
with rconnect() as conn:
try:
query = self._base()
if order_by is not None:
query = self._order_by(query, order_by)
if limit > 0:
query = self._limit(query, limit)
log.debug(query)
rv = query.run(conn)
except Exception as e:
log.warn(e)
raise
else:
data = [self._model(_) for _ in rv]
return data |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:safe_dump_js; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:js; 5, identifier:abspath; 6, default_parameter; 6, 7; 6, 8; 7, identifier:fastmode; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:compress; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:enable_verbose; 14, True; 15, block; 15, 16; 15, 23; 15, 29; 15, 47; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:abspath; 19, call; 19, 20; 19, 21; 20, identifier:str; 21, argument_list; 21, 22; 22, identifier:abspath; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:temp_abspath; 26, binary_operator:%; 26, 27; 26, 28; 27, string:"%s.tmp"; 28, identifier:abspath; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:dump_js; 32, argument_list; 32, 33; 32, 34; 32, 35; 32, 38; 32, 41; 32, 44; 33, identifier:js; 34, identifier:temp_abspath; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:fastmode; 37, identifier:fastmode; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:replace; 40, True; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:compress; 43, identifier:compress; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:enable_verbose; 46, identifier:enable_verbose; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:shutil; 51, identifier:move; 52, argument_list; 52, 53; 52, 54; 53, identifier:temp_abspath; 54, identifier:abspath | def safe_dump_js(js, abspath,
fastmode=False, compress=False, enable_verbose=True):
abspath = str(abspath)
temp_abspath = "%s.tmp" % abspath
dump_js(js, temp_abspath, fastmode=fastmode,
replace=True, compress=compress, enable_verbose=enable_verbose)
shutil.move(temp_abspath, abspath) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:all_selectors; 3, parameters; 3, 4; 3, 5; 4, identifier:Class; 5, identifier:fn; 6, block; 6, 7; 6, 11; 6, 22; 6, 31; 6, 64; 6, 77; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:selectors; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:cssparser; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:cssutils; 17, identifier:CSSParser; 18, argument_list; 18, 19; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:validate; 21, False; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:css; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:cssparser; 28, identifier:parseFile; 29, argument_list; 29, 30; 30, identifier:fn; 31, for_statement; 31, 32; 31, 33; 31, 51; 32, identifier:rule; 33, list_comprehension; 33, 34; 33, 35; 33, 40; 34, identifier:r; 35, for_in_clause; 35, 36; 35, 37; 36, identifier:r; 37, attribute; 37, 38; 37, 39; 38, identifier:css; 39, identifier:cssRules; 40, if_clause; 40, 41; 41, comparison_operator:==; 41, 42; 41, 46; 42, call; 42, 43; 42, 44; 43, identifier:type; 44, argument_list; 44, 45; 45, identifier:r; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:cssutils; 49, identifier:css; 50, identifier:CSSStyleRule; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, augmented_assignment:+=; 53, 54; 53, 55; 54, identifier:selectors; 55, list_comprehension; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:sel; 58, identifier:selectorText; 59, for_in_clause; 59, 60; 59, 61; 60, identifier:sel; 61, attribute; 61, 62; 61, 63; 62, identifier:rule; 63, identifier:selectorList; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:selectors; 67, call; 67, 68; 67, 69; 68, identifier:sorted; 69, argument_list; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:list; 72, argument_list; 72, 73; 73, call; 73, 74; 73, 75; 74, identifier:set; 75, argument_list; 75, 76; 76, identifier:selectors; 77, return_statement; 77, 78; 78, identifier:selectors | def all_selectors(Class, fn):
selectors = []
cssparser = cssutils.CSSParser(validate=False)
css = cssparser.parseFile(fn)
for rule in [r for r in css.cssRules if type(r)==cssutils.css.CSSStyleRule]:
selectors += [sel.selectorText for sel in rule.selectorList]
selectors = sorted(list(set(selectors)))
return selectors |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:create_logger; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:args; 7, dictionary; 8, block; 8, 9; 8, 18; 8, 26; 8, 46; 8, 56; 8, 65; 8, 78; 8, 85; 8, 92; 8, 138; 8, 156; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:logger; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:logging; 15, identifier:getLogger; 16, argument_list; 16, 17; 17, string:"SmartFileSorter"; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:logger; 22, identifier:level; 23, attribute; 23, 24; 23, 25; 24, identifier:logging; 25, identifier:INFO; 26, if_statement; 26, 27; 26, 36; 27, boolean_operator:and; 27, 28; 27, 31; 28, comparison_operator:in; 28, 29; 28, 30; 29, string:'--debug'; 30, identifier:args; 31, comparison_operator:is; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:args; 34, string:'--debug'; 35, True; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:logger; 41, identifier:setLevel; 42, argument_list; 42, 43; 43, attribute; 43, 44; 43, 45; 44, identifier:logging; 45, identifier:DEBUG; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:file_log_formatter; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:logging; 52, identifier:Formatter; 53, argument_list; 53, 54; 53, 55; 54, string:'%(asctime)s %(name)s %(levelname)s %(message)s'; 55, string:'%Y-%m-%d %H:%M:%S'; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:console_log_formatter; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:logging; 62, identifier:Formatter; 63, argument_list; 63, 64; 64, string:'%(message)s'; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:stdout_stream; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:logging; 71, identifier:StreamHandler; 72, argument_list; 72, 73; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:stream; 75, attribute; 75, 76; 75, 77; 76, identifier:sys; 77, identifier:stdout; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:stdout_stream; 82, identifier:setFormatter; 83, argument_list; 83, 84; 84, identifier:console_log_formatter; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:logger; 89, identifier:addHandler; 90, argument_list; 90, 91; 91, identifier:stdout_stream; 92, if_statement; 92, 93; 92, 102; 93, boolean_operator:and; 93, 94; 93, 97; 94, comparison_operator:in; 94, 95; 94, 96; 95, string:'--log'; 96, identifier:args; 97, comparison_operator:is; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:args; 100, string:'--log'; 101, None; 102, block; 102, 103; 102, 113; 102, 124; 102, 131; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:logfile; 106, call; 106, 107; 106, 108; 107, identifier:open; 108, argument_list; 108, 109; 108, 112; 109, subscript; 109, 110; 109, 111; 110, identifier:args; 111, string:'--log'; 112, string:'w'; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:logfile_stream; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:logging; 119, identifier:StreamHandler; 120, argument_list; 120, 121; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:stream; 123, identifier:logfile; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:logfile_stream; 128, identifier:setFormatter; 129, argument_list; 129, 130; 130, identifier:file_log_formatter; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:logger; 135, identifier:addHandler; 136, argument_list; 136, 137; 137, identifier:logfile_stream; 138, if_statement; 138, 139; 138, 148; 139, boolean_operator:and; 139, 140; 139, 143; 140, comparison_operator:in; 140, 141; 140, 142; 141, string:'--dry-run'; 142, identifier:args; 143, comparison_operator:is; 143, 144; 143, 147; 144, subscript; 144, 145; 144, 146; 145, identifier:args; 146, string:'--dry-run'; 147, True; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:logger; 153, identifier:info; 154, argument_list; 154, 155; 155, string:'Running with --dry-run parameter. Actions will not be performed.'; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:self; 160, identifier:logger; 161, identifier:logger | def create_logger(self, args={}):
logger = logging.getLogger("SmartFileSorter")
logger.level = logging.INFO
if '--debug' in args and args['--debug'] is True:
logger.setLevel(logging.DEBUG)
file_log_formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(message)s',
'%Y-%m-%d %H:%M:%S')
console_log_formatter = logging.Formatter('%(message)s')
stdout_stream = logging.StreamHandler(stream=sys.stdout)
stdout_stream.setFormatter(console_log_formatter)
logger.addHandler(stdout_stream)
if '--log' in args and args['--log'] is not None:
logfile = open(args['--log'], 'w')
logfile_stream = logging.StreamHandler(stream=logfile)
logfile_stream.setFormatter(file_log_formatter)
logger.addHandler(logfile_stream)
if '--dry-run' in args and args['--dry-run'] is True:
logger.info('Running with --dry-run parameter. Actions will not be performed.')
self.logger = logger |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:slug; 6, block; 6, 7; 6, 16; 6, 21; 6, 29; 6, 42; 6, 55; 6, 68; 6, 81; 6, 94; 6, 107; 6, 115; 6, 123; 6, 167; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:kb; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:api; 13, identifier:get_kb_by_slug; 14, argument_list; 14, 15; 15, identifier:slug; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:check_knowledge_access; 19, argument_list; 19, 20; 20, identifier:kb; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:parser; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:reqparse; 27, identifier:RequestParser; 28, argument_list; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:parser; 33, identifier:add_argument; 34, argument_list; 34, 35; 34, 36; 34, 39; 35, string:'from'; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:type; 38, identifier:str; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:help; 41, string:"Return only entries where key matches this."; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:parser; 46, identifier:add_argument; 47, argument_list; 47, 48; 47, 49; 47, 52; 48, string:'to'; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:type; 51, identifier:str; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:help; 54, string:"Return only entries where value matches this."; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:parser; 59, identifier:add_argument; 60, argument_list; 60, 61; 60, 62; 60, 65; 61, string:'page'; 62, keyword_argument; 62, 63; 62, 64; 63, identifier:type; 64, identifier:int; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:help; 67, string:"Require a specific page"; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:parser; 72, identifier:add_argument; 73, argument_list; 73, 74; 73, 75; 73, 78; 74, string:'per_page'; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:type; 77, identifier:int; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:help; 80, string:"Set how much result per page"; 81, expression_statement; 81, 82; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:parser; 85, identifier:add_argument; 86, argument_list; 86, 87; 86, 88; 86, 91; 87, string:'match_type'; 88, keyword_argument; 88, 89; 88, 90; 89, identifier:type; 90, identifier:str; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:help; 93, string:"s=substring, e=exact, sw=startswith"; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:parser; 98, identifier:add_argument; 99, argument_list; 99, 100; 99, 101; 99, 104; 100, string:'sortby'; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:type; 103, identifier:str; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:help; 106, string:"the sorting criteria ('from' or 'to')"; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:args; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:parser; 113, identifier:parse_args; 114, argument_list; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 118; 117, identifier:kb_dict; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:kb; 121, identifier:to_dict; 122, argument_list; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:kb_dict; 127, string:'mappings'; 128, call; 128, 129; 128, 133; 129, attribute; 129, 130; 129, 131; 129, 132; 130, identifier:KnwKBMappingsResource; 131, line_continuation:\; 132, identifier:search_mappings; 133, argument_list; 133, 134; 133, 137; 133, 142; 133, 147; 133, 152; 133, 157; 133, 162; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:kb; 136, identifier:kb; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:key; 139, subscript; 139, 140; 139, 141; 140, identifier:args; 141, string:'from'; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:value; 144, subscript; 144, 145; 144, 146; 145, identifier:args; 146, string:'to'; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:match_type; 149, subscript; 149, 150; 149, 151; 150, identifier:args; 151, string:'match_type'; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:sortby; 154, subscript; 154, 155; 154, 156; 155, identifier:args; 156, string:'sortby'; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:page; 159, subscript; 159, 160; 159, 161; 160, identifier:args; 161, string:'page'; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:per_page; 164, subscript; 164, 165; 164, 166; 165, identifier:args; 166, string:'per_page'; 167, return_statement; 167, 168; 168, identifier:kb_dict | def get(self, slug):
kb = api.get_kb_by_slug(slug)
check_knowledge_access(kb)
parser = reqparse.RequestParser()
parser.add_argument(
'from', type=str,
help="Return only entries where key matches this.")
parser.add_argument(
'to', type=str,
help="Return only entries where value matches this.")
parser.add_argument('page', type=int,
help="Require a specific page")
parser.add_argument('per_page', type=int,
help="Set how much result per page")
parser.add_argument('match_type', type=str,
help="s=substring, e=exact, sw=startswith")
parser.add_argument('sortby', type=str,
help="the sorting criteria ('from' or 'to')")
args = parser.parse_args()
kb_dict = kb.to_dict()
kb_dict['mappings'] = KnwKBMappingsResource \
.search_mappings(kb=kb, key=args['from'], value=args['to'],
match_type=args['match_type'],
sortby=args['sortby'], page=args['page'],
per_page=args['per_page'])
return kb_dict |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.