sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:filter_sorted_apps; 3, parameters; 3, 4; 3, 5; 4, identifier:admin_apps; 5, identifier:request; 6, block; 6, 7; 6, 11; 6, 53; 6, 57; 6, 67; 6, 75; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sorted_apps; 10, list:[]; 11, for_statement; 11, 12; 11, 13; 11, 16; 12, identifier:orig_app_spec; 13, attribute; 13, 14; 13, 15; 14, identifier:appsettings; 15, identifier:DASHBOARD_SORTED_APPS; 16, block; 16, 17; 16, 25; 16, 41; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:app_spec; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:orig_app_spec; 23, identifier:copy; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, subscript; 27, 28; 27, 29; 28, identifier:app_spec; 29, string:'models'; 30, call; 30, 31; 30, 32; 31, identifier:_build_app_models; 32, argument_list; 32, 33; 32, 34; 32, 35; 32, 38; 33, identifier:request; 34, identifier:admin_apps; 35, subscript; 35, 36; 35, 37; 36, identifier:app_spec; 37, string:'models'; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:ensure_all_models; 40, True; 41, if_statement; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:app_spec; 44, string:'models'; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:sorted_apps; 50, identifier:append; 51, argument_list; 51, 52; 52, identifier:app_spec; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:used_models; 56, list:[]; 57, for_statement; 57, 58; 57, 59; 57, 60; 58, identifier:app; 59, identifier:sorted_apps; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, augmented_assignment:+=; 62, 63; 62, 64; 63, identifier:used_models; 64, subscript; 64, 65; 64, 66; 65, identifier:app; 66, string:'models'; 67, expression_statement; 67, 68; 68, augmented_assignment:+=; 68, 69; 68, 70; 69, identifier:sorted_apps; 70, call; 70, 71; 70, 72; 71, identifier:_remove_app_models; 72, argument_list; 72, 73; 72, 74; 73, identifier:admin_apps; 74, identifier:used_models; 75, return_statement; 75, 76; 76, identifier:sorted_apps | def filter_sorted_apps(admin_apps, request):
sorted_apps = []
for orig_app_spec in appsettings.DASHBOARD_SORTED_APPS:
app_spec = orig_app_spec.copy()
app_spec['models'] = _build_app_models(
request, admin_apps, app_spec['models'], ensure_all_models=True
)
if app_spec['models']:
sorted_apps.append(app_spec)
used_models = []
for app in sorted_apps:
used_models += app['models']
sorted_apps += _remove_app_models(admin_apps, used_models)
return sorted_apps |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:render_stats; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:stats; 5, identifier:sort; 6, identifier:format; 7, block; 7, 8; 7, 14; 7, 29; 7, 37; 7, 45; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:output; 11, call; 11, 12; 11, 13; 12, identifier:StdoutWrapper; 13, argument_list; 14, if_statement; 14, 15; 14, 20; 15, call; 15, 16; 15, 17; 16, identifier:hasattr; 17, argument_list; 17, 18; 17, 19; 18, identifier:stats; 19, string:"stream"; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:stats; 25, identifier:stream; 26, attribute; 26, 27; 26, 28; 27, identifier:output; 28, identifier:stream; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:stats; 33, identifier:sort_stats; 34, argument_list; 34, 35; 35, list_splat; 35, 36; 36, identifier:sort; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 44; 39, call; 39, 40; 39, 41; 40, identifier:getattr; 41, argument_list; 41, 42; 41, 43; 42, identifier:stats; 43, identifier:format; 44, argument_list; 45, return_statement; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:output; 48, identifier:stream | def render_stats(stats, sort, format):
output = StdoutWrapper()
if hasattr(stats, "stream"):
stats.stream = output.stream
stats.sort_stats(*sort)
getattr(stats, format)()
return output.stream |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:render_queries; 3, parameters; 3, 4; 3, 5; 4, identifier:queries; 5, identifier:sort; 6, block; 6, 7; 6, 13; 6, 40; 6, 99; 6, 103; 6, 107; 6, 156; 6, 173; 6, 196; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:output; 10, call; 10, 11; 10, 12; 11, identifier:StringIO; 12, argument_list; 13, if_statement; 13, 14; 13, 17; 14, comparison_operator:==; 14, 15; 14, 16; 15, identifier:sort; 16, string:'order'; 17, block; 17, 18; 17, 22; 17, 38; 18, print_statement; 18, 19; 18, 21; 19, chevron; 19, 20; 20, identifier:output; 21, string:" time query"; 22, for_statement; 22, 23; 22, 24; 22, 25; 23, identifier:query; 24, identifier:queries; 25, block; 25, 26; 26, print_statement; 26, 27; 26, 29; 27, chevron; 27, 28; 28, identifier:output; 29, binary_operator:%; 29, 30; 29, 31; 30, string:" %8s %s"; 31, tuple; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:query; 34, string:"time"; 35, subscript; 35, 36; 35, 37; 36, identifier:query; 37, string:"sql"; 38, return_statement; 38, 39; 39, identifier:output; 40, if_statement; 40, 41; 40, 44; 40, 65; 40, 90; 41, comparison_operator:==; 41, 42; 41, 43; 42, identifier:sort; 43, string:'time'; 44, block; 44, 45; 45, function_definition; 45, 46; 45, 47; 45, 50; 46, function_name:sorter; 47, parameters; 47, 48; 47, 49; 48, identifier:x; 49, identifier:y; 50, block; 50, 51; 51, return_statement; 51, 52; 52, call; 52, 53; 52, 54; 53, identifier:cmp; 54, argument_list; 54, 55; 54, 60; 55, subscript; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:x; 58, integer:1; 59, integer:1; 60, subscript; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:y; 63, integer:1; 64, integer:1; 65, elif_clause; 65, 66; 65, 69; 66, comparison_operator:==; 66, 67; 66, 68; 67, identifier:sort; 68, string:'queries'; 69, block; 69, 70; 70, function_definition; 70, 71; 70, 72; 70, 75; 71, function_name:sorter; 72, parameters; 72, 73; 72, 74; 73, identifier:x; 74, identifier:y; 75, block; 75, 76; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:cmp; 79, argument_list; 79, 80; 79, 85; 80, subscript; 80, 81; 80, 84; 81, subscript; 81, 82; 81, 83; 82, identifier:x; 83, integer:1; 84, integer:0; 85, subscript; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:y; 88, integer:1; 89, integer:0; 90, else_clause; 90, 91; 91, block; 91, 92; 92, raise_statement; 92, 93; 93, call; 93, 94; 93, 95; 94, identifier:RuntimeError; 95, argument_list; 95, 96; 96, binary_operator:%; 96, 97; 96, 98; 97, string:"Unknown sort: %s"; 98, identifier:sort; 99, print_statement; 99, 100; 99, 102; 100, chevron; 100, 101; 101, identifier:output; 102, string:" queries time query"; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:results; 106, dictionary; 107, for_statement; 107, 108; 107, 109; 107, 110; 108, identifier:query; 109, identifier:queries; 110, block; 110, 111; 111, try_statement; 111, 112; 111, 138; 112, block; 112, 113; 112, 121; 112, 127; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:result; 116, subscript; 116, 117; 116, 118; 117, identifier:results; 118, subscript; 118, 119; 118, 120; 119, identifier:query; 120, string:"sql"; 121, expression_statement; 121, 122; 122, augmented_assignment:+=; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:result; 125, integer:0; 126, integer:1; 127, expression_statement; 127, 128; 128, augmented_assignment:+=; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:result; 131, integer:1; 132, call; 132, 133; 132, 134; 133, identifier:Decimal; 134, argument_list; 134, 135; 135, subscript; 135, 136; 135, 137; 136, identifier:query; 137, string:"time"; 138, except_clause; 138, 139; 138, 140; 139, identifier:KeyError; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 148; 143, subscript; 143, 144; 143, 145; 144, identifier:results; 145, subscript; 145, 146; 145, 147; 146, identifier:query; 147, string:"sql"; 148, list:[1, Decimal(query["time"])]; 148, 149; 148, 150; 149, integer:1; 150, call; 150, 151; 150, 152; 151, identifier:Decimal; 152, argument_list; 152, 153; 153, subscript; 153, 154; 153, 155; 154, identifier:query; 155, string:"time"; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:results; 159, call; 159, 160; 159, 161; 160, identifier:sorted; 161, argument_list; 161, 162; 161, 167; 161, 170; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:results; 165, identifier:iteritems; 166, argument_list; 167, keyword_argument; 167, 168; 167, 169; 168, identifier:cmp; 169, identifier:sorter; 170, keyword_argument; 170, 171; 170, 172; 171, identifier:reverse; 172, True; 173, for_statement; 173, 174; 173, 175; 173, 176; 174, identifier:result; 175, identifier:results; 176, block; 176, 177; 177, print_statement; 177, 178; 177, 180; 178, chevron; 178, 179; 179, identifier:output; 180, binary_operator:%; 180, 181; 180, 182; 181, string:" %8d %8.3f %s"; 182, tuple; 182, 183; 182, 188; 182, 193; 183, subscript; 183, 184; 183, 187; 184, subscript; 184, 185; 184, 186; 185, identifier:result; 186, integer:1; 187, integer:0; 188, subscript; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:result; 191, integer:1; 192, integer:1; 193, subscript; 193, 194; 193, 195; 194, identifier:result; 195, integer:0; 196, return_statement; 196, 197; 197, identifier:output | def render_queries(queries, sort):
output = StringIO()
if sort == 'order':
print >>output, " time query"
for query in queries:
print >>output, " %8s %s" % (query["time"], query["sql"])
return output
if sort == 'time':
def sorter(x, y):
return cmp(x[1][1], y[1][1])
elif sort == 'queries':
def sorter(x, y):
return cmp(x[1][0], y[1][0])
else:
raise RuntimeError("Unknown sort: %s" % sort)
print >>output, " queries time query"
results = {}
for query in queries:
try:
result = results[query["sql"]]
result[0] += 1
result[1] += Decimal(query["time"])
except KeyError:
results[query["sql"]] = [1, Decimal(query["time"])]
results = sorted(results.iteritems(), cmp=sorter, reverse=True)
for result in results:
print >>output, " %8d %8.3f %s" % (
result[1][0], result[1][1], result[0]
)
return output |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:process_request; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:request; 6, block; 6, 7; 6, 50; 6, 83; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:unpickle; 9, parameters; 9, 10; 10, identifier:params; 11, block; 11, 12; 11, 28; 11, 46; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:stats; 15, call; 15, 16; 15, 17; 16, identifier:unpickle_stats; 17, argument_list; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:b64decode; 20, argument_list; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:params; 24, identifier:get; 25, argument_list; 25, 26; 25, 27; 26, string:'stats'; 27, string:''; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:queries; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:cPickle; 34, identifier:loads; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:b64decode; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:params; 42, identifier:get; 43, argument_list; 43, 44; 43, 45; 44, string:'queries'; 45, string:''; 46, return_statement; 46, 47; 47, expression_list; 47, 48; 47, 49; 48, identifier:stats; 49, identifier:queries; 50, if_statement; 50, 51; 50, 81; 51, boolean_operator:and; 51, 52; 51, 57; 51, 58; 52, comparison_operator:!=; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:request; 55, identifier:method; 56, string:'GET'; 57, line_continuation:\; 58, not_operator; 58, 59; 59, parenthesized_expression; 59, 60; 60, comparison_operator:in; 60, 61; 60, 78; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:request; 65, identifier:META; 66, identifier:get; 67, argument_list; 67, 68; 67, 69; 68, string:'HTTP_CONTENT_TYPE'; 69, call; 69, 70; 69, 75; 70, attribute; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:request; 73, identifier:META; 74, identifier:get; 75, argument_list; 75, 76; 75, 77; 76, string:'CONTENT_TYPE'; 77, string:''; 78, list:['multipart/form-data', 'application/x-www-form-urlencoded']; 78, 79; 78, 80; 79, string:'multipart/form-data'; 80, string:'application/x-www-form-urlencoded'; 81, block; 81, 82; 82, return_statement; 83, if_statement; 83, 84; 83, 107; 84, parenthesized_expression; 84, 85; 85, boolean_operator:and; 85, 86; 85, 95; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:request; 90, identifier:REQUEST; 91, identifier:get; 92, argument_list; 92, 93; 92, 94; 93, string:'profile'; 94, False; 95, parenthesized_expression; 95, 96; 96, boolean_operator:or; 96, 97; 96, 102; 97, comparison_operator:==; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:settings; 100, identifier:DEBUG; 101, True; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:request; 105, identifier:user; 106, identifier:is_staff; 107, block; 107, 108; 107, 118; 107, 124; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:request; 112, identifier:statsfile; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:tempfile; 116, identifier:NamedTemporaryFile; 117, argument_list; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:params; 121, attribute; 121, 122; 121, 123; 122, identifier:request; 123, identifier:REQUEST; 124, if_statement; 124, 125; 124, 143; 124, 160; 124, 196; 125, parenthesized_expression; 125, 126; 126, boolean_operator:and; 126, 127; 126, 134; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:params; 130, identifier:get; 131, argument_list; 131, 132; 131, 133; 132, string:'show_stats'; 133, False; 134, comparison_operator:==; 134, 135; 134, 142; 135, call; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:params; 138, identifier:get; 139, argument_list; 139, 140; 139, 141; 140, string:'show_queries'; 141, string:'1'; 142, string:'1'; 143, block; 143, 144; 143, 153; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 149; 146, pattern_list; 146, 147; 146, 148; 147, identifier:stats; 148, identifier:queries; 149, call; 149, 150; 149, 151; 150, identifier:unpickle; 151, argument_list; 151, 152; 152, identifier:params; 153, return_statement; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:display_stats; 156, argument_list; 156, 157; 156, 158; 156, 159; 157, identifier:request; 158, identifier:stats; 159, identifier:queries; 160, elif_clause; 160, 161; 160, 179; 161, parenthesized_expression; 161, 162; 162, boolean_operator:and; 162, 163; 162, 170; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:params; 166, identifier:get; 167, argument_list; 167, 168; 167, 169; 168, string:'show_queries'; 169, False; 170, comparison_operator:==; 170, 171; 170, 178; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:params; 174, identifier:get; 175, argument_list; 175, 176; 175, 177; 176, string:'show_stats'; 177, string:'1'; 178, string:'1'; 179, block; 179, 180; 179, 189; 180, expression_statement; 180, 181; 181, assignment; 181, 182; 181, 185; 182, pattern_list; 182, 183; 182, 184; 183, identifier:stats; 184, identifier:queries; 185, call; 185, 186; 185, 187; 186, identifier:unpickle; 187, argument_list; 187, 188; 188, identifier:params; 189, return_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:display_queries; 192, argument_list; 192, 193; 192, 194; 192, 195; 193, identifier:request; 194, identifier:stats; 195, identifier:queries; 196, else_clause; 196, 197; 197, block; 197, 198; 197, 213; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:request; 202, identifier:profiler; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:hotshot; 206, identifier:Profile; 207, argument_list; 207, 208; 208, attribute; 208, 209; 208, 212; 209, attribute; 209, 210; 209, 211; 210, identifier:request; 211, identifier:statsfile; 212, identifier:name; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 216; 215, identifier:reset_queries; 216, argument_list | def process_request(self, request):
def unpickle(params):
stats = unpickle_stats(b64decode(params.get('stats', '')))
queries = cPickle.loads(b64decode(params.get('queries', '')))
return stats, queries
if request.method != 'GET' and \
not (request.META.get(
'HTTP_CONTENT_TYPE', request.META.get('CONTENT_TYPE', '')
) in ['multipart/form-data', 'application/x-www-form-urlencoded']):
return
if (request.REQUEST.get('profile', False) and
(settings.DEBUG == True or request.user.is_staff)):
request.statsfile = tempfile.NamedTemporaryFile()
params = request.REQUEST
if (params.get('show_stats', False)
and params.get('show_queries', '1') == '1'):
stats, queries = unpickle(params)
return display_stats(request, stats, queries)
elif (params.get('show_queries', False)
and params.get('show_stats', '1') == '1'):
stats, queries = unpickle(params)
return display_queries(request, stats, queries)
else:
request.profiler = hotshot.Profile(request.statsfile.name)
reset_queries() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:dedupe_and_sort; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:sequence; 5, default_parameter; 5, 6; 5, 7; 6, identifier:first; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:last; 10, None; 11, block; 11, 12; 11, 18; 11, 24; 11, 36; 11, 56; 11, 71; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:first; 15, boolean_operator:or; 15, 16; 15, 17; 16, identifier:first; 17, list:[]; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:last; 21, boolean_operator:or; 21, 22; 21, 23; 22, identifier:last; 23, list:[]; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:new_sequence; 27, list_comprehension; 27, 28; 27, 29; 27, 32; 28, identifier:i; 29, for_in_clause; 29, 30; 29, 31; 30, identifier:i; 31, identifier:first; 32, if_clause; 32, 33; 33, comparison_operator:in; 33, 34; 33, 35; 34, identifier:i; 35, identifier:sequence; 36, for_statement; 36, 37; 36, 38; 36, 39; 37, identifier:item; 38, identifier:sequence; 39, block; 39, 40; 40, if_statement; 40, 41; 40, 48; 41, boolean_operator:and; 41, 42; 41, 45; 42, comparison_operator:not; 42, 43; 42, 44; 43, identifier:item; 44, identifier:new_sequence; 45, comparison_operator:not; 45, 46; 45, 47; 46, identifier:item; 47, identifier:last; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:new_sequence; 53, identifier:append; 54, argument_list; 54, 55; 55, identifier:item; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:new_sequence; 60, identifier:extend; 61, argument_list; 61, 62; 62, list_comprehension; 62, 63; 62, 64; 62, 67; 63, identifier:i; 64, for_in_clause; 64, 65; 64, 66; 65, identifier:i; 66, identifier:last; 67, if_clause; 67, 68; 68, comparison_operator:in; 68, 69; 68, 70; 69, identifier:i; 70, identifier:sequence; 71, return_statement; 71, 72; 72, call; 72, 73; 72, 77; 73, call; 73, 74; 73, 75; 74, identifier:type; 75, argument_list; 75, 76; 76, identifier:sequence; 77, argument_list; 77, 78; 78, identifier:new_sequence | def dedupe_and_sort(sequence, first=None, last=None):
first = first or []
last = last or []
new_sequence = [i for i in first if i in sequence]
for item in sequence:
if item not in new_sequence and item not in last:
new_sequence.append(item)
new_sequence.extend([i for i in last if i in sequence])
return type(sequence)(new_sequence) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sortedSemver; 3, parameters; 3, 4; 3, 5; 4, identifier:versions; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, string:"asc"; 8, block; 8, 9; 9, if_statement; 9, 10; 9, 19; 9, 77; 10, boolean_operator:and; 10, 11; 10, 12; 11, identifier:versions; 12, call; 12, 13; 12, 14; 13, identifier:isinstance; 14, argument_list; 14, 15; 14, 16; 15, identifier:versions; 16, tuple; 16, 17; 16, 18; 17, identifier:list; 18, identifier:tuple; 19, block; 19, 20; 20, if_statement; 20, 21; 20, 22; 20, 45; 21, identifier:PY2; 22, block; 22, 23; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:sorted; 26, argument_list; 26, 27; 26, 28; 26, 33; 27, identifier:versions; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:cmp; 30, attribute; 30, 31; 30, 32; 31, identifier:semver; 32, identifier:compare; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:reverse; 35, conditional_expression:if; 35, 36; 35, 37; 35, 44; 36, True; 37, comparison_operator:==; 37, 38; 37, 43; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:sort; 41, identifier:upper; 42, argument_list; 43, string:"DESC"; 44, False; 45, else_clause; 45, 46; 46, block; 46, 47; 46, 52; 47, import_from_statement; 47, 48; 47, 50; 48, dotted_name; 48, 49; 49, identifier:functools; 50, dotted_name; 50, 51; 51, identifier:cmp_to_key; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:sorted; 55, argument_list; 55, 56; 55, 57; 55, 65; 56, identifier:versions; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:key; 59, call; 59, 60; 59, 61; 60, identifier:cmp_to_key; 61, argument_list; 61, 62; 62, attribute; 62, 63; 62, 64; 63, identifier:semver; 64, identifier:compare; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:reverse; 67, conditional_expression:if; 67, 68; 67, 69; 67, 76; 68, True; 69, comparison_operator:==; 69, 70; 69, 75; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:sort; 73, identifier:upper; 74, argument_list; 75, string:"DESC"; 76, False; 77, else_clause; 77, 78; 78, block; 78, 79; 79, raise_statement; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:TypeError; 82, argument_list; 82, 83; 83, string:"Invaild Versions, a list or tuple is right." | def sortedSemver(versions, sort="asc"):
if versions and isinstance(versions, (list, tuple)):
if PY2:
return sorted(versions, cmp=semver.compare, reverse=True if sort.upper() == "DESC" else False)
else:
from functools import cmp_to_key
return sorted(versions, key=cmp_to_key(semver.compare), reverse=True if sort.upper() == "DESC" else False)
else:
raise TypeError("Invaild Versions, a list or tuple is right.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 1, 12; 2, function_name:unique; 3, parameters; 3, 4; 3, 5; 4, identifier:arr; 5, default_parameter; 5, 6; 5, 7; 6, identifier:tolerance; 7, float:1e-6; 8, type; 8, 9; 9, attribute; 9, 10; 9, 11; 10, identifier:np; 11, identifier:ndarray; 12, block; 12, 13; 12, 24; 12, 28; 12, 102; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:arr; 16, call; 16, 17; 16, 18; 17, identifier:sorted; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:arr; 22, identifier:flatten; 23, argument_list; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:unique; 27, list:[]; 28, while_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:arr; 34, integer:0; 35, block; 35, 36; 35, 42; 35, 61; 35, 83; 35, 95; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:current; 39, subscript; 39, 40; 39, 41; 40, identifier:arr; 41, integer:0; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:lis; 45, list_comprehension; 45, 46; 45, 47; 45, 50; 46, identifier:xi; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:xi; 49, identifier:arr; 50, if_clause; 50, 51; 51, comparison_operator:<; 51, 52; 51, 60; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:np; 55, identifier:abs; 56, argument_list; 56, 57; 57, binary_operator:-; 57, 58; 57, 59; 58, identifier:current; 59, identifier:xi; 60, identifier:tolerance; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:arr; 64, list_comprehension; 64, 65; 64, 66; 64, 69; 65, identifier:xi; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:xi; 68, identifier:arr; 69, if_clause; 69, 70; 70, not_operator; 70, 71; 71, comparison_operator:<; 71, 72; 71, 82; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:np; 75, identifier:abs; 76, argument_list; 76, 77; 77, binary_operator:-; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:lis; 80, integer:0; 81, identifier:xi; 82, identifier:tolerance; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:xi_lis_average; 86, binary_operator:/; 86, 87; 86, 91; 87, call; 87, 88; 87, 89; 88, identifier:sum; 89, argument_list; 89, 90; 90, identifier:lis; 91, call; 91, 92; 91, 93; 92, identifier:len; 93, argument_list; 93, 94; 94, identifier:lis; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:unique; 99, identifier:append; 100, argument_list; 100, 101; 101, identifier:xi_lis_average; 102, return_statement; 102, 103; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:np; 106, identifier:array; 107, argument_list; 107, 108; 108, identifier:unique | def unique(arr, tolerance=1e-6) -> np.ndarray:
arr = sorted(arr.flatten())
unique = []
while len(arr) > 0:
current = arr[0]
lis = [xi for xi in arr if np.abs(current - xi) < tolerance]
arr = [xi for xi in arr if not np.abs(lis[0] - xi) < tolerance]
xi_lis_average = sum(lis) / len(lis)
unique.append(xi_lis_average)
return np.array(unique) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_cache_key; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 19; 5, 25; 5, 31; 5, 58; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:keys; 9, call; 9, 10; 9, 11; 10, identifier:list; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:params; 17, identifier:keys; 18, argument_list; 19, expression_statement; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:keys; 23, identifier:sort; 24, argument_list; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:cache_key; 28, call; 28, 29; 28, 30; 29, identifier:str; 30, argument_list; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:key; 33, identifier:keys; 34, block; 34, 35; 35, if_statement; 35, 36; 35, 47; 36, boolean_operator:and; 36, 37; 36, 44; 37, boolean_operator:and; 37, 38; 37, 41; 38, comparison_operator:!=; 38, 39; 38, 40; 39, identifier:key; 40, string:"api_sig"; 41, comparison_operator:!=; 41, 42; 41, 43; 42, identifier:key; 43, string:"api_key"; 44, comparison_operator:!=; 44, 45; 44, 46; 45, identifier:key; 46, string:"sk"; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, augmented_assignment:+=; 49, 50; 49, 51; 50, identifier:cache_key; 51, binary_operator:+; 51, 52; 51, 53; 52, identifier:key; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:params; 57, identifier:key; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 73; 60, attribute; 60, 61; 60, 72; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:hashlib; 64, identifier:sha1; 65, argument_list; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:cache_key; 69, identifier:encode; 70, argument_list; 70, 71; 71, string:"utf-8"; 72, identifier:hexdigest; 73, argument_list | def _get_cache_key(self):
keys = list(self.params.keys())
keys.sort()
cache_key = str()
for key in keys:
if key != "api_sig" and key != "api_key" and key != "sk":
cache_key += key + self.params[key]
return hashlib.sha1(cache_key.encode("utf-8")).hexdigest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:fast_float; 3, parameters; 3, 4; 3, 5; 3, 11; 3, 14; 3, 19; 3, 22; 4, identifier:x; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, lambda; 7, 8; 7, 10; 8, lambda_parameters; 8, 9; 9, identifier:x; 10, identifier:x; 11, default_parameter; 11, 12; 11, 13; 12, identifier:nan; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:_uni; 16, attribute; 16, 17; 16, 18; 17, identifier:unicodedata; 18, identifier:numeric; 19, default_parameter; 19, 20; 19, 21; 20, identifier:_nan_inf; 21, identifier:NAN_INF; 22, default_parameter; 22, 23; 22, 24; 23, identifier:_first_char; 24, identifier:POTENTIAL_FIRST_CHAR; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 44; 26, 98; 27, boolean_operator:or; 27, 28; 27, 33; 28, comparison_operator:in; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:x; 31, integer:0; 32, identifier:_first_char; 33, comparison_operator:in; 33, 34; 33, 43; 34, subscript; 34, 35; 34, 40; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:x; 38, identifier:lstrip; 39, argument_list; 40, slice; 40, 41; 40, 42; 41, colon; 42, integer:3; 43, identifier:_nan_inf; 44, block; 44, 45; 45, try_statement; 45, 46; 45, 65; 46, block; 46, 47; 46, 54; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:x; 50, call; 50, 51; 50, 52; 51, identifier:float; 52, argument_list; 52, 53; 53, identifier:x; 54, return_statement; 54, 55; 55, conditional_expression:if; 55, 56; 55, 57; 55, 64; 56, identifier:nan; 57, boolean_operator:and; 57, 58; 57, 61; 58, comparison_operator:is; 58, 59; 58, 60; 59, identifier:nan; 60, None; 61, comparison_operator:!=; 61, 62; 61, 63; 62, identifier:x; 63, identifier:x; 64, identifier:x; 65, except_clause; 65, 66; 65, 67; 66, identifier:ValueError; 67, block; 67, 68; 68, try_statement; 68, 69; 68, 90; 69, block; 69, 70; 70, return_statement; 70, 71; 71, conditional_expression:if; 71, 72; 71, 80; 71, 86; 72, call; 72, 73; 72, 74; 73, identifier:_uni; 74, argument_list; 74, 75; 74, 76; 75, identifier:x; 76, call; 76, 77; 76, 78; 77, identifier:key; 78, argument_list; 78, 79; 79, identifier:x; 80, comparison_operator:==; 80, 81; 80, 85; 81, call; 81, 82; 81, 83; 82, identifier:len; 83, argument_list; 83, 84; 84, identifier:x; 85, integer:1; 86, call; 86, 87; 86, 88; 87, identifier:key; 88, argument_list; 88, 89; 89, identifier:x; 90, except_clause; 90, 91; 90, 92; 91, identifier:TypeError; 92, block; 92, 93; 93, return_statement; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:key; 96, argument_list; 96, 97; 97, identifier:x; 98, else_clause; 98, 99; 99, block; 99, 100; 100, try_statement; 100, 101; 100, 122; 101, block; 101, 102; 102, return_statement; 102, 103; 103, conditional_expression:if; 103, 104; 103, 112; 103, 118; 104, call; 104, 105; 104, 106; 105, identifier:_uni; 106, argument_list; 106, 107; 106, 108; 107, identifier:x; 108, call; 108, 109; 108, 110; 109, identifier:key; 110, argument_list; 110, 111; 111, identifier:x; 112, comparison_operator:==; 112, 113; 112, 117; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, identifier:x; 117, integer:1; 118, call; 118, 119; 118, 120; 119, identifier:key; 120, argument_list; 120, 121; 121, identifier:x; 122, except_clause; 122, 123; 122, 124; 123, identifier:TypeError; 124, block; 124, 125; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 128; 127, identifier:key; 128, argument_list; 128, 129; 129, identifier:x | def fast_float(
x,
key=lambda x: x,
nan=None,
_uni=unicodedata.numeric,
_nan_inf=NAN_INF,
_first_char=POTENTIAL_FIRST_CHAR,
):
if x[0] in _first_char or x.lstrip()[:3] in _nan_inf:
try:
x = float(x)
return nan if nan is not None and x != x else x
except ValueError:
try:
return _uni(x, key(x)) if len(x) == 1 else key(x)
except TypeError:
return key(x)
else:
try:
return _uni(x, key(x)) if len(x) == 1 else key(x)
except TypeError:
return key(x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:fast_int; 3, parameters; 3, 4; 3, 5; 3, 11; 3, 16; 4, identifier:x; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, lambda; 7, 8; 7, 10; 8, lambda_parameters; 8, 9; 9, identifier:x; 10, identifier:x; 11, default_parameter; 11, 12; 11, 13; 12, identifier:_uni; 13, attribute; 13, 14; 13, 15; 14, identifier:unicodedata; 15, identifier:digit; 16, default_parameter; 16, 17; 16, 18; 17, identifier:_first_char; 18, identifier:POTENTIAL_FIRST_CHAR; 19, block; 19, 20; 20, if_statement; 20, 21; 20, 26; 20, 67; 21, comparison_operator:in; 21, 22; 21, 25; 22, subscript; 22, 23; 22, 24; 23, identifier:x; 24, integer:0; 25, identifier:_first_char; 26, block; 26, 27; 27, try_statement; 27, 28; 27, 34; 28, block; 28, 29; 29, return_statement; 29, 30; 30, call; 30, 31; 30, 32; 31, identifier:long; 32, argument_list; 32, 33; 33, identifier:x; 34, except_clause; 34, 35; 34, 36; 35, identifier:ValueError; 36, block; 36, 37; 37, try_statement; 37, 38; 37, 59; 38, block; 38, 39; 39, return_statement; 39, 40; 40, conditional_expression:if; 40, 41; 40, 49; 40, 55; 41, call; 41, 42; 41, 43; 42, identifier:_uni; 43, argument_list; 43, 44; 43, 45; 44, identifier:x; 45, call; 45, 46; 45, 47; 46, identifier:key; 47, argument_list; 47, 48; 48, identifier:x; 49, comparison_operator:==; 49, 50; 49, 54; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:x; 54, integer:1; 55, call; 55, 56; 55, 57; 56, identifier:key; 57, argument_list; 57, 58; 58, identifier:x; 59, except_clause; 59, 60; 59, 61; 60, identifier:TypeError; 61, block; 61, 62; 62, return_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:key; 65, argument_list; 65, 66; 66, identifier:x; 67, else_clause; 67, 68; 68, block; 68, 69; 69, try_statement; 69, 70; 69, 91; 70, block; 70, 71; 71, return_statement; 71, 72; 72, conditional_expression:if; 72, 73; 72, 81; 72, 87; 73, call; 73, 74; 73, 75; 74, identifier:_uni; 75, argument_list; 75, 76; 75, 77; 76, identifier:x; 77, call; 77, 78; 77, 79; 78, identifier:key; 79, argument_list; 79, 80; 80, identifier:x; 81, comparison_operator:==; 81, 82; 81, 86; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:x; 86, integer:1; 87, call; 87, 88; 87, 89; 88, identifier:key; 89, argument_list; 89, 90; 90, identifier:x; 91, except_clause; 91, 92; 91, 93; 92, identifier:TypeError; 93, block; 93, 94; 94, return_statement; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:key; 97, argument_list; 97, 98; 98, identifier:x | def fast_int(
x,
key=lambda x: x,
_uni=unicodedata.digit,
_first_char=POTENTIAL_FIRST_CHAR,
):
if x[0] in _first_char:
try:
return long(x)
except ValueError:
try:
return _uni(x, key(x)) if len(x) == 1 else key(x)
except TypeError:
return key(x)
else:
try:
return _uni(x, key(x)) if len(x) == 1 else key(x)
except TypeError:
return key(x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_and_print_entries; 3, parameters; 3, 4; 3, 5; 4, identifier:entries; 5, identifier:args; 6, block; 6, 7; 6, 19; 6, 33; 6, 84; 6, 98; 6, 270; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:is_float; 10, comparison_operator:in; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:args; 13, identifier:number_type; 14, tuple; 14, 15; 14, 16; 14, 17; 14, 18; 15, string:"float"; 16, string:"real"; 17, string:"f"; 18, string:"r"; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:signed; 22, boolean_operator:or; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:args; 25, identifier:signed; 26, comparison_operator:in; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:args; 29, identifier:number_type; 30, tuple; 30, 31; 30, 32; 31, string:"real"; 32, string:"r"; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:alg; 36, parenthesized_expression; 36, 37; 37, binary_operator:|; 37, 38; 37, 75; 38, binary_operator:|; 38, 39; 38, 66; 39, binary_operator:|; 39, 40; 39, 55; 40, binary_operator:|; 40, 41; 40, 48; 41, binary_operator:*; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:natsort; 45, identifier:ns; 46, identifier:FLOAT; 47, identifier:is_float; 48, binary_operator:*; 48, 49; 48, 54; 49, attribute; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:natsort; 52, identifier:ns; 53, identifier:SIGNED; 54, identifier:signed; 55, binary_operator:*; 55, 56; 55, 61; 56, attribute; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:natsort; 59, identifier:ns; 60, identifier:NOEXP; 61, parenthesized_expression; 61, 62; 62, not_operator; 62, 63; 63, attribute; 63, 64; 63, 65; 64, identifier:args; 65, identifier:exp; 66, binary_operator:*; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:natsort; 70, identifier:ns; 71, identifier:PATH; 72, attribute; 72, 73; 72, 74; 73, identifier:args; 74, identifier:paths; 75, binary_operator:*; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:natsort; 79, identifier:ns; 80, identifier:LOCALE; 81, attribute; 81, 82; 81, 83; 82, identifier:args; 83, identifier:locale; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:do_filter; 87, boolean_operator:or; 87, 88; 87, 93; 88, comparison_operator:is; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:args; 91, identifier:filter; 92, None; 93, comparison_operator:is; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:args; 96, identifier:reverse_filter; 97, None; 98, if_statement; 98, 99; 98, 104; 99, boolean_operator:or; 99, 100; 99, 101; 100, identifier:do_filter; 101, attribute; 101, 102; 101, 103; 102, identifier:args; 103, identifier:exclude; 104, block; 104, 105; 104, 136; 104, 143; 104, 191; 104, 240; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:inp_options; 108, parenthesized_expression; 108, 109; 109, binary_operator:|; 109, 110; 109, 125; 110, binary_operator:|; 110, 111; 110, 118; 111, binary_operator:*; 111, 112; 111, 117; 112, attribute; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:natsort; 115, identifier:ns; 116, identifier:FLOAT; 117, identifier:is_float; 118, binary_operator:*; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:natsort; 122, identifier:ns; 123, identifier:SIGNED; 124, identifier:signed; 125, binary_operator:*; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:natsort; 129, identifier:ns; 130, identifier:NOEXP; 131, parenthesized_expression; 131, 132; 132, not_operator; 132, 133; 133, attribute; 133, 134; 133, 135; 134, identifier:args; 135, identifier:exp; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 139; 138, identifier:regex; 139, call; 139, 140; 139, 141; 140, identifier:regex_chooser; 141, argument_list; 141, 142; 142, identifier:inp_options; 143, if_statement; 143, 144; 143, 149; 144, comparison_operator:is; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:args; 147, identifier:filter; 148, None; 149, block; 149, 150; 149, 174; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 155; 152, pattern_list; 152, 153; 152, 154; 153, identifier:lows; 154, identifier:highs; 155, tuple; 155, 156; 155, 165; 156, list_comprehension; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:f; 159, integer:0; 160, for_in_clause; 160, 161; 160, 162; 161, identifier:f; 162, attribute; 162, 163; 162, 164; 163, identifier:args; 164, identifier:filter; 165, list_comprehension; 165, 166; 165, 169; 166, subscript; 166, 167; 166, 168; 167, identifier:f; 168, integer:1; 169, for_in_clause; 169, 170; 169, 171; 170, identifier:f; 171, attribute; 171, 172; 171, 173; 172, identifier:args; 173, identifier:filter; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:entries; 177, list_comprehension; 177, 178; 177, 179; 177, 182; 178, identifier:entry; 179, for_in_clause; 179, 180; 179, 181; 180, identifier:entry; 181, identifier:entries; 182, if_clause; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:keep_entry_range; 185, argument_list; 185, 186; 185, 187; 185, 188; 185, 189; 185, 190; 186, identifier:entry; 187, identifier:lows; 188, identifier:highs; 189, identifier:float; 190, identifier:regex; 191, if_statement; 191, 192; 191, 197; 192, comparison_operator:is; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:args; 195, identifier:reverse_filter; 196, None; 197, block; 197, 198; 197, 222; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, pattern_list; 200, 201; 200, 202; 201, identifier:lows; 202, identifier:highs; 203, tuple; 203, 204; 203, 213; 204, list_comprehension; 204, 205; 204, 208; 205, subscript; 205, 206; 205, 207; 206, identifier:f; 207, integer:0; 208, for_in_clause; 208, 209; 208, 210; 209, identifier:f; 210, attribute; 210, 211; 210, 212; 211, identifier:args; 212, identifier:reverse_filter; 213, list_comprehension; 213, 214; 213, 217; 214, subscript; 214, 215; 214, 216; 215, identifier:f; 216, integer:1; 217, for_in_clause; 217, 218; 217, 219; 218, identifier:f; 219, attribute; 219, 220; 219, 221; 220, identifier:args; 221, identifier:reverse_filter; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:entries; 225, list_comprehension; 225, 226; 225, 227; 225, 230; 226, identifier:entry; 227, for_in_clause; 227, 228; 227, 229; 228, identifier:entry; 229, identifier:entries; 230, if_clause; 230, 231; 231, not_operator; 231, 232; 232, call; 232, 233; 232, 234; 233, identifier:keep_entry_range; 234, argument_list; 234, 235; 234, 236; 234, 237; 234, 238; 234, 239; 235, identifier:entry; 236, identifier:lows; 237, identifier:highs; 238, identifier:float; 239, identifier:regex; 240, if_statement; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:args; 243, identifier:exclude; 244, block; 244, 245; 244, 254; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:exclude; 248, call; 248, 249; 248, 250; 249, identifier:set; 250, argument_list; 250, 251; 251, attribute; 251, 252; 251, 253; 252, identifier:args; 253, identifier:exclude; 254, expression_statement; 254, 255; 255, assignment; 255, 256; 255, 257; 256, identifier:entries; 257, list_comprehension; 257, 258; 257, 259; 257, 262; 258, identifier:entry; 259, for_in_clause; 259, 260; 259, 261; 260, identifier:entry; 261, identifier:entries; 262, if_clause; 262, 263; 263, call; 263, 264; 263, 265; 264, identifier:keep_entry_value; 265, argument_list; 265, 266; 265, 267; 265, 268; 265, 269; 266, identifier:entry; 267, identifier:exclude; 268, identifier:float; 269, identifier:regex; 270, for_statement; 270, 271; 270, 272; 270, 286; 271, identifier:entry; 272, call; 272, 273; 272, 276; 273, attribute; 273, 274; 273, 275; 274, identifier:natsort; 275, identifier:natsorted; 276, argument_list; 276, 277; 276, 278; 276, 283; 277, identifier:entries; 278, keyword_argument; 278, 279; 278, 280; 279, identifier:reverse; 280, attribute; 280, 281; 280, 282; 281, identifier:args; 282, identifier:reverse; 283, keyword_argument; 283, 284; 283, 285; 284, identifier:alg; 285, identifier:alg; 286, block; 286, 287; 287, expression_statement; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:print; 290, argument_list; 290, 291; 291, identifier:entry | def sort_and_print_entries(entries, args):
is_float = args.number_type in ("float", "real", "f", "r")
signed = args.signed or args.number_type in ("real", "r")
alg = (
natsort.ns.FLOAT * is_float
| natsort.ns.SIGNED * signed
| natsort.ns.NOEXP * (not args.exp)
| natsort.ns.PATH * args.paths
| natsort.ns.LOCALE * args.locale
)
do_filter = args.filter is not None or args.reverse_filter is not None
if do_filter or args.exclude:
inp_options = (
natsort.ns.FLOAT * is_float
| natsort.ns.SIGNED * signed
| natsort.ns.NOEXP * (not args.exp)
)
regex = regex_chooser(inp_options)
if args.filter is not None:
lows, highs = ([f[0] for f in args.filter], [f[1] for f in args.filter])
entries = [
entry
for entry in entries
if keep_entry_range(entry, lows, highs, float, regex)
]
if args.reverse_filter is not None:
lows, highs = (
[f[0] for f in args.reverse_filter],
[f[1] for f in args.reverse_filter],
)
entries = [
entry
for entry in entries
if not keep_entry_range(entry, lows, highs, float, regex)
]
if args.exclude:
exclude = set(args.exclude)
entries = [
entry
for entry in entries
if keep_entry_value(entry, exclude, float, regex)
]
for entry in natsort.natsorted(entries, reverse=args.reverse, alg=alg):
print(entry) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:natsort_key; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:val; 5, identifier:key; 6, identifier:string_func; 7, identifier:bytes_func; 8, identifier:num_func; 9, block; 9, 10; 9, 22; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:key; 13, None; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:val; 18, call; 18, 19; 18, 20; 19, identifier:key; 20, argument_list; 20, 21; 21, identifier:val; 22, try_statement; 22, 23; 22, 29; 23, block; 23, 24; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:string_func; 27, argument_list; 27, 28; 28, identifier:val; 29, except_clause; 29, 30; 29, 33; 30, tuple; 30, 31; 30, 32; 31, identifier:TypeError; 32, identifier:AttributeError; 33, block; 33, 34; 33, 48; 34, if_statement; 34, 35; 34, 42; 35, comparison_operator:in; 35, 36; 35, 40; 36, call; 36, 37; 36, 38; 37, identifier:type; 38, argument_list; 38, 39; 39, identifier:val; 40, tuple; 40, 41; 41, identifier:bytes; 42, block; 42, 43; 43, return_statement; 43, 44; 44, call; 44, 45; 44, 46; 45, identifier:bytes_func; 46, argument_list; 46, 47; 47, identifier:val; 48, try_statement; 48, 49; 48, 65; 49, block; 49, 50; 50, return_statement; 50, 51; 51, call; 51, 52; 51, 53; 52, identifier:tuple; 53, generator_expression; 53, 54; 53, 62; 54, call; 54, 55; 54, 56; 55, identifier:natsort_key; 56, argument_list; 56, 57; 56, 58; 56, 59; 56, 60; 56, 61; 57, identifier:x; 58, None; 59, identifier:string_func; 60, identifier:bytes_func; 61, identifier:num_func; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:x; 64, identifier:val; 65, except_clause; 65, 66; 65, 67; 66, identifier:TypeError; 67, block; 67, 68; 68, return_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:num_func; 71, argument_list; 71, 72; 72, identifier:val | def natsort_key(val, key, string_func, bytes_func, num_func):
if key is not None:
val = key(val)
try:
return string_func(val)
except (TypeError, AttributeError):
if type(val) in (bytes,):
return bytes_func(val)
try:
return tuple(
natsort_key(x, None, string_func, bytes_func, num_func) for x in val
)
except TypeError:
return num_func(val) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:parse_number_factory; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:alg; 5, identifier:sep; 6, identifier:pre_sep; 7, block; 7, 8; 7, 25; 7, 45; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:nan_replace; 11, conditional_expression:if; 11, 12; 11, 16; 11, 21; 12, call; 12, 13; 12, 14; 13, identifier:float; 14, argument_list; 14, 15; 15, string:"+inf"; 16, binary_operator:&; 16, 17; 16, 18; 17, identifier:alg; 18, attribute; 18, 19; 18, 20; 19, identifier:ns; 20, identifier:NANLAST; 21, call; 21, 22; 21, 23; 22, identifier:float; 23, argument_list; 23, 24; 24, string:"-inf"; 25, function_definition; 25, 26; 25, 27; 25, 35; 26, function_name:func; 27, parameters; 27, 28; 27, 29; 27, 32; 28, identifier:val; 29, default_parameter; 29, 30; 29, 31; 30, identifier:_nan_replace; 31, identifier:nan_replace; 32, default_parameter; 32, 33; 32, 34; 33, identifier:_sep; 34, identifier:sep; 35, block; 35, 36; 36, return_statement; 36, 37; 37, expression_list; 37, 38; 37, 39; 38, identifier:_sep; 39, conditional_expression:if; 39, 40; 39, 41; 39, 44; 40, identifier:_nan_replace; 41, comparison_operator:!=; 41, 42; 41, 43; 42, identifier:val; 43, identifier:val; 44, identifier:val; 45, if_statement; 45, 46; 45, 63; 45, 76; 45, 100; 45, 116; 46, boolean_operator:and; 46, 47; 46, 58; 47, boolean_operator:and; 47, 48; 47, 53; 48, binary_operator:&; 48, 49; 48, 50; 49, identifier:alg; 50, attribute; 50, 51; 50, 52; 51, identifier:ns; 52, identifier:PATH; 53, binary_operator:&; 53, 54; 53, 55; 54, identifier:alg; 55, attribute; 55, 56; 55, 57; 56, identifier:ns; 57, identifier:UNGROUPLETTERS; 58, binary_operator:&; 58, 59; 58, 60; 59, identifier:alg; 60, attribute; 60, 61; 60, 62; 61, identifier:ns; 62, identifier:LOCALEALPHA; 63, block; 63, 64; 64, return_statement; 64, 65; 65, lambda; 65, 66; 65, 68; 66, lambda_parameters; 66, 67; 67, identifier:x; 68, tuple; 68, 69; 69, tuple; 69, 70; 69, 72; 70, tuple; 70, 71; 71, identifier:pre_sep; 72, call; 72, 73; 72, 74; 73, identifier:func; 74, argument_list; 74, 75; 75, identifier:x; 76, elif_clause; 76, 77; 76, 88; 77, boolean_operator:and; 77, 78; 77, 83; 78, binary_operator:&; 78, 79; 78, 80; 79, identifier:alg; 80, attribute; 80, 81; 80, 82; 81, identifier:ns; 82, identifier:UNGROUPLETTERS; 83, binary_operator:&; 83, 84; 83, 85; 84, identifier:alg; 85, attribute; 85, 86; 85, 87; 86, identifier:ns; 87, identifier:LOCALEALPHA; 88, block; 88, 89; 89, return_statement; 89, 90; 90, lambda; 90, 91; 90, 93; 91, lambda_parameters; 91, 92; 92, identifier:x; 93, tuple; 93, 94; 93, 96; 94, tuple; 94, 95; 95, identifier:pre_sep; 96, call; 96, 97; 96, 98; 97, identifier:func; 98, argument_list; 98, 99; 99, identifier:x; 100, elif_clause; 100, 101; 100, 106; 101, binary_operator:&; 101, 102; 101, 103; 102, identifier:alg; 103, attribute; 103, 104; 103, 105; 104, identifier:ns; 105, identifier:PATH; 106, block; 106, 107; 107, return_statement; 107, 108; 108, lambda; 108, 109; 108, 111; 109, lambda_parameters; 109, 110; 110, identifier:x; 111, tuple; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:func; 114, argument_list; 114, 115; 115, identifier:x; 116, else_clause; 116, 117; 117, block; 117, 118; 118, return_statement; 118, 119; 119, identifier:func | def parse_number_factory(alg, sep, pre_sep):
nan_replace = float("+inf") if alg & ns.NANLAST else float("-inf")
def func(val, _nan_replace=nan_replace, _sep=sep):
return _sep, _nan_replace if val != val else val
if alg & ns.PATH and alg & ns.UNGROUPLETTERS and alg & ns.LOCALEALPHA:
return lambda x: (((pre_sep,), func(x)),)
elif alg & ns.UNGROUPLETTERS and alg & ns.LOCALEALPHA:
return lambda x: ((pre_sep,), func(x))
elif alg & ns.PATH:
return lambda x: (func(x),)
else:
return func |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:natsort_keygen; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:key; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:alg; 9, attribute; 9, 10; 9, 11; 10, identifier:ns; 11, identifier:DEFAULT; 12, block; 12, 13; 12, 43; 12, 64; 12, 151; 12, 160; 12, 169; 12, 178; 12, 189; 12, 205; 12, 221; 12, 230; 12, 241; 13, try_statement; 13, 14; 13, 21; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, binary_operator:|; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:ns; 19, identifier:DEFAULT; 20, identifier:alg; 21, except_clause; 21, 22; 21, 23; 22, identifier:TypeError; 23, block; 23, 24; 23, 28; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:msg; 27, string:"natsort_keygen: 'alg' argument must be from the enum 'ns'"; 28, raise_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:ValueError; 31, argument_list; 31, 32; 32, binary_operator:+; 32, 33; 32, 34; 33, identifier:msg; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, string:", got {}"; 37, identifier:format; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:py23_str; 41, argument_list; 41, 42; 42, identifier:alg; 43, if_statement; 43, 44; 43, 59; 44, boolean_operator:and; 44, 45; 44, 50; 45, binary_operator:&; 45, 46; 45, 47; 46, identifier:alg; 47, attribute; 47, 48; 47, 49; 48, identifier:ns; 49, identifier:LOCALEALPHA; 50, call; 50, 51; 50, 58; 51, attribute; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:natsort; 55, identifier:compat; 56, identifier:locale; 57, identifier:dumb_sort; 58, argument_list; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, augmented_assignment:|=; 61, 62; 61, 63; 62, identifier:alg; 63, identifier:NS_DUMB; 64, if_statement; 64, 65; 64, 70; 64, 110; 65, binary_operator:&; 65, 66; 65, 67; 66, identifier:alg; 67, attribute; 67, 68; 67, 69; 68, identifier:ns; 69, identifier:NUMAFTER; 70, block; 70, 71; 70, 100; 71, if_statement; 71, 72; 71, 77; 71, 88; 72, binary_operator:&; 72, 73; 72, 74; 73, identifier:alg; 74, attribute; 74, 75; 74, 76; 75, identifier:ns; 76, identifier:LOCALEALPHA; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:sep; 81, attribute; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:natsort; 85, identifier:compat; 86, identifier:locale; 87, identifier:null_string_locale_max; 88, else_clause; 88, 89; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:sep; 93, attribute; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:natsort; 97, identifier:compat; 98, identifier:locale; 99, identifier:null_string_max; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:pre_sep; 103, attribute; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:natsort; 107, identifier:compat; 108, identifier:locale; 109, identifier:null_string_max; 110, else_clause; 110, 111; 111, block; 111, 112; 111, 141; 112, if_statement; 112, 113; 112, 118; 112, 129; 113, binary_operator:&; 113, 114; 113, 115; 114, identifier:alg; 115, attribute; 115, 116; 115, 117; 116, identifier:ns; 117, identifier:LOCALEALPHA; 118, block; 118, 119; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:sep; 122, attribute; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:natsort; 126, identifier:compat; 127, identifier:locale; 128, identifier:null_string_locale; 129, else_clause; 129, 130; 130, block; 130, 131; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:sep; 134, attribute; 134, 135; 134, 140; 135, attribute; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:natsort; 138, identifier:compat; 139, identifier:locale; 140, identifier:null_string; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:pre_sep; 144, attribute; 144, 145; 144, 150; 145, attribute; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:natsort; 148, identifier:compat; 149, identifier:locale; 150, identifier:null_string; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:regex; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:utils; 157, identifier:regex_chooser; 158, argument_list; 158, 159; 159, identifier:alg; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:input_transform; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:utils; 166, identifier:input_string_transform_factory; 167, argument_list; 167, 168; 168, identifier:alg; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:component_transform; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:utils; 175, identifier:string_component_transform_factory; 176, argument_list; 176, 177; 177, identifier:alg; 178, expression_statement; 178, 179; 179, assignment; 179, 180; 179, 181; 180, identifier:final_transform; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:utils; 184, identifier:final_data_transform_factory; 185, argument_list; 185, 186; 185, 187; 185, 188; 186, identifier:alg; 187, identifier:sep; 188, identifier:pre_sep; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:string_func; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:utils; 195, identifier:parse_string_factory; 196, argument_list; 196, 197; 196, 198; 196, 199; 196, 202; 196, 203; 196, 204; 197, identifier:alg; 198, identifier:sep; 199, attribute; 199, 200; 199, 201; 200, identifier:regex; 201, identifier:split; 202, identifier:input_transform; 203, identifier:component_transform; 204, identifier:final_transform; 205, if_statement; 205, 206; 205, 211; 206, binary_operator:&; 206, 207; 206, 208; 207, identifier:alg; 208, attribute; 208, 209; 208, 210; 209, identifier:ns; 210, identifier:PATH; 211, block; 211, 212; 212, expression_statement; 212, 213; 213, assignment; 213, 214; 213, 215; 214, identifier:string_func; 215, call; 215, 216; 215, 219; 216, attribute; 216, 217; 216, 218; 217, identifier:utils; 218, identifier:parse_path_factory; 219, argument_list; 219, 220; 220, identifier:string_func; 221, expression_statement; 221, 222; 222, assignment; 222, 223; 222, 224; 223, identifier:bytes_func; 224, call; 224, 225; 224, 228; 225, attribute; 225, 226; 225, 227; 226, identifier:utils; 227, identifier:parse_bytes_factory; 228, argument_list; 228, 229; 229, identifier:alg; 230, expression_statement; 230, 231; 231, assignment; 231, 232; 231, 233; 232, identifier:num_func; 233, call; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:utils; 236, identifier:parse_number_factory; 237, argument_list; 237, 238; 237, 239; 237, 240; 238, identifier:alg; 239, identifier:sep; 240, identifier:pre_sep; 241, return_statement; 241, 242; 242, call; 242, 243; 242, 244; 243, identifier:partial; 244, argument_list; 244, 245; 244, 248; 244, 251; 244, 254; 244, 257; 245, attribute; 245, 246; 245, 247; 246, identifier:utils; 247, identifier:natsort_key; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:key; 250, identifier:key; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:string_func; 253, identifier:string_func; 254, keyword_argument; 254, 255; 254, 256; 255, identifier:bytes_func; 256, identifier:bytes_func; 257, keyword_argument; 257, 258; 257, 259; 258, identifier:num_func; 259, identifier:num_func | def natsort_keygen(key=None, alg=ns.DEFAULT):
try:
ns.DEFAULT | alg
except TypeError:
msg = "natsort_keygen: 'alg' argument must be from the enum 'ns'"
raise ValueError(msg + ", got {}".format(py23_str(alg)))
if alg & ns.LOCALEALPHA and natsort.compat.locale.dumb_sort():
alg |= NS_DUMB
if alg & ns.NUMAFTER:
if alg & ns.LOCALEALPHA:
sep = natsort.compat.locale.null_string_locale_max
else:
sep = natsort.compat.locale.null_string_max
pre_sep = natsort.compat.locale.null_string_max
else:
if alg & ns.LOCALEALPHA:
sep = natsort.compat.locale.null_string_locale
else:
sep = natsort.compat.locale.null_string
pre_sep = natsort.compat.locale.null_string
regex = utils.regex_chooser(alg)
input_transform = utils.input_string_transform_factory(alg)
component_transform = utils.string_component_transform_factory(alg)
final_transform = utils.final_data_transform_factory(alg, sep, pre_sep)
string_func = utils.parse_string_factory(
alg, sep, regex.split, input_transform, component_transform, final_transform
)
if alg & ns.PATH:
string_func = utils.parse_path_factory(string_func)
bytes_func = utils.parse_bytes_factory(alg)
num_func = utils.parse_number_factory(alg, sep, pre_sep)
return partial(
utils.natsort_key,
key=key,
string_func=string_func,
bytes_func=bytes_func,
num_func=num_func,
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:natsorted; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:seq; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:alg; 13, attribute; 13, 14; 13, 15; 14, identifier:ns; 15, identifier:DEFAULT; 16, block; 16, 17; 16, 25; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:key; 20, call; 20, 21; 20, 22; 21, identifier:natsort_keygen; 22, argument_list; 22, 23; 22, 24; 23, identifier:key; 24, identifier:alg; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:sorted; 28, argument_list; 28, 29; 28, 30; 28, 33; 29, identifier:seq; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:reverse; 32, identifier:reverse; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:key; 35, identifier:key | def natsorted(seq, key=None, reverse=False, alg=ns.DEFAULT):
key = natsort_keygen(key, alg)
return sorted(seq, reverse=reverse, key=key) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:humansorted; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:seq; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:alg; 13, attribute; 13, 14; 13, 15; 14, identifier:ns; 15, identifier:DEFAULT; 16, block; 16, 17; 17, return_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:natsorted; 20, argument_list; 20, 21; 20, 22; 20, 23; 20, 24; 21, identifier:seq; 22, identifier:key; 23, identifier:reverse; 24, binary_operator:|; 24, 25; 24, 26; 25, identifier:alg; 26, attribute; 26, 27; 26, 28; 27, identifier:ns; 28, identifier:LOCALE | def humansorted(seq, key=None, reverse=False, alg=ns.DEFAULT):
return natsorted(seq, key, reverse, alg | ns.LOCALE) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:realsorted; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:seq; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:alg; 13, attribute; 13, 14; 13, 15; 14, identifier:ns; 15, identifier:DEFAULT; 16, block; 16, 17; 17, return_statement; 17, 18; 18, call; 18, 19; 18, 20; 19, identifier:natsorted; 20, argument_list; 20, 21; 20, 22; 20, 23; 20, 24; 21, identifier:seq; 22, identifier:key; 23, identifier:reverse; 24, binary_operator:|; 24, 25; 24, 26; 25, identifier:alg; 26, attribute; 26, 27; 26, 28; 27, identifier:ns; 28, identifier:REAL | def realsorted(seq, key=None, reverse=False, alg=ns.DEFAULT):
return natsorted(seq, key, reverse, alg | ns.REAL) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:index_natsorted; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:seq; 5, default_parameter; 5, 6; 5, 7; 6, identifier:key; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:alg; 13, attribute; 13, 14; 13, 15; 14, identifier:ns; 15, identifier:DEFAULT; 16, block; 16, 17; 16, 47; 16, 62; 16, 78; 17, if_statement; 17, 18; 17, 21; 17, 29; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:key; 20, None; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:newkey; 25, call; 25, 26; 25, 27; 26, identifier:itemgetter; 27, argument_list; 27, 28; 28, integer:1; 29, else_clause; 29, 30; 30, block; 30, 31; 31, function_definition; 31, 32; 31, 33; 31, 35; 32, function_name:newkey; 33, parameters; 33, 34; 34, identifier:x; 35, block; 35, 36; 36, return_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:key; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 45; 41, call; 41, 42; 41, 43; 42, identifier:itemgetter; 43, argument_list; 43, 44; 44, integer:1; 45, argument_list; 45, 46; 46, identifier:x; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:index_seq_pair; 50, list_comprehension; 50, 51; 50, 54; 51, list:[x, y]; 51, 52; 51, 53; 52, identifier:x; 53, identifier:y; 54, for_in_clause; 54, 55; 54, 58; 55, pattern_list; 55, 56; 55, 57; 56, identifier:x; 57, identifier:y; 58, call; 58, 59; 58, 60; 59, identifier:enumerate; 60, argument_list; 60, 61; 61, identifier:seq; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:index_seq_pair; 66, identifier:sort; 67, argument_list; 67, 68; 67, 71; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:reverse; 70, identifier:reverse; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:key; 73, call; 73, 74; 73, 75; 74, identifier:natsort_keygen; 75, argument_list; 75, 76; 75, 77; 76, identifier:newkey; 77, identifier:alg; 78, return_statement; 78, 79; 79, list_comprehension; 79, 80; 79, 81; 80, identifier:x; 81, for_in_clause; 81, 82; 81, 85; 82, pattern_list; 82, 83; 82, 84; 83, identifier:x; 84, identifier:_; 85, identifier:index_seq_pair | def index_natsorted(seq, key=None, reverse=False, alg=ns.DEFAULT):
if key is None:
newkey = itemgetter(1)
else:
def newkey(x):
return key(itemgetter(1)(x))
index_seq_pair = [[x, y] for x, y in enumerate(seq)]
index_seq_pair.sort(reverse=reverse, key=natsort_keygen(newkey, alg))
return [x for x, _ in index_seq_pair] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:order_by_index; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:seq; 5, identifier:index; 6, default_parameter; 6, 7; 6, 8; 7, identifier:iter; 8, False; 9, block; 9, 10; 10, return_statement; 10, 11; 11, conditional_expression:if; 11, 12; 11, 19; 11, 20; 12, generator_expression; 12, 13; 12, 16; 13, subscript; 13, 14; 13, 15; 14, identifier:seq; 15, identifier:i; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:i; 18, identifier:index; 19, identifier:iter; 20, list_comprehension; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:seq; 23, identifier:i; 24, for_in_clause; 24, 25; 24, 26; 25, identifier:i; 26, identifier:index | def order_by_index(seq, index, iter=False):
return (seq[i] for i in index) if iter else [seq[i] for i in index] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:find_records; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:collection_name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:query; 8, dictionary; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort_by; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:sort_direction; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:start; 17, integer:0; 18, default_parameter; 18, 19; 18, 20; 19, identifier:limit; 20, None; 21, block; 21, 22; 21, 36; 21, 52; 21, 61; 21, 75; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:cursor; 25, call; 25, 26; 25, 34; 26, attribute; 26, 27; 26, 33; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_get_collection; 31, argument_list; 31, 32; 32, identifier:collection_name; 33, identifier:find; 34, argument_list; 34, 35; 35, identifier:query; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:sort_by; 39, None; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:cursor; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_apply_sort; 48, argument_list; 48, 49; 48, 50; 48, 51; 49, identifier:cursor; 50, identifier:sort_by; 51, identifier:sort_direction; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:cursor; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:cursor; 58, identifier:skip; 59, argument_list; 59, 60; 60, identifier:start; 61, if_statement; 61, 62; 61, 65; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:limit; 64, None; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:cursor; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:cursor; 72, identifier:limit; 73, argument_list; 73, 74; 74, identifier:limit; 75, return_statement; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:MongoDbCursor; 78, argument_list; 78, 79; 79, identifier:cursor | def find_records(self, collection_name, query={}, sort_by=None,
sort_direction=None, start=0, limit=None):
cursor = self._get_collection(collection_name).find(query)
if sort_by is not None:
cursor = self._apply_sort(cursor, sort_by, sort_direction)
cursor = cursor.skip(start)
if limit is not None:
cursor = cursor.limit(limit)
return MongoDbCursor(cursor) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_apply_sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cursor; 5, identifier:sort_by; 6, identifier:sort_direction; 7, block; 7, 8; 7, 35; 8, if_statement; 8, 9; 8, 20; 8, 27; 9, boolean_operator:and; 9, 10; 9, 13; 10, comparison_operator:is; 10, 11; 10, 12; 11, identifier:sort_direction; 12, None; 13, comparison_operator:==; 13, 14; 13, 19; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:sort_direction; 17, identifier:lower; 18, argument_list; 19, string:"desc"; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:sort; 24, attribute; 24, 25; 24, 26; 25, identifier:pymongo; 26, identifier:DESCENDING; 27, else_clause; 27, 28; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:sort; 32, attribute; 32, 33; 32, 34; 33, identifier:pymongo; 34, identifier:ASCENDING; 35, return_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:cursor; 39, identifier:sort; 40, argument_list; 40, 41; 40, 42; 41, identifier:sort_by; 42, identifier:sort | def _apply_sort(cursor, sort_by, sort_direction):
if sort_direction is not None and sort_direction.lower() == "desc":
sort = pymongo.DESCENDING
else:
sort = pymongo.ASCENDING
return cursor.sort(sort_by, sort) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:get_runs; 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:sort_by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort_direction; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:start; 13, integer:0; 14, default_parameter; 14, 15; 14, 16; 15, identifier:limit; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:query; 19, dictionary; 19, 20; 19, 23; 20, pair; 20, 21; 20, 22; 21, string:"type"; 22, string:"and"; 23, pair; 23, 24; 23, 25; 24, string:"filters"; 25, list:[]; 26, block; 26, 27; 26, 38; 26, 74; 26, 81; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:all_run_ids; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:os; 33, identifier:listdir; 34, argument_list; 34, 35; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:directory; 38, function_definition; 38, 39; 38, 40; 38, 41; 39, function_name:run_iterator; 40, parameters; 41, block; 41, 42; 41, 50; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:blacklist; 45, call; 45, 46; 45, 47; 46, identifier:set; 47, argument_list; 47, 48; 48, list:["_sources"]; 48, 49; 49, string:"_sources"; 50, for_statement; 50, 51; 50, 52; 50, 53; 51, identifier:id; 52, identifier:all_run_ids; 53, block; 53, 54; 53, 60; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:in; 55, 56; 55, 57; 56, identifier:id; 57, identifier:blacklist; 58, block; 58, 59; 59, continue_statement; 60, try_statement; 60, 61; 60, 70; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, yield; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:get; 68, argument_list; 68, 69; 69, identifier:id; 70, except_clause; 70, 71; 70, 72; 71, identifier:FileNotFoundError; 72, block; 72, 73; 73, pass_statement; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:count; 77, call; 77, 78; 77, 79; 78, identifier:len; 79, argument_list; 79, 80; 80, identifier:all_run_ids; 81, return_statement; 81, 82; 82, call; 82, 83; 82, 84; 83, identifier:FileStoreCursor; 84, argument_list; 84, 85; 84, 86; 85, identifier:count; 86, call; 86, 87; 86, 88; 87, identifier:run_iterator; 88, argument_list | def get_runs(self, sort_by=None, sort_direction=None, start=0, limit=None, query={"type": "and", "filters": []}):
all_run_ids = os.listdir(self.directory)
def run_iterator():
blacklist = set(["_sources"])
for id in all_run_ids:
if id in blacklist:
continue
try:
yield self.get(id)
except FileNotFoundError:
pass
count = len(all_run_ids)
return FileStoreCursor(count, run_iterator()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:get_runs; 3, parameters; 4, block; 4, 5; 4, 13; 4, 21; 4, 29; 4, 38; 4, 47; 4, 58; 4, 69; 4, 75; 4, 106; 4, 133; 4, 141; 4, 149; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:data; 8, subscript; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:current_app; 11, identifier:config; 12, string:"data"; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:draw; 16, call; 16, 17; 16, 18; 17, identifier:parse_int_arg; 18, argument_list; 18, 19; 18, 20; 19, string:"draw"; 20, integer:1; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:start; 24, call; 24, 25; 24, 26; 25, identifier:parse_int_arg; 26, argument_list; 26, 27; 26, 28; 27, string:"start"; 28, integer:0; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:length; 32, call; 32, 33; 32, 34; 33, identifier:parse_int_arg; 34, argument_list; 34, 35; 34, 36; 35, string:"length"; 36, unary_operator:-; 36, 37; 37, integer:1; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:length; 41, conditional_expression:if; 41, 42; 41, 43; 41, 46; 42, identifier:length; 43, comparison_operator:>=; 43, 44; 43, 45; 44, identifier:length; 45, integer:0; 46, None; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:order_column; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:request; 54, identifier:args; 55, identifier:get; 56, argument_list; 56, 57; 57, string:"order[0][column]"; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:order_dir; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:request; 65, identifier:args; 66, identifier:get; 67, argument_list; 67, 68; 68, string:"order[0][dir]"; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:query; 72, call; 72, 73; 72, 74; 73, identifier:parse_query_filter; 74, argument_list; 75, if_statement; 75, 76; 75, 79; 76, comparison_operator:is; 76, 77; 76, 78; 77, identifier:order_column; 78, None; 79, block; 79, 80; 79, 97; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 81, 84; 82, identifier:order_column; 83, line_continuation:\; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:request; 88, identifier:args; 89, identifier:get; 90, argument_list; 90, 91; 91, binary_operator:%; 91, 92; 91, 93; 92, string:"columns[%d][name]"; 93, call; 93, 94; 93, 95; 94, identifier:int; 95, argument_list; 95, 96; 96, identifier:order_column; 97, if_statement; 97, 98; 97, 101; 98, comparison_operator:==; 98, 99; 98, 100; 99, identifier:order_column; 100, string:"hostname"; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:order_column; 105, string:"host.hostname"; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:runs; 109, call; 109, 110; 109, 117; 110, attribute; 110, 111; 110, 116; 111, call; 111, 112; 111, 115; 112, attribute; 112, 113; 112, 114; 113, identifier:data; 114, identifier:get_run_dao; 115, argument_list; 116, identifier:get_runs; 117, argument_list; 117, 118; 117, 121; 117, 124; 117, 127; 117, 130; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:start; 120, identifier:start; 121, keyword_argument; 121, 122; 121, 123; 122, identifier:limit; 123, identifier:length; 124, keyword_argument; 124, 125; 124, 126; 125, identifier:sort_by; 126, identifier:order_column; 127, keyword_argument; 127, 128; 127, 129; 128, identifier:sort_direction; 129, identifier:order_dir; 130, keyword_argument; 130, 131; 130, 132; 131, identifier:query; 132, identifier:query; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:records_total; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:runs; 139, identifier:count; 140, argument_list; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:records_filtered; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:runs; 147, identifier:count; 148, argument_list; 149, return_statement; 149, 150; 150, call; 150, 151; 150, 152; 151, identifier:Response; 152, argument_list; 152, 153; 152, 169; 153, call; 153, 154; 153, 155; 154, identifier:render_template; 155, argument_list; 155, 156; 155, 157; 155, 160; 155, 163; 155, 166; 156, string:"api/runs.js"; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:runs; 159, identifier:runs; 160, keyword_argument; 160, 161; 160, 162; 161, identifier:draw; 162, identifier:draw; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:recordsTotal; 165, identifier:records_total; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:recordsFiltered; 168, identifier:records_filtered; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:mimetype; 171, string:"application/json" | def get_runs():
data = current_app.config["data"]
draw = parse_int_arg("draw", 1)
start = parse_int_arg("start", 0)
length = parse_int_arg("length", -1)
length = length if length >= 0 else None
order_column = request.args.get("order[0][column]")
order_dir = request.args.get("order[0][dir]")
query = parse_query_filter()
if order_column is not None:
order_column = \
request.args.get("columns[%d][name]" % int(order_column))
if order_column == "hostname":
order_column = "host.hostname"
runs = data.get_run_dao().get_runs(
start=start, limit=length,
sort_by=order_column, sort_direction=order_dir, query=query)
records_total = runs.count()
records_filtered = runs.count()
return Response(render_template(
"api/runs.js", runs=runs,
draw=draw, recordsTotal=records_total,
recordsFiltered=records_filtered),
mimetype="application/json") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:generate_querystring; 3, parameters; 3, 4; 4, identifier:params; 5, block; 5, 6; 5, 12; 5, 16; 5, 92; 6, if_statement; 6, 7; 6, 9; 7, not_operator; 7, 8; 8, identifier:params; 9, block; 9, 10; 10, return_statement; 10, 11; 11, None; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:parts; 15, list:[]; 16, for_statement; 16, 17; 16, 20; 16, 28; 17, pattern_list; 17, 18; 17, 19; 18, identifier:param; 19, identifier:value; 20, call; 20, 21; 20, 22; 21, identifier:sorted; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:params; 26, identifier:items; 27, argument_list; 28, block; 28, 29; 29, if_statement; 29, 30; 29, 36; 29, 50; 30, not_operator; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:isinstance; 33, argument_list; 33, 34; 33, 35; 34, identifier:value; 35, identifier:dict; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:parts; 41, identifier:append; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 45; 44, identifier:urlencode; 45, argument_list; 45, 46; 46, dictionary; 46, 47; 47, pair; 47, 48; 47, 49; 48, identifier:param; 49, identifier:value; 50, else_clause; 50, 51; 51, block; 51, 52; 52, for_statement; 52, 53; 52, 56; 52, 64; 53, pattern_list; 53, 54; 53, 55; 54, identifier:key; 55, identifier:sub_value; 56, call; 56, 57; 56, 58; 57, identifier:sorted; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:value; 62, identifier:items; 63, argument_list; 64, block; 64, 65; 64, 79; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:composed; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, string:'{param}[{key}]'; 71, identifier:format; 72, argument_list; 72, 73; 72, 76; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:param; 75, identifier:param; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:key; 78, identifier:key; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:parts; 83, identifier:append; 84, argument_list; 84, 85; 85, call; 85, 86; 85, 87; 86, identifier:urlencode; 87, argument_list; 87, 88; 88, dictionary; 88, 89; 89, pair; 89, 90; 89, 91; 90, identifier:composed; 91, identifier:sub_value; 92, if_statement; 92, 93; 92, 94; 93, identifier:parts; 94, block; 94, 95; 95, return_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, string:'&'; 99, identifier:join; 100, argument_list; 100, 101; 101, identifier:parts | def generate_querystring(params):
if not params:
return None
parts = []
for param, value in sorted(params.items()):
if not isinstance(value, dict):
parts.append(urlencode({param: value}))
else:
for key, sub_value in sorted(value.items()):
composed = '{param}[{key}]'.format(param=param, key=key)
parts.append(urlencode({composed: sub_value}))
if parts:
return '&'.join(parts) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:filter_catalog; 3, parameters; 3, 4; 3, 5; 4, identifier:catalog; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 18; 7, 28; 7, 38; 7, 48; 7, 54; 7, 61; 7, 70; 7, 79; 7, 92; 7, 101; 7, 111; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:bright_limit; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:kwargs; 14, identifier:get; 15, argument_list; 15, 16; 15, 17; 16, string:'bright_limit'; 17, float:1.00; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:max_bright; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:kwargs; 24, identifier:get; 25, argument_list; 25, 26; 25, 27; 26, string:'max_bright'; 27, None; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:min_bright; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:kwargs; 34, identifier:get; 35, argument_list; 35, 36; 35, 37; 36, string:'min_bright'; 37, integer:20; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:colname; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:kwargs; 44, identifier:get; 45, argument_list; 45, 46; 45, 47; 46, string:'colname'; 47, string:'vegamag'; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:phot_column; 51, subscript; 51, 52; 51, 53; 52, identifier:catalog; 53, identifier:colname; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:num_sources; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, identifier:phot_column; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:sort_indx; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:np; 67, identifier:argsort; 68, argument_list; 68, 69; 69, identifier:phot_column; 70, if_statement; 70, 71; 70, 74; 71, comparison_operator:is; 71, 72; 71, 73; 72, identifier:max_bright; 73, None; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:max_bright; 78, identifier:num_sources; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:limit_num; 82, call; 82, 83; 82, 84; 83, identifier:max; 84, argument_list; 84, 85; 84, 91; 85, call; 85, 86; 85, 87; 86, identifier:int; 87, argument_list; 87, 88; 88, binary_operator:*; 88, 89; 88, 90; 89, identifier:num_sources; 90, identifier:bright_limit; 91, identifier:min_bright; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:limit_num; 95, call; 95, 96; 95, 97; 96, identifier:min; 97, argument_list; 97, 98; 97, 99; 97, 100; 98, identifier:max_bright; 99, identifier:limit_num; 100, identifier:num_sources; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:new_catalog; 104, subscript; 104, 105; 104, 106; 105, identifier:catalog; 106, subscript; 106, 107; 106, 108; 107, identifier:sort_indx; 108, slice; 108, 109; 108, 110; 109, colon; 110, identifier:limit_num; 111, return_statement; 111, 112; 112, identifier:new_catalog | def filter_catalog(catalog, **kwargs):
bright_limit = kwargs.get('bright_limit', 1.00)
max_bright = kwargs.get('max_bright', None)
min_bright = kwargs.get('min_bright', 20)
colname = kwargs.get('colname', 'vegamag')
phot_column = catalog[colname]
num_sources = len(phot_column)
sort_indx = np.argsort(phot_column)
if max_bright is None:
max_bright = num_sources
limit_num = max(int(num_sources * bright_limit), min_bright)
limit_num = min(max_bright, limit_num, num_sources)
new_catalog = catalog[sort_indx[:limit_num]]
return new_catalog |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sort_timeseries; 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, 17; 8, 21; 8, 36; 8, 54; 8, 60; 9, if_statement; 9, 10; 9, 15; 10, boolean_operator:and; 10, 11; 10, 12; 11, identifier:ascending; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_sorted; 15, block; 15, 16; 16, return_statement; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:sortorder; 20, integer:1; 21, if_statement; 21, 22; 21, 24; 22, not_operator; 22, 23; 23, identifier:ascending; 24, block; 24, 25; 24, 30; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:sortorder; 28, unary_operator:-; 28, 29; 29, integer:1; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_predefinedSorted; 35, False; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_timeseriesData; 42, identifier:sort; 43, argument_list; 43, 44; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:key; 46, lambda; 46, 47; 46, 49; 47, lambda_parameters; 47, 48; 48, identifier:i; 49, binary_operator:*; 49, 50; 49, 51; 50, identifier:sortorder; 51, subscript; 51, 52; 51, 53; 52, identifier:i; 53, integer:0; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:_sorted; 59, identifier:ascending; 60, return_statement; 60, 61; 61, identifier:self | def sort_timeseries(self, ascending=True):
if ascending and self._sorted:
return
sortorder = 1
if not ascending:
sortorder = -1
self._predefinedSorted = False
self._timeseriesData.sort(key=lambda i: sortorder * i[0])
self._sorted = ascending
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sorted_timeseries; 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, 13; 8, 22; 8, 41; 8, 50; 8, 62; 8, 68; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sortorder; 12, integer:1; 13, if_statement; 13, 14; 13, 16; 14, not_operator; 14, 15; 15, identifier:ascending; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:sortorder; 20, unary_operator:-; 20, 21; 21, integer:1; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:data; 25, call; 25, 26; 25, 27; 26, identifier:sorted; 27, argument_list; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_timeseriesData; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:key; 33, lambda; 33, 34; 33, 36; 34, lambda_parameters; 34, 35; 35, identifier:i; 36, binary_operator:*; 36, 37; 36, 38; 37, identifier:sortorder; 38, subscript; 38, 39; 38, 40; 39, identifier:i; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:newTS; 44, call; 44, 45; 44, 46; 45, identifier:TimeSeries; 46, argument_list; 46, 47; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_normalized; 50, for_statement; 50, 51; 50, 52; 50, 53; 51, identifier:entry; 52, identifier:data; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:newTS; 58, identifier:add_entry; 59, argument_list; 59, 60; 60, list_splat; 60, 61; 61, identifier:entry; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:newTS; 66, identifier:_sorted; 67, identifier:ascending; 68, return_statement; 68, 69; 69, identifier:newTS | def sorted_timeseries(self, ascending=True):
sortorder = 1
if not ascending:
sortorder = -1
data = sorted(self._timeseriesData, key=lambda i: sortorder * i[0])
newTS = TimeSeries(self._normalized)
for entry in data:
newTS.add_entry(*entry)
newTS._sorted = ascending
return newTS |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_calculate_values_to_forecast; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:timeSeries; 6, block; 6, 7; 6, 15; 6, 28; 6, 41; 6, 57; 6, 70; 7, if_statement; 7, 8; 7, 13; 8, comparison_operator:is; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:_forecastUntil; 12, None; 13, block; 13, 14; 14, return_statement; 15, if_statement; 15, 16; 15, 22; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:timeSeries; 20, identifier:is_sorted; 21, argument_list; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:ValueError; 26, argument_list; 26, 27; 27, string:"timeSeries has to be sorted."; 28, if_statement; 28, 29; 28, 35; 29, not_operator; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:timeSeries; 33, identifier:is_normalized; 34, argument_list; 35, block; 35, 36; 36, raise_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:ValueError; 39, argument_list; 39, 40; 40, string:"timeSeries has to be normalized."; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:timediff; 44, binary_operator:-; 44, 45; 44, 51; 45, subscript; 45, 46; 45, 50; 46, subscript; 46, 47; 46, 48; 47, identifier:timeSeries; 48, unary_operator:-; 48, 49; 49, integer:1; 50, integer:0; 51, subscript; 51, 52; 51, 56; 52, subscript; 52, 53; 52, 54; 53, identifier:timeSeries; 54, unary_operator:-; 54, 55; 55, integer:2; 56, integer:0; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:forecastSpan; 60, binary_operator:-; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:_forecastUntil; 64, subscript; 64, 65; 64, 69; 65, subscript; 65, 66; 65, 67; 66, identifier:timeSeries; 67, unary_operator:-; 67, 68; 68, integer:1; 69, integer:0; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:set_parameter; 75, argument_list; 75, 76; 75, 77; 76, string:"valuesToForecast"; 77, binary_operator:+; 77, 78; 77, 84; 78, call; 78, 79; 78, 80; 79, identifier:int; 80, argument_list; 80, 81; 81, binary_operator:/; 81, 82; 81, 83; 82, identifier:forecastSpan; 83, identifier:timediff; 84, integer:1 | def _calculate_values_to_forecast(self, timeSeries):
if self._forecastUntil is None:
return
if not timeSeries.is_sorted():
raise ValueError("timeSeries has to be sorted.")
if not timeSeries.is_normalized():
raise ValueError("timeSeries has to be normalized.")
timediff = timeSeries[-1][0] - timeSeries[-2][0]
forecastSpan = self._forecastUntil - timeSeries[-1][0]
self.set_parameter("valuesToForecast", int(forecastSpan / timediff) + 1) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:get_bucket; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:bucket; 6, default_parameter; 6, 7; 6, 8; 7, identifier:marker; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:max_keys; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:prefix; 14, None; 15, block; 15, 16; 15, 20; 15, 34; 15, 51; 15, 65; 15, 83; 15, 107; 15, 121; 15, 130; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:args; 19, list:[]; 20, if_statement; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:marker; 23, None; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:args; 29, identifier:append; 30, argument_list; 30, 31; 31, tuple; 31, 32; 31, 33; 32, string:"marker"; 33, identifier:marker; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:is; 35, 36; 35, 37; 36, identifier:max_keys; 37, None; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:args; 43, identifier:append; 44, argument_list; 44, 45; 45, tuple; 45, 46; 45, 47; 46, string:"max-keys"; 47, binary_operator:%; 47, 48; 47, 49; 48, string:"%d"; 49, tuple; 49, 50; 50, identifier:max_keys; 51, if_statement; 51, 52; 51, 55; 52, comparison_operator:is; 52, 53; 52, 54; 53, identifier:prefix; 54, None; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:args; 60, identifier:append; 61, argument_list; 61, 62; 62, tuple; 62, 63; 62, 64; 63, string:"prefix"; 64, identifier:prefix; 65, if_statement; 65, 66; 65, 67; 65, 77; 66, identifier:args; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:object_name; 71, binary_operator:+; 71, 72; 71, 73; 72, string:"?"; 73, call; 73, 74; 73, 75; 74, identifier:urlencode; 75, argument_list; 75, 76; 76, identifier:args; 77, else_clause; 77, 78; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:object_name; 82, None; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:details; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:_details; 90, argument_list; 90, 91; 90, 94; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:method; 93, string:b"GET"; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:url_context; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:self; 99, identifier:_url_context; 100, argument_list; 100, 101; 100, 104; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:bucket; 103, identifier:bucket; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:object_name; 106, identifier:object_name; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:d; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:_submit; 114, argument_list; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_query_factory; 119, argument_list; 119, 120; 120, identifier:details; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:d; 125, identifier:addCallback; 126, argument_list; 126, 127; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:_parse_get_bucket; 130, return_statement; 130, 131; 131, identifier:d | def get_bucket(self, bucket, marker=None, max_keys=None, prefix=None):
args = []
if marker is not None:
args.append(("marker", marker))
if max_keys is not None:
args.append(("max-keys", "%d" % (max_keys,)))
if prefix is not None:
args.append(("prefix", prefix))
if args:
object_name = "?" + urlencode(args)
else:
object_name = None
details = self._details(
method=b"GET",
url_context=self._url_context(bucket=bucket, object_name=object_name),
)
d = self._submit(self._query_factory(details))
d.addCallback(self._parse_get_bucket)
return d |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:findunique; 3, parameters; 3, 4; 3, 5; 4, identifier:lst; 5, identifier:key; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:sorted; 10, argument_list; 10, 11; 11, call; 11, 12; 11, 13; 12, identifier:set; 13, argument_list; 13, 14; 14, list_comprehension; 14, 15; 14, 22; 15, subscript; 15, 16; 15, 17; 16, identifier:item; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:key; 20, identifier:lower; 21, argument_list; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:item; 24, identifier:lst | def findunique(lst, key):
return sorted(set([item[key.lower()] for item in lst])) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:make_input_dataframe_by_entity; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:tax_benefit_system; 5, identifier:nb_persons; 6, identifier:nb_groups; 7, block; 7, 8; 7, 14; 7, 30; 7, 39; 7, 45; 7, 65; 7, 76; 7, 98; 7, 110; 7, 122; 7, 127; 7, 172; 7, 277; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:input_dataframe_by_entity; 11, call; 11, 12; 11, 13; 12, identifier:dict; 13, argument_list; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:person_entity; 17, subscript; 17, 18; 17, 29; 18, list_comprehension; 18, 19; 18, 20; 18, 25; 19, identifier:entity; 20, for_in_clause; 20, 21; 20, 22; 21, identifier:entity; 22, attribute; 22, 23; 22, 24; 23, identifier:tax_benefit_system; 24, identifier:entities; 25, if_clause; 25, 26; 26, attribute; 26, 27; 26, 28; 27, identifier:entity; 28, identifier:is_person; 29, integer:0; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:person_id; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:np; 36, identifier:arange; 37, argument_list; 37, 38; 38, identifier:nb_persons; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:input_dataframe_by_entity; 42, call; 42, 43; 42, 44; 43, identifier:dict; 44, argument_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 52; 47, subscript; 47, 48; 47, 49; 48, identifier:input_dataframe_by_entity; 49, attribute; 49, 50; 49, 51; 50, identifier:person_entity; 51, identifier:key; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:pd; 55, identifier:DataFrame; 56, argument_list; 56, 57; 57, dictionary; 57, 58; 58, pair; 58, 59; 58, 64; 59, binary_operator:+; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:person_entity; 62, identifier:key; 63, string:'_id'; 64, identifier:person_id; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 74; 67, attribute; 67, 68; 67, 73; 68, subscript; 68, 69; 68, 70; 69, identifier:input_dataframe_by_entity; 70, attribute; 70, 71; 70, 72; 71, identifier:person_entity; 72, identifier:key; 73, identifier:set_index; 74, argument_list; 74, 75; 75, string:'person_id'; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:adults; 79, binary_operator:+; 79, 80; 79, 82; 80, list:[0]; 80, 81; 81, integer:0; 82, call; 82, 83; 82, 84; 83, identifier:sorted; 84, argument_list; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:random; 88, identifier:sample; 89, argument_list; 89, 90; 89, 95; 90, call; 90, 91; 90, 92; 91, identifier:range; 92, argument_list; 92, 93; 92, 94; 93, integer:1; 94, identifier:nb_persons; 95, binary_operator:-; 95, 96; 95, 97; 96, identifier:nb_groups; 97, integer:1; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:members_entity_id; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:np; 104, identifier:empty; 105, argument_list; 105, 106; 105, 107; 106, identifier:nb_persons; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:dtype; 109, identifier:int; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:members_legacy_role; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:np; 116, identifier:empty; 117, argument_list; 117, 118; 117, 119; 118, identifier:nb_persons; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:dtype; 121, identifier:int; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:id_group; 125, unary_operator:-; 125, 126; 126, integer:1; 127, for_statement; 127, 128; 127, 129; 127, 133; 128, identifier:id_person; 129, call; 129, 130; 129, 131; 130, identifier:range; 131, argument_list; 131, 132; 132, identifier:nb_persons; 133, block; 133, 134; 133, 160; 133, 166; 134, if_statement; 134, 135; 134, 138; 134, 147; 135, comparison_operator:in; 135, 136; 135, 137; 136, identifier:id_person; 137, identifier:adults; 138, block; 138, 139; 138, 143; 139, expression_statement; 139, 140; 140, augmented_assignment:+=; 140, 141; 140, 142; 141, identifier:id_group; 142, integer:1; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:legacy_role; 146, integer:0; 147, else_clause; 147, 148; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:legacy_role; 152, conditional_expression:if; 152, 153; 152, 154; 152, 157; 153, integer:2; 154, comparison_operator:==; 154, 155; 154, 156; 155, identifier:legacy_role; 156, integer:0; 157, binary_operator:+; 157, 158; 157, 159; 158, identifier:legacy_role; 159, integer:1; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 165; 162, subscript; 162, 163; 162, 164; 163, identifier:members_legacy_role; 164, identifier:id_person; 165, identifier:legacy_role; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 171; 168, subscript; 168, 169; 168, 170; 169, identifier:members_entity_id; 170, identifier:id_person; 171, identifier:id_group; 172, for_statement; 172, 173; 172, 174; 172, 177; 173, identifier:entity; 174, attribute; 174, 175; 174, 176; 175, identifier:tax_benefit_system; 176, identifier:entities; 177, block; 177, 178; 177, 184; 177, 190; 177, 198; 177, 206; 177, 214; 177, 244; 177, 263; 178, if_statement; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:entity; 181, identifier:is_person; 182, block; 182, 183; 183, continue_statement; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:key; 187, attribute; 187, 188; 187, 189; 188, identifier:entity; 189, identifier:key; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:person_dataframe; 193, subscript; 193, 194; 193, 195; 194, identifier:input_dataframe_by_entity; 195, attribute; 195, 196; 195, 197; 196, identifier:person_entity; 197, identifier:key; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 205; 200, subscript; 200, 201; 200, 202; 201, identifier:person_dataframe; 202, binary_operator:+; 202, 203; 202, 204; 203, identifier:key; 204, string:'_id'; 205, identifier:members_entity_id; 206, expression_statement; 206, 207; 207, assignment; 207, 208; 207, 213; 208, subscript; 208, 209; 208, 210; 209, identifier:person_dataframe; 210, binary_operator:+; 210, 211; 210, 212; 211, identifier:key; 212, string:'_legacy_role'; 213, identifier:members_legacy_role; 214, expression_statement; 214, 215; 215, assignment; 215, 216; 215, 221; 216, subscript; 216, 217; 216, 218; 217, identifier:person_dataframe; 218, binary_operator:+; 218, 219; 218, 220; 219, identifier:key; 220, string:'_role'; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:np; 224, identifier:where; 225, argument_list; 225, 226; 225, 229; 225, 236; 226, comparison_operator:==; 226, 227; 226, 228; 227, identifier:members_legacy_role; 228, integer:0; 229, attribute; 229, 230; 229, 235; 230, subscript; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:entity; 233, identifier:flattened_roles; 234, integer:0; 235, identifier:key; 236, attribute; 236, 237; 236, 243; 237, subscript; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:entity; 240, identifier:flattened_roles; 241, unary_operator:-; 241, 242; 242, integer:1; 243, identifier:key; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 249; 246, subscript; 246, 247; 246, 248; 247, identifier:input_dataframe_by_entity; 248, identifier:key; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:pd; 252, identifier:DataFrame; 253, argument_list; 253, 254; 254, dictionary; 254, 255; 255, pair; 255, 256; 255, 259; 256, binary_operator:+; 256, 257; 256, 258; 257, identifier:key; 258, string:'_id'; 259, call; 259, 260; 259, 261; 260, identifier:range; 261, argument_list; 261, 262; 262, identifier:nb_groups; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 270; 265, attribute; 265, 266; 265, 269; 266, subscript; 266, 267; 266, 268; 267, identifier:input_dataframe_by_entity; 268, identifier:key; 269, identifier:set_index; 270, argument_list; 270, 271; 270, 274; 271, binary_operator:+; 271, 272; 271, 273; 272, identifier:key; 273, string:'_id'; 274, keyword_argument; 274, 275; 274, 276; 275, identifier:inplace; 276, True; 277, return_statement; 277, 278; 278, identifier:input_dataframe_by_entity | def make_input_dataframe_by_entity(tax_benefit_system, nb_persons, nb_groups):
input_dataframe_by_entity = dict()
person_entity = [entity for entity in tax_benefit_system.entities if entity.is_person][0]
person_id = np.arange(nb_persons)
input_dataframe_by_entity = dict()
input_dataframe_by_entity[person_entity.key] = pd.DataFrame({
person_entity.key + '_id': person_id,
})
input_dataframe_by_entity[person_entity.key].set_index('person_id')
adults = [0] + sorted(random.sample(range(1, nb_persons), nb_groups - 1))
members_entity_id = np.empty(nb_persons, dtype = int)
members_legacy_role = np.empty(nb_persons, dtype = int)
id_group = -1
for id_person in range(nb_persons):
if id_person in adults:
id_group += 1
legacy_role = 0
else:
legacy_role = 2 if legacy_role == 0 else legacy_role + 1
members_legacy_role[id_person] = legacy_role
members_entity_id[id_person] = id_group
for entity in tax_benefit_system.entities:
if entity.is_person:
continue
key = entity.key
person_dataframe = input_dataframe_by_entity[person_entity.key]
person_dataframe[key + '_id'] = members_entity_id
person_dataframe[key + '_legacy_role'] = members_legacy_role
person_dataframe[key + '_role'] = np.where(
members_legacy_role == 0, entity.flattened_roles[0].key, entity.flattened_roles[-1].key)
input_dataframe_by_entity[key] = pd.DataFrame({
key + '_id': range(nb_groups)
})
input_dataframe_by_entity[key].set_index(key + '_id', inplace = True)
return input_dataframe_by_entity |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:multi_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:remotes; 5, identifier:sort; 6, block; 6, 7; 6, 13; 6, 19; 6, 74; 6, 91; 6, 97; 6, 168; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:exploded_alpha; 10, call; 10, 11; 10, 12; 11, identifier:list; 12, argument_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:exploded_semver; 16, call; 16, 17; 16, 18; 17, identifier:list; 18, argument_list; 19, if_statement; 19, 20; 19, 23; 20, comparison_operator:in; 20, 21; 20, 22; 21, string:'alpha'; 22, identifier:sort; 23, block; 23, 24; 23, 39; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:alpha_max_len; 27, call; 27, 28; 27, 29; 28, identifier:max; 29, generator_expression; 29, 30; 29, 36; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, subscript; 33, 34; 33, 35; 34, identifier:r; 35, string:'name'; 36, for_in_clause; 36, 37; 36, 38; 37, identifier:r; 38, identifier:remotes; 39, for_statement; 39, 40; 39, 41; 39, 48; 40, identifier:name; 41, generator_expression; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:r; 44, string:'name'; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:r; 47, identifier:remotes; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:exploded_alpha; 53, identifier:append; 54, argument_list; 54, 55; 55, binary_operator:+; 55, 56; 55, 64; 56, list_comprehension; 56, 57; 56, 61; 57, call; 57, 58; 57, 59; 58, identifier:ord; 59, argument_list; 59, 60; 60, identifier:i; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:i; 63, identifier:name; 64, binary_operator:*; 64, 65; 64, 67; 65, list:[0]; 65, 66; 66, integer:0; 67, parenthesized_expression; 67, 68; 68, binary_operator:-; 68, 69; 68, 70; 69, identifier:alpha_max_len; 70, call; 70, 71; 70, 72; 71, identifier:len; 72, argument_list; 72, 73; 73, identifier:name; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:in; 75, 76; 75, 77; 76, string:'semver'; 77, identifier:sort; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:exploded_semver; 82, call; 82, 83; 82, 84; 83, identifier:semvers; 84, generator_expression; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:r; 87, string:'name'; 88, for_in_clause; 88, 89; 88, 90; 89, identifier:r; 90, identifier:remotes; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:sort_mapping; 94, call; 94, 95; 94, 96; 95, identifier:dict; 96, argument_list; 97, for_statement; 97, 98; 97, 101; 97, 105; 98, pattern_list; 98, 99; 98, 100; 99, identifier:i; 100, identifier:remote; 101, call; 101, 102; 101, 103; 102, identifier:enumerate; 103, argument_list; 103, 104; 104, identifier:remotes; 105, block; 105, 106; 105, 112; 105, 159; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:key; 109, call; 109, 110; 109, 111; 110, identifier:list; 111, argument_list; 112, for_statement; 112, 113; 112, 114; 112, 115; 113, identifier:sort_by; 114, identifier:sort; 115, block; 115, 116; 116, if_statement; 116, 117; 116, 120; 116, 130; 116, 145; 117, comparison_operator:==; 117, 118; 117, 119; 118, identifier:sort_by; 119, string:'alpha'; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:key; 125, identifier:extend; 126, argument_list; 126, 127; 127, subscript; 127, 128; 127, 129; 128, identifier:exploded_alpha; 129, identifier:i; 130, elif_clause; 130, 131; 130, 134; 131, comparison_operator:==; 131, 132; 131, 133; 132, identifier:sort_by; 133, string:'time'; 134, block; 134, 135; 135, expression_statement; 135, 136; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:key; 139, identifier:append; 140, argument_list; 140, 141; 141, unary_operator:-; 141, 142; 142, subscript; 142, 143; 142, 144; 143, identifier:remote; 144, string:'date'; 145, elif_clause; 145, 146; 145, 149; 146, comparison_operator:==; 146, 147; 146, 148; 147, identifier:sort_by; 148, string:'semver'; 149, block; 149, 150; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:key; 154, identifier:extend; 155, argument_list; 155, 156; 156, subscript; 156, 157; 156, 158; 157, identifier:exploded_semver; 158, identifier:i; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 167; 161, subscript; 161, 162; 161, 163; 162, identifier:sort_mapping; 163, call; 163, 164; 163, 165; 164, identifier:id; 165, argument_list; 165, 166; 166, identifier:remote; 167, identifier:key; 168, expression_statement; 168, 169; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:remotes; 172, identifier:sort; 173, argument_list; 173, 174; 174, keyword_argument; 174, 175; 174, 176; 175, identifier:key; 176, lambda; 176, 177; 176, 179; 177, lambda_parameters; 177, 178; 178, identifier:k; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:sort_mapping; 182, identifier:get; 183, argument_list; 183, 184; 184, call; 184, 185; 184, 186; 185, identifier:id; 186, argument_list; 186, 187; 187, identifier:k | def multi_sort(remotes, sort):
exploded_alpha = list()
exploded_semver = list()
if 'alpha' in sort:
alpha_max_len = max(len(r['name']) for r in remotes)
for name in (r['name'] for r in remotes):
exploded_alpha.append([ord(i) for i in name] + [0] * (alpha_max_len - len(name)))
if 'semver' in sort:
exploded_semver = semvers(r['name'] for r in remotes)
sort_mapping = dict()
for i, remote in enumerate(remotes):
key = list()
for sort_by in sort:
if sort_by == 'alpha':
key.extend(exploded_alpha[i])
elif sort_by == 'time':
key.append(-remote['date'])
elif sort_by == 'semver':
key.extend(exploded_semver[i])
sort_mapping[id(remote)] = key
remotes.sort(key=lambda k: sort_mapping.get(id(k))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_params; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:ctx; 6, block; 6, 7; 6, 20; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 14; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:params; 13, identifier:sort; 14, argument_list; 14, 15; 15, keyword_argument; 15, 16; 15, 17; 16, identifier:key; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:custom_sort; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 29; 22, attribute; 22, 23; 22, 28; 23, call; 23, 24; 23, 25; 24, identifier:super; 25, argument_list; 25, 26; 25, 27; 26, identifier:ClickGroup; 27, identifier:self; 28, identifier:get_params; 29, argument_list; 29, 30; 30, identifier:ctx | def get_params(self, ctx):
self.params.sort(key=self.custom_sort)
return super(ClickGroup, self).get_params(ctx) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:configure_switch_entries; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:switch_ip; 6, identifier:port_bindings; 7, block; 7, 8; 7, 13; 7, 18; 7, 22; 7, 26; 7, 34; 7, 55; 7, 68; 7, 74; 7, 80; 7, 84; 7, 88; 7, 92; 7, 294; 7, 322; 7, 333; 7, 346; 7, 353; 7, 393; 7, 403; 7, 410; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:prev_vlan; 11, unary_operator:-; 11, 12; 12, integer:1; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:prev_vni; 16, unary_operator:-; 16, 17; 17, integer:1; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:prev_port; 21, None; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:prev_native_vlan; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:starttime; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:time; 32, identifier:time; 33, argument_list; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:port_bindings; 38, identifier:sort; 39, argument_list; 39, 40; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:key; 42, lambda; 42, 43; 42, 45; 43, lambda_parameters; 43, 44; 44, identifier:x; 45, tuple; 45, 46; 45, 49; 45, 52; 46, attribute; 46, 47; 46, 48; 47, identifier:x; 48, identifier:port_id; 49, attribute; 49, 50; 49, 51; 50, identifier:x; 51, identifier:vlan_id; 52, attribute; 52, 53; 52, 54; 53, identifier:x; 54, identifier:vni; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:driver; 61, identifier:capture_and_print_timeshot; 62, argument_list; 62, 63; 62, 64; 62, 65; 63, identifier:starttime; 64, string:"replay_t2_aft_sort"; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:switch; 67, identifier:switch_ip; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:vlans; 71, call; 71, 72; 71, 73; 72, identifier:set; 73, argument_list; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:pvlans; 77, call; 77, 78; 77, 79; 78, identifier:set; 79, argument_list; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:interface_count; 83, integer:0; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:duplicate_port; 87, integer:0; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:vlan_count; 91, integer:0; 92, for_statement; 92, 93; 92, 94; 92, 95; 93, identifier:port; 94, identifier:port_bindings; 95, block; 95, 96; 95, 105; 95, 126; 96, if_statement; 96, 97; 96, 103; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:nxos_db; 100, identifier:is_reserved_binding; 101, argument_list; 101, 102; 102, identifier:port; 103, block; 103, 104; 104, continue_statement; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 110; 107, pattern_list; 107, 108; 107, 109; 108, identifier:auto_create; 109, identifier:auto_trunk; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:_gather_config_parms; 114, argument_list; 114, 115; 114, 123; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:nxos_db; 118, identifier:is_provider_vlan; 119, argument_list; 119, 120; 120, attribute; 120, 121; 120, 122; 121, identifier:port; 122, identifier:vlan_id; 123, attribute; 123, 124; 123, 125; 124, identifier:port; 125, identifier:vlan_id; 126, if_statement; 126, 127; 126, 132; 126, 196; 127, comparison_operator:==; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:port; 130, identifier:port_id; 131, identifier:prev_port; 132, block; 132, 133; 133, if_statement; 133, 134; 133, 145; 133, 151; 134, boolean_operator:and; 134, 135; 134, 140; 135, comparison_operator:==; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:port; 138, identifier:vlan_id; 139, identifier:prev_vlan; 140, comparison_operator:==; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:port; 143, identifier:vni; 144, identifier:prev_vni; 145, block; 145, 146; 145, 150; 146, expression_statement; 146, 147; 147, augmented_assignment:+=; 147, 148; 147, 149; 148, identifier:duplicate_port; 149, integer:1; 150, continue_statement; 151, else_clause; 151, 152; 152, block; 152, 153; 152, 157; 152, 173; 152, 185; 153, expression_statement; 153, 154; 154, augmented_assignment:+=; 154, 155; 154, 156; 155, identifier:vlan_count; 156, integer:1; 157, if_statement; 157, 158; 157, 159; 158, identifier:auto_create; 159, block; 159, 160; 160, expression_statement; 160, 161; 161, call; 161, 162; 161, 165; 162, attribute; 162, 163; 162, 164; 163, identifier:vlans; 164, identifier:add; 165, argument_list; 165, 166; 166, tuple; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:port; 169, identifier:vlan_id; 170, attribute; 170, 171; 170, 172; 171, identifier:port; 172, identifier:vni; 173, if_statement; 173, 174; 173, 175; 174, identifier:auto_trunk; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:pvlans; 180, identifier:add; 181, argument_list; 181, 182; 182, attribute; 182, 183; 182, 184; 183, identifier:port; 184, identifier:vlan_id; 185, if_statement; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:port; 188, identifier:is_native; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:prev_native_vlan; 193, attribute; 193, 194; 193, 195; 194, identifier:port; 195, identifier:vlan_id; 196, else_clause; 196, 197; 197, block; 197, 198; 197, 218; 197, 222; 197, 226; 197, 249; 197, 265; 197, 277; 197, 283; 198, if_statement; 198, 199; 198, 200; 199, identifier:prev_port; 200, block; 200, 201; 200, 205; 201, expression_statement; 201, 202; 202, augmented_assignment:+=; 202, 203; 202, 204; 203, identifier:interface_count; 204, integer:1; 205, expression_statement; 205, 206; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:LOG; 209, identifier:debug; 210, argument_list; 210, 211; 210, 214; 210, 215; 210, 216; 210, 217; 211, concatenated_string; 211, 212; 211, 213; 212, string:"Switch %s port %s replay summary: unique vlan "; 213, string:"count %d, duplicate port entries %d"; 214, identifier:switch_ip; 215, identifier:prev_port; 216, identifier:vlan_count; 217, identifier:duplicate_port; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:duplicate_port; 221, integer:0; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:vlan_count; 225, integer:0; 226, if_statement; 226, 227; 226, 228; 227, identifier:pvlans; 228, block; 228, 229; 228, 239; 228, 245; 229, expression_statement; 229, 230; 230, call; 230, 231; 230, 234; 231, attribute; 231, 232; 231, 233; 232, identifier:self; 233, identifier:_restore_port_binding; 234, argument_list; 234, 235; 234, 236; 234, 237; 234, 238; 235, identifier:switch_ip; 236, identifier:pvlans; 237, identifier:prev_port; 238, identifier:prev_native_vlan; 239, expression_statement; 239, 240; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:pvlans; 243, identifier:clear; 244, argument_list; 245, expression_statement; 245, 246; 246, assignment; 246, 247; 246, 248; 247, identifier:prev_native_vlan; 248, integer:0; 249, if_statement; 249, 250; 249, 251; 250, identifier:auto_create; 251, block; 251, 252; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 257; 254, attribute; 254, 255; 254, 256; 255, identifier:vlans; 256, identifier:add; 257, argument_list; 257, 258; 258, tuple; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:port; 261, identifier:vlan_id; 262, attribute; 262, 263; 262, 264; 263, identifier:port; 264, identifier:vni; 265, if_statement; 265, 266; 265, 267; 266, identifier:auto_trunk; 267, block; 267, 268; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:pvlans; 272, identifier:add; 273, argument_list; 273, 274; 274, attribute; 274, 275; 274, 276; 275, identifier:port; 276, identifier:vlan_id; 277, expression_statement; 277, 278; 278, assignment; 278, 279; 278, 280; 279, identifier:prev_port; 280, attribute; 280, 281; 280, 282; 281, identifier:port; 282, identifier:port_id; 283, if_statement; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:port; 286, identifier:is_native; 287, block; 287, 288; 288, expression_statement; 288, 289; 289, assignment; 289, 290; 289, 291; 290, identifier:prev_native_vlan; 291, attribute; 291, 292; 291, 293; 292, identifier:port; 293, identifier:vlan_id; 294, if_statement; 294, 295; 294, 296; 295, identifier:pvlans; 296, block; 296, 297; 296, 312; 297, expression_statement; 297, 298; 298, call; 298, 299; 298, 302; 299, attribute; 299, 300; 299, 301; 300, identifier:LOG; 301, identifier:debug; 302, argument_list; 302, 303; 302, 306; 302, 307; 302, 310; 302, 311; 303, concatenated_string; 303, 304; 303, 305; 304, string:"Switch %s port %s replay summary: unique vlan "; 305, string:"count %d, duplicate port entries %d"; 306, identifier:switch_ip; 307, attribute; 307, 308; 307, 309; 308, identifier:port; 309, identifier:port_id; 310, identifier:vlan_count; 311, identifier:duplicate_port; 312, expression_statement; 312, 313; 313, call; 313, 314; 313, 317; 314, attribute; 314, 315; 314, 316; 315, identifier:self; 316, identifier:_restore_port_binding; 317, argument_list; 317, 318; 317, 319; 317, 320; 317, 321; 318, identifier:switch_ip; 319, identifier:pvlans; 320, identifier:prev_port; 321, identifier:prev_native_vlan; 322, expression_statement; 322, 323; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:LOG; 326, identifier:debug; 327, argument_list; 327, 328; 327, 329; 327, 332; 328, string:"Replayed total %d ports for Switch %s"; 329, binary_operator:+; 329, 330; 329, 331; 330, identifier:interface_count; 331, integer:1; 332, identifier:switch_ip; 333, expression_statement; 333, 334; 334, call; 334, 335; 334, 340; 335, attribute; 335, 336; 335, 339; 336, attribute; 336, 337; 336, 338; 337, identifier:self; 338, identifier:driver; 339, identifier:capture_and_print_timeshot; 340, argument_list; 340, 341; 340, 342; 340, 343; 341, identifier:starttime; 342, string:"replay_part_1"; 343, keyword_argument; 343, 344; 343, 345; 344, identifier:switch; 345, identifier:switch_ip; 346, expression_statement; 346, 347; 347, assignment; 347, 348; 347, 349; 348, identifier:vlans; 349, call; 349, 350; 349, 351; 350, identifier:list; 351, argument_list; 351, 352; 352, identifier:vlans; 353, if_statement; 353, 354; 353, 355; 354, identifier:vlans; 355, block; 355, 356; 355, 362; 355, 370; 356, expression_statement; 356, 357; 357, call; 357, 358; 357, 361; 358, attribute; 358, 359; 358, 360; 359, identifier:vlans; 360, identifier:sort; 361, argument_list; 362, expression_statement; 362, 363; 363, assignment; 363, 364; 363, 367; 364, pattern_list; 364, 365; 364, 366; 365, identifier:vlan; 366, identifier:vni; 367, subscript; 367, 368; 367, 369; 368, identifier:vlans; 369, integer:0; 370, if_statement; 370, 371; 370, 374; 370, 383; 371, comparison_operator:==; 371, 372; 371, 373; 372, identifier:vni; 373, integer:0; 374, block; 374, 375; 375, expression_statement; 375, 376; 376, call; 376, 377; 376, 380; 377, attribute; 377, 378; 377, 379; 378, identifier:self; 379, identifier:_save_switch_vlan_range; 380, argument_list; 380, 381; 380, 382; 381, identifier:switch_ip; 382, identifier:vlans; 383, else_clause; 383, 384; 384, block; 384, 385; 385, expression_statement; 385, 386; 386, call; 386, 387; 386, 390; 387, attribute; 387, 388; 387, 389; 388, identifier:self; 389, identifier:_save_switch_vxlan_range; 390, argument_list; 390, 391; 390, 392; 391, identifier:switch_ip; 392, identifier:vlans; 393, expression_statement; 393, 394; 394, call; 394, 395; 394, 398; 395, attribute; 395, 396; 395, 397; 396, identifier:self; 397, identifier:set_switch_ip_and_active_state; 398, argument_list; 398, 399; 398, 400; 399, identifier:switch_ip; 400, attribute; 400, 401; 400, 402; 401, identifier:const; 402, identifier:SWITCH_RESTORE_S2; 403, expression_statement; 403, 404; 404, call; 404, 405; 404, 408; 405, attribute; 405, 406; 405, 407; 406, identifier:self; 407, identifier:configure_next_batch_of_vlans; 408, argument_list; 408, 409; 409, identifier:switch_ip; 410, expression_statement; 410, 411; 411, call; 411, 412; 411, 417; 412, attribute; 412, 413; 412, 416; 413, attribute; 413, 414; 413, 415; 414, identifier:self; 415, identifier:driver; 416, identifier:capture_and_print_timeshot; 417, argument_list; 417, 418; 417, 419; 417, 420; 418, identifier:starttime; 419, string:"replay_part_2"; 420, keyword_argument; 420, 421; 420, 422; 421, identifier:switch; 422, identifier:switch_ip | def configure_switch_entries(self, switch_ip, port_bindings):
prev_vlan = -1
prev_vni = -1
prev_port = None
prev_native_vlan = 0
starttime = time.time()
port_bindings.sort(key=lambda x: (x.port_id, x.vlan_id, x.vni))
self.driver.capture_and_print_timeshot(
starttime, "replay_t2_aft_sort",
switch=switch_ip)
vlans = set()
pvlans = set()
interface_count = 0
duplicate_port = 0
vlan_count = 0
for port in port_bindings:
if nxos_db.is_reserved_binding(port):
continue
auto_create, auto_trunk = self._gather_config_parms(
nxos_db.is_provider_vlan(port.vlan_id), port.vlan_id)
if port.port_id == prev_port:
if port.vlan_id == prev_vlan and port.vni == prev_vni:
duplicate_port += 1
continue
else:
vlan_count += 1
if auto_create:
vlans.add((port.vlan_id, port.vni))
if auto_trunk:
pvlans.add(port.vlan_id)
if port.is_native:
prev_native_vlan = port.vlan_id
else:
if prev_port:
interface_count += 1
LOG.debug("Switch %s port %s replay summary: unique vlan "
"count %d, duplicate port entries %d",
switch_ip, prev_port, vlan_count, duplicate_port)
duplicate_port = 0
vlan_count = 0
if pvlans:
self._restore_port_binding(
switch_ip, pvlans, prev_port, prev_native_vlan)
pvlans.clear()
prev_native_vlan = 0
if auto_create:
vlans.add((port.vlan_id, port.vni))
if auto_trunk:
pvlans.add(port.vlan_id)
prev_port = port.port_id
if port.is_native:
prev_native_vlan = port.vlan_id
if pvlans:
LOG.debug("Switch %s port %s replay summary: unique vlan "
"count %d, duplicate port entries %d",
switch_ip, port.port_id, vlan_count, duplicate_port)
self._restore_port_binding(
switch_ip, pvlans, prev_port, prev_native_vlan)
LOG.debug("Replayed total %d ports for Switch %s",
interface_count + 1, switch_ip)
self.driver.capture_and_print_timeshot(
starttime, "replay_part_1",
switch=switch_ip)
vlans = list(vlans)
if vlans:
vlans.sort()
vlan, vni = vlans[0]
if vni == 0:
self._save_switch_vlan_range(switch_ip, vlans)
else:
self._save_switch_vxlan_range(switch_ip, vlans)
self.set_switch_ip_and_active_state(
switch_ip, const.SWITCH_RESTORE_S2)
self.configure_next_batch_of_vlans(switch_ip)
self.driver.capture_and_print_timeshot(
starttime, "replay_part_2",
switch=switch_ip) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sort_resources_per_hosting_device; 3, parameters; 3, 4; 4, identifier:resources; 5, block; 5, 6; 5, 10; 5, 71; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:hosting_devices; 9, dictionary; 10, for_statement; 10, 11; 10, 12; 10, 17; 11, identifier:key; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:resources; 15, identifier:keys; 16, argument_list; 17, block; 17, 18; 18, for_statement; 18, 19; 18, 20; 18, 28; 19, identifier:r; 20, boolean_operator:or; 20, 21; 20, 27; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:resources; 24, identifier:get; 25, argument_list; 25, 26; 26, identifier:key; 27, list:[]; 28, block; 28, 29; 28, 40; 28, 48; 28, 56; 29, if_statement; 29, 30; 29, 38; 30, comparison_operator:is; 30, 31; 30, 37; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:r; 34, identifier:get; 35, argument_list; 35, 36; 36, string:'hosting_device'; 37, None; 38, block; 38, 39; 39, continue_statement; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:hd_id; 43, subscript; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:r; 46, string:'hosting_device'; 47, string:'id'; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:hosting_devices; 52, identifier:setdefault; 53, argument_list; 53, 54; 53, 55; 54, identifier:hd_id; 55, dictionary; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 69; 58, attribute; 58, 59; 58, 68; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:hosting_devices; 63, identifier:hd_id; 64, identifier:setdefault; 65, argument_list; 65, 66; 65, 67; 66, identifier:key; 67, list:[]; 68, identifier:append; 69, argument_list; 69, 70; 70, identifier:r; 71, return_statement; 71, 72; 72, identifier:hosting_devices | def _sort_resources_per_hosting_device(resources):
hosting_devices = {}
for key in resources.keys():
for r in resources.get(key) or []:
if r.get('hosting_device') is None:
continue
hd_id = r['hosting_device']['id']
hosting_devices.setdefault(hd_id, {})
hosting_devices[hd_id].setdefault(key, []).append(r)
return hosting_devices |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:compute; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:t; 6, default_parameter; 6, 7; 6, 8; 7, identifier:yerr; 8, float:1.123e-12; 9, default_parameter; 9, 10; 9, 11; 10, identifier:check_sorted; 11, True; 12, default_parameter; 12, 13; 12, 14; 13, identifier:A; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:U; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:V; 20, None; 21, block; 21, 22; 21, 31; 21, 53; 21, 70; 21, 76; 21, 89; 21, 98; 21, 112; 21, 128; 21, 146; 21, 164; 21, 198; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:t; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:np; 28, identifier:atleast_1d; 29, argument_list; 29, 30; 30, identifier:t; 31, if_statement; 31, 32; 31, 47; 32, boolean_operator:and; 32, 33; 32, 34; 33, identifier:check_sorted; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:np; 37, identifier:any; 38, argument_list; 38, 39; 39, comparison_operator:<; 39, 40; 39, 46; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:np; 43, identifier:diff; 44, argument_list; 44, 45; 45, identifier:t; 46, float:0.0; 47, block; 47, 48; 48, raise_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:ValueError; 51, argument_list; 51, 52; 52, string:"the input coordinates must be sorted"; 53, if_statement; 53, 54; 53, 64; 54, boolean_operator:and; 54, 55; 54, 56; 55, identifier:check_sorted; 56, comparison_operator:>; 56, 57; 56, 63; 57, call; 57, 58; 57, 59; 58, identifier:len; 59, argument_list; 59, 60; 60, attribute; 60, 61; 60, 62; 61, identifier:t; 62, identifier:shape; 63, integer:1; 64, block; 64, 65; 65, raise_statement; 65, 66; 66, call; 66, 67; 66, 68; 67, identifier:ValueError; 68, argument_list; 68, 69; 69, string:"dimension mismatch"; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_t; 75, identifier:t; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:_yerr; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:np; 84, identifier:empty_like; 85, argument_list; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:_t; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 97; 91, subscript; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:_yerr; 95, slice; 95, 96; 96, colon; 97, identifier:yerr; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 107; 100, tuple_pattern; 100, 101; 100, 102; 100, 103; 100, 104; 100, 105; 100, 106; 101, identifier:alpha_real; 102, identifier:beta_real; 103, identifier:alpha_complex_real; 104, identifier:alpha_complex_imag; 105, identifier:beta_complex_real; 106, identifier:beta_complex_imag; 107, attribute; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:kernel; 111, identifier:coefficients; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:_A; 117, conditional_expression:if; 117, 118; 117, 124; 117, 127; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:np; 121, identifier:empty; 122, argument_list; 122, 123; 123, integer:0; 124, comparison_operator:is; 124, 125; 124, 126; 125, identifier:A; 126, None; 127, identifier:A; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:self; 132, identifier:_U; 133, conditional_expression:if; 133, 134; 133, 142; 133, 145; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:np; 137, identifier:empty; 138, argument_list; 138, 139; 139, tuple; 139, 140; 139, 141; 140, integer:0; 141, integer:0; 142, comparison_operator:is; 142, 143; 142, 144; 143, identifier:U; 144, None; 145, identifier:U; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 151; 148, attribute; 148, 149; 148, 150; 149, identifier:self; 150, identifier:_V; 151, conditional_expression:if; 151, 152; 151, 160; 151, 163; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:np; 155, identifier:empty; 156, argument_list; 156, 157; 157, tuple; 157, 158; 157, 159; 158, integer:0; 159, integer:0; 160, comparison_operator:is; 160, 161; 160, 162; 161, identifier:V; 162, None; 163, identifier:V; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 171; 166, attribute; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:self; 169, identifier:solver; 170, identifier:compute; 171, argument_list; 171, 172; 171, 177; 171, 178; 171, 179; 171, 180; 171, 181; 171, 182; 171, 183; 171, 186; 171, 189; 171, 192; 171, 193; 172, attribute; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:self; 175, identifier:kernel; 176, identifier:jitter; 177, identifier:alpha_real; 178, identifier:beta_real; 179, identifier:alpha_complex_real; 180, identifier:alpha_complex_imag; 181, identifier:beta_complex_real; 182, identifier:beta_complex_imag; 183, attribute; 183, 184; 183, 185; 184, identifier:self; 185, identifier:_A; 186, attribute; 186, 187; 186, 188; 187, identifier:self; 188, identifier:_U; 189, attribute; 189, 190; 189, 191; 190, identifier:self; 191, identifier:_V; 192, identifier:t; 193, binary_operator:**; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:self; 196, identifier:_yerr; 197, integer:2; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:self; 202, identifier:dirty; 203, False | def compute(self, t, yerr=1.123e-12, check_sorted=True,
A=None, U=None, V=None):
t = np.atleast_1d(t)
if check_sorted and np.any(np.diff(t) < 0.0):
raise ValueError("the input coordinates must be sorted")
if check_sorted and len(t.shape) > 1:
raise ValueError("dimension mismatch")
self._t = t
self._yerr = np.empty_like(self._t)
self._yerr[:] = yerr
(alpha_real, beta_real, alpha_complex_real, alpha_complex_imag,
beta_complex_real, beta_complex_imag) = self.kernel.coefficients
self._A = np.empty(0) if A is None else A
self._U = np.empty((0, 0)) if U is None else U
self._V = np.empty((0, 0)) if V is None else V
self.solver.compute(
self.kernel.jitter,
alpha_real, beta_real,
alpha_complex_real, alpha_complex_imag,
beta_complex_real, beta_complex_imag,
self._A, self._U, self._V,
t, self._yerr**2
)
self.dirty = False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:group_dict; 3, parameters; 3, 4; 3, 5; 4, identifier:items; 5, identifier:keyfunc; 6, block; 6, 7; 6, 16; 6, 36; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:result; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:collections; 13, identifier:defaultdict; 14, argument_list; 14, 15; 15, identifier:list; 16, for_statement; 16, 17; 16, 18; 16, 19; 17, identifier:i; 18, identifier:items; 19, block; 19, 20; 19, 27; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:key; 23, call; 23, 24; 23, 25; 24, identifier:keyfunc; 25, argument_list; 25, 26; 26, identifier:i; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:result; 32, identifier:key; 33, identifier:append; 34, argument_list; 34, 35; 35, identifier:i; 36, return_statement; 36, 37; 37, identifier:result | def group_dict(items, keyfunc):
result = collections.defaultdict(list)
for i in items:
key = keyfunc(i)
result[key].append(i)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_split_dict; 3, parameters; 3, 4; 4, identifier:dic; 5, block; 5, 6; 5, 8; 5, 19; 6, expression_statement; 6, 7; 7, string:'''Split dict into sorted keys and values
>>> _split_dict({'b': 2, 'a': 1})
(['a', 'b'], [1, 2])
'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:keys; 11, call; 11, 12; 11, 13; 12, identifier:sorted; 13, argument_list; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:dic; 17, identifier:keys; 18, argument_list; 19, return_statement; 19, 20; 20, expression_list; 20, 21; 20, 22; 21, identifier:keys; 22, list_comprehension; 22, 23; 22, 26; 23, subscript; 23, 24; 23, 25; 24, identifier:dic; 25, identifier:k; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:k; 28, identifier:keys | def _split_dict(dic):
'''Split dict into sorted keys and values
>>> _split_dict({'b': 2, 'a': 1})
(['a', 'b'], [1, 2])
'''
keys = sorted(dic.keys())
return keys, [dic[k] for k in keys] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:monitor; 3, parameters; 3, 4; 4, identifier:args; 5, block; 5, 6; 5, 8; 5, 22; 5, 30; 5, 52; 5, 70; 5, 82; 5, 124; 6, expression_statement; 6, 7; 7, string:''' Retrieve status of jobs submitted from a given workspace, as a list
of TSV lines sorted by descending order of job submission date'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:r; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:fapi; 14, identifier:list_submissions; 15, argument_list; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:args; 18, identifier:project; 19, attribute; 19, 20; 19, 21; 20, identifier:args; 21, identifier:workspace; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:fapi; 26, identifier:_check_response_code; 27, argument_list; 27, 28; 27, 29; 28, identifier:r; 29, integer:200; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:statuses; 33, call; 33, 34; 33, 35; 34, identifier:sorted; 35, argument_list; 35, 36; 35, 41; 35, 49; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:r; 39, identifier:json; 40, argument_list; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:key; 43, lambda; 43, 44; 43, 46; 44, lambda_parameters; 44, 45; 45, identifier:k; 46, subscript; 46, 47; 46, 48; 47, identifier:k; 48, string:'submissionDate'; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:reverse; 51, True; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:header; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, string:'\t'; 58, identifier:join; 59, argument_list; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:list; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:statuses; 67, integer:0; 68, identifier:keys; 69, argument_list; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:expander; 73, lambda; 73, 74; 73, 76; 74, lambda_parameters; 74, 75; 75, identifier:v; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, string:'{0}'; 79, identifier:format; 80, argument_list; 80, 81; 81, identifier:v; 82, function_definition; 82, 83; 82, 84; 82, 86; 83, function_name:expander; 84, parameters; 84, 85; 85, identifier:thing; 86, block; 86, 87; 86, 117; 87, if_statement; 87, 88; 87, 93; 88, call; 88, 89; 88, 90; 89, identifier:isinstance; 90, argument_list; 90, 91; 90, 92; 91, identifier:thing; 92, identifier:dict; 93, block; 93, 94; 93, 104; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:entityType; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:thing; 100, identifier:get; 101, argument_list; 101, 102; 101, 103; 102, string:"entityType"; 103, None; 104, if_statement; 104, 105; 104, 106; 105, identifier:entityType; 106, block; 106, 107; 107, return_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, string:"{0}:{1}"; 111, identifier:format; 112, argument_list; 112, 113; 112, 114; 113, identifier:entityType; 114, subscript; 114, 115; 114, 116; 115, identifier:thing; 116, string:'entityName'; 117, return_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, string:"{0}"; 121, identifier:format; 122, argument_list; 122, 123; 123, identifier:thing; 124, return_statement; 124, 125; 125, binary_operator:+; 125, 126; 125, 128; 126, list:[header]; 126, 127; 127, identifier:header; 128, list_comprehension; 128, 129; 128, 143; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, string:'\t'; 132, identifier:join; 133, argument_list; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:map; 136, argument_list; 136, 137; 136, 138; 137, identifier:expander; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, identifier:v; 141, identifier:values; 142, argument_list; 143, for_in_clause; 143, 144; 143, 145; 144, identifier:v; 145, identifier:statuses | def monitor(args):
''' Retrieve status of jobs submitted from a given workspace, as a list
of TSV lines sorted by descending order of job submission date'''
r = fapi.list_submissions(args.project, args.workspace)
fapi._check_response_code(r, 200)
statuses = sorted(r.json(), key=lambda k: k['submissionDate'], reverse=True)
header = '\t'.join(list(statuses[0].keys()))
expander = lambda v: '{0}'.format(v)
def expander(thing):
if isinstance(thing, dict):
entityType = thing.get("entityType", None)
if entityType:
return "{0}:{1}".format(entityType, thing['entityName'])
return "{0}".format(thing)
return [header] + ['\t'.join( map(expander, v.values())) for v in statuses] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:tcsort; 3, parameters; 3, 4; 4, identifier:item; 5, block; 5, 6; 6, return_statement; 6, 7; 7, binary_operator:+; 7, 8; 7, 14; 8, call; 8, 9; 8, 10; 9, identifier:len; 10, argument_list; 10, 11; 11, subscript; 11, 12; 11, 13; 12, identifier:item; 13, integer:1; 14, call; 14, 15; 14, 16; 15, identifier:sum; 16, generator_expression; 16, 17; 16, 21; 17, call; 17, 18; 17, 19; 18, identifier:tcsort; 19, argument_list; 19, 20; 20, identifier:kv; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:kv; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:item; 27, integer:1; 28, identifier:items; 29, argument_list | def tcsort(item):
return len(item[1]) + sum(tcsort(kv) for kv in item[1].items()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sortProperties; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:properties; 6, block; 6, 7; 6, 28; 7, for_statement; 7, 8; 7, 11; 7, 16; 8, pattern_list; 8, 9; 8, 10; 9, identifier:prop; 10, identifier:objects; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:properties; 14, identifier:items; 15, argument_list; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:objects; 21, identifier:sort; 22, argument_list; 22, 23; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:key; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_globalSortKey; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:sorted; 31, argument_list; 31, 32; 31, 33; 32, identifier:properties; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:key; 35, lambda; 35, 36; 35, 38; 36, lambda_parameters; 36, 37; 37, identifier:p; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:predicate_rank; 42, identifier:p | def sortProperties(self, properties):
for prop, objects in properties.items():
objects.sort(key=self._globalSortKey)
return sorted(properties, key=lambda p: self.predicate_rank[p]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:getSubOrder; 3, parameters; 3, 4; 4, identifier:existing; 5, block; 5, 6; 5, 46; 5, 50; 5, 106; 5, 115; 5, 127; 5, 136; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:alpha; 9, subscript; 9, 10; 9, 45; 10, call; 10, 11; 10, 12; 11, identifier:list; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:zip; 15, argument_list; 15, 16; 16, list_splat; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, argument_list; 19, 20; 19, 37; 20, generator_expression; 20, 21; 20, 28; 21, tuple; 21, 22; 21, 23; 22, identifier:k; 23, subscript; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:v; 26, string:'rec'; 27, string:'label'; 28, for_in_clause; 28, 29; 28, 32; 29, pattern_list; 29, 30; 29, 31; 30, identifier:k; 31, identifier:v; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:existing; 35, identifier:items; 36, argument_list; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:key; 39, lambda; 39, 40; 39, 42; 40, lambda_parameters; 40, 41; 41, identifier:a; 42, subscript; 42, 43; 42, 44; 43, identifier:a; 44, integer:1; 45, integer:0; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:depths; 49, dictionary; 50, function_definition; 50, 51; 50, 52; 50, 54; 51, function_name:getDepth; 52, parameters; 52, 53; 53, identifier:id_; 54, block; 54, 55; 55, if_statement; 55, 56; 55, 59; 55, 64; 56, comparison_operator:in; 56, 57; 56, 58; 57, identifier:id_; 58, identifier:depths; 59, block; 59, 60; 60, return_statement; 60, 61; 61, subscript; 61, 62; 61, 63; 62, identifier:depths; 63, identifier:id_; 64, else_clause; 64, 65; 65, block; 65, 66; 66, if_statement; 66, 67; 66, 70; 66, 101; 67, comparison_operator:in; 67, 68; 67, 69; 68, identifier:id_; 69, identifier:existing; 70, block; 70, 71; 70, 82; 70, 97; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:names_above; 74, call; 74, 75; 74, 76; 75, identifier:getDepth; 76, argument_list; 76, 77; 77, subscript; 77, 78; 77, 81; 78, subscript; 78, 79; 78, 80; 79, identifier:existing; 80, identifier:id_; 81, string:'sc'; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:depths; 86, identifier:id_; 87, binary_operator:+; 87, 88; 87, 89; 88, identifier:names_above; 89, list:[existing[id_]['rec']['label']]; 89, 90; 90, subscript; 90, 91; 90, 96; 91, subscript; 91, 92; 91, 95; 92, subscript; 92, 93; 92, 94; 93, identifier:existing; 94, identifier:id_; 95, string:'rec'; 96, string:'label'; 97, return_statement; 97, 98; 98, subscript; 98, 99; 98, 100; 99, identifier:depths; 100, identifier:id_; 101, else_clause; 101, 102; 102, block; 102, 103; 103, return_statement; 103, 104; 104, list:['']; 104, 105; 105, string:''; 106, for_statement; 106, 107; 106, 108; 106, 109; 107, identifier:id_; 108, identifier:existing; 109, block; 109, 110; 110, expression_statement; 110, 111; 111, call; 111, 112; 111, 113; 112, identifier:getDepth; 113, argument_list; 113, 114; 114, identifier:id_; 115, expression_statement; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:print; 118, argument_list; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:sorted; 121, argument_list; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:depths; 125, identifier:values; 126, argument_list; 127, function_definition; 127, 128; 127, 129; 127, 131; 128, function_name:key_; 129, parameters; 129, 130; 130, identifier:id_; 131, block; 131, 132; 132, return_statement; 132, 133; 133, subscript; 133, 134; 133, 135; 134, identifier:depths; 135, identifier:id_; 136, return_statement; 136, 137; 137, call; 137, 138; 137, 139; 138, identifier:sorted; 139, argument_list; 139, 140; 139, 141; 140, identifier:depths; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:key; 143, identifier:key_ | def getSubOrder(existing):
alpha = list(zip(*sorted(((k, v['rec']['label']) for k, v in existing.items()), key=lambda a: a[1])))[0]
depths = {}
def getDepth(id_):
if id_ in depths:
return depths[id_]
else:
if id_ in existing:
names_above = getDepth(existing[id_]['sc'])
depths[id_] = names_above + [existing[id_]['rec']['label']]
return depths[id_]
else:
return ['']
for id_ in existing:
getDepth(id_)
print(sorted(depths.values()))
def key_(id_):
return depths[id_]
return sorted(depths, key=key_) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:insert_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:node; 5, identifier:target; 6, block; 6, 7; 6, 13; 6, 19; 6, 36; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sort; 10, attribute; 10, 11; 10, 12; 11, identifier:target; 12, identifier:sort; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:lang; 16, attribute; 16, 17; 16, 18; 17, identifier:target; 18, identifier:lang; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:collator; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:Collator; 25, identifier:createInstance; 26, argument_list; 26, 27; 27, conditional_expression:if; 27, 28; 27, 32; 27, 33; 28, call; 28, 29; 28, 30; 29, identifier:Locale; 30, argument_list; 30, 31; 31, identifier:lang; 32, identifier:lang; 33, call; 33, 34; 33, 35; 34, identifier:Locale; 35, argument_list; 36, for_statement; 36, 37; 36, 38; 36, 41; 36, 71; 37, identifier:child; 38, attribute; 38, 39; 38, 40; 39, identifier:target; 40, identifier:tree; 41, block; 41, 42; 42, if_statement; 42, 43; 42, 62; 43, comparison_operator:>; 43, 44; 43, 61; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:collator; 47, identifier:compare; 48, argument_list; 48, 49; 48, 55; 49, boolean_operator:or; 49, 50; 49, 54; 50, call; 50, 51; 50, 52; 51, identifier:sort; 52, argument_list; 52, 53; 53, identifier:child; 54, string:''; 55, boolean_operator:or; 55, 56; 55, 60; 56, call; 56, 57; 56, 58; 57, identifier:sort; 58, argument_list; 58, 59; 59, identifier:node; 60, string:''; 61, integer:0; 62, block; 62, 63; 62, 70; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:child; 67, identifier:addprevious; 68, argument_list; 68, 69; 69, identifier:node; 70, break_statement; 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:target; 78, identifier:tree; 79, identifier:append; 80, argument_list; 80, 81; 81, identifier:node | def insert_sort(node, target):
sort = target.sort
lang = target.lang
collator = Collator.createInstance(Locale(lang) if lang else Locale())
for child in target.tree:
if collator.compare(sort(child) or '', sort(node) or '') > 0:
child.addprevious(node)
break
else:
target.tree.append(node) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:do_sort_by; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:element; 6, identifier:decl; 7, identifier:pseudo; 8, block; 8, 9; 8, 40; 8, 64; 8, 76; 8, 84; 8, 90; 8, 100; 8, 106; 8, 112; 9, if_statement; 9, 10; 9, 15; 9, 28; 10, comparison_operator:in; 10, 11; 10, 12; 11, string:','; 12, attribute; 12, 13; 12, 14; 13, identifier:decl; 14, identifier:value; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 21; 18, pattern_list; 18, 19; 18, 20; 19, identifier:css; 20, identifier:flags; 21, call; 21, 22; 21, 23; 22, identifier:split; 23, argument_list; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:decl; 26, identifier:value; 27, string:','; 28, else_clause; 28, 29; 29, block; 29, 30; 29, 36; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:css; 33, attribute; 33, 34; 33, 35; 34, identifier:decl; 35, identifier:value; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:flags; 39, None; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:sort; 43, call; 43, 44; 43, 45; 44, identifier:css_to_func; 45, argument_list; 45, 46; 45, 50; 45, 56; 45, 59; 46, call; 46, 47; 46, 48; 47, identifier:serialize; 48, argument_list; 48, 49; 49, identifier:css; 50, call; 50, 51; 50, 52; 51, identifier:serialize; 52, argument_list; 52, 53; 53, boolean_operator:or; 53, 54; 53, 55; 54, identifier:flags; 55, string:''; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:css_namespaces; 59, subscript; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:state; 63, string:'lang'; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:step; 67, subscript; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:state; 71, subscript; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:state; 75, string:'current_step'; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:target; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:current_target; 83, argument_list; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:target; 88, identifier:sort; 89, identifier:sort; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:target; 94, identifier:lang; 95, subscript; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:state; 99, string:'lang'; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:target; 104, identifier:isgroup; 105, False; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:target; 110, identifier:groupby; 111, None; 112, for_statement; 112, 113; 112, 116; 112, 117; 112, 126; 113, pattern_list; 113, 114; 113, 115; 114, identifier:pos; 115, identifier:action; 116, line_continuation:\; 117, call; 117, 118; 117, 119; 118, identifier:enumerate; 119, argument_list; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:reversed; 122, argument_list; 122, 123; 123, subscript; 123, 124; 123, 125; 124, identifier:step; 125, string:'actions'; 126, block; 126, 127; 127, if_statement; 127, 128; 127, 144; 128, boolean_operator:and; 128, 129; 128, 134; 128, 135; 129, comparison_operator:==; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:action; 132, integer:0; 133, string:'target'; 134, line_continuation:\; 135, comparison_operator:==; 135, 136; 135, 141; 136, attribute; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:action; 139, integer:1; 140, identifier:tree; 141, attribute; 141, 142; 141, 143; 142, identifier:element; 143, identifier:etree_element; 144, block; 144, 145; 144, 153; 144, 161; 144, 169; 145, expression_statement; 145, 146; 146, assignment; 146, 147; 146, 152; 147, attribute; 147, 148; 147, 151; 148, subscript; 148, 149; 148, 150; 149, identifier:action; 150, integer:1; 151, identifier:sort; 152, identifier:sort; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 160; 155, attribute; 155, 156; 155, 159; 156, subscript; 156, 157; 156, 158; 157, identifier:action; 158, integer:1; 159, identifier:isgroup; 160, False; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 168; 163, attribute; 163, 164; 163, 167; 164, subscript; 164, 165; 164, 166; 165, identifier:action; 166, integer:1; 167, identifier:groupby; 168, None; 169, break_statement | def do_sort_by(self, element, decl, pseudo):
if ',' in decl.value:
css, flags = split(decl.value, ',')
else:
css = decl.value
flags = None
sort = css_to_func(serialize(css), serialize(flags or ''),
self.css_namespaces, self.state['lang'])
step = self.state[self.state['current_step']]
target = self.current_target()
target.sort = sort
target.lang = self.state['lang']
target.isgroup = False
target.groupby = None
for pos, action in \
enumerate(reversed(step['actions'])):
if action[0] == 'target' and \
action[1].tree == element.etree_element:
action[1].sort = sort
action[1].isgroup = False
action[1].groupby = None
break |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:keys; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 45; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:keys; 9, call; 9, 10; 9, 11; 10, identifier:list; 11, argument_list; 12, for_statement; 12, 13; 12, 14; 12, 21; 13, identifier:n; 14, call; 14, 15; 14, 16; 15, identifier:range; 16, argument_list; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:len; 19, argument_list; 19, 20; 20, identifier:self; 21, block; 21, 22; 21, 30; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:key; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:get_value; 29, argument_list; 30, if_statement; 30, 31; 30, 37; 31, not_operator; 31, 32; 32, comparison_operator:in; 32, 33; 32, 34; 33, identifier:key; 34, list:['', None]; 34, 35; 34, 36; 35, string:''; 36, None; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:keys; 42, identifier:append; 43, argument_list; 43, 44; 44, identifier:key; 45, return_statement; 45, 46; 46, identifier:keys | def keys(self):
keys = list()
for n in range(len(self)):
key = self.get_value()
if not key in ['', None]: keys.append(key)
return keys |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:set_item; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, identifier:value; 7, block; 7, 8; 7, 19; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:keys; 11, call; 11, 12; 11, 13; 12, identifier:list; 13, argument_list; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:keys; 18, argument_list; 19, if_statement; 19, 20; 19, 23; 19, 41; 20, comparison_operator:in; 20, 21; 20, 22; 21, identifier:key; 22, identifier:keys; 23, block; 23, 24; 24, expression_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:set_value; 29, argument_list; 29, 30; 29, 31; 29, 37; 30, integer:1; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:keys; 34, identifier:index; 35, argument_list; 35, 36; 36, identifier:key; 37, call; 37, 38; 37, 39; 38, identifier:str; 39, argument_list; 39, 40; 40, identifier:value; 41, else_clause; 41, 42; 42, block; 42, 43; 42, 58; 43, expression_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:set_value; 48, argument_list; 48, 49; 48, 50; 48, 54; 49, integer:0; 50, call; 50, 51; 50, 52; 51, identifier:len; 52, argument_list; 52, 53; 53, identifier:self; 54, call; 54, 55; 54, 56; 55, identifier:str; 56, argument_list; 56, 57; 57, identifier:key; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:set_value; 63, argument_list; 63, 64; 63, 65; 63, 71; 64, integer:1; 65, binary_operator:-; 65, 66; 65, 70; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:self; 70, integer:1; 71, call; 71, 72; 71, 73; 72, identifier:str; 73, argument_list; 73, 74; 74, identifier:value | def set_item(self, key, value):
keys = list(self.keys())
if key in keys:
self.set_value(1,keys.index(key),str(value))
else:
self.set_value(0,len(self), str(key))
self.set_value(1,len(self)-1, str(value)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:insert_ordered; 3, parameters; 3, 4; 3, 5; 4, identifier:value; 5, identifier:array; 6, block; 6, 7; 6, 11; 6, 35; 6, 43; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:index; 10, integer:0; 11, for_statement; 11, 12; 11, 13; 11, 21; 12, identifier:n; 13, call; 13, 14; 13, 15; 14, identifier:range; 15, argument_list; 15, 16; 15, 17; 16, integer:0; 17, call; 17, 18; 17, 19; 18, identifier:len; 19, argument_list; 19, 20; 20, identifier:array; 21, block; 21, 22; 22, if_statement; 22, 23; 22, 28; 23, comparison_operator:>=; 23, 24; 23, 25; 24, identifier:value; 25, subscript; 25, 26; 25, 27; 26, identifier:array; 27, identifier:n; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:index; 32, binary_operator:+; 32, 33; 32, 34; 33, identifier:n; 34, integer:1; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:array; 39, identifier:insert; 40, argument_list; 40, 41; 40, 42; 41, identifier:index; 42, identifier:value; 43, return_statement; 43, 44; 44, identifier:index | def insert_ordered(value, array):
index = 0
for n in range(0,len(array)):
if value >= array[n]: index = n+1
array.insert(index, value)
return index |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:remove_dataset; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:dataset; 7, None; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 18; 10, 38; 10, 48; 10, 100; 10, 106; 10, 129; 10, 135; 10, 141; 10, 153; 10, 161; 10, 169; 10, 175; 10, 196; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:_kwargs_checks; 16, argument_list; 16, 17; 17, identifier:kwargs; 18, if_statement; 18, 19; 18, 32; 19, boolean_operator:and; 19, 20; 19, 23; 20, comparison_operator:is; 20, 21; 20, 22; 21, identifier:dataset; 22, None; 23, not_operator; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:len; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:kwargs; 30, identifier:items; 31, argument_list; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:ValueError; 36, argument_list; 36, 37; 37, string:"must provide some value to filter for datasets"; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:kind; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:kwargs; 44, identifier:get; 45, argument_list; 45, 46; 45, 47; 46, string:'kind'; 47, None; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:kind; 51, None; 52, block; 52, 53; 52, 65; 52, 69; 52, 94; 53, if_statement; 53, 54; 53, 59; 54, call; 54, 55; 54, 56; 55, identifier:isinstance; 56, argument_list; 56, 57; 56, 58; 57, identifier:kind; 58, identifier:str; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:kind; 63, list:[kind]; 63, 64; 64, identifier:kind; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:kind_deps; 68, list:[]; 69, for_statement; 69, 70; 69, 71; 69, 72; 70, identifier:kind_i; 71, identifier:kind; 72, block; 72, 73; 72, 82; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:dep; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, string:'{}_dep'; 79, identifier:format; 80, argument_list; 80, 81; 81, identifier:kind_i; 82, if_statement; 82, 83; 82, 86; 83, comparison_operator:not; 83, 84; 83, 85; 84, identifier:dep; 85, identifier:kind; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:kind_deps; 91, identifier:append; 92, argument_list; 92, 93; 93, identifier:dep; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:kind; 97, binary_operator:+; 97, 98; 97, 99; 98, identifier:kind; 99, identifier:kind_deps; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:kwargs; 104, string:'kind'; 105, identifier:kind; 106, if_statement; 106, 107; 106, 110; 107, comparison_operator:is; 107, 108; 107, 109; 108, identifier:dataset; 109, None; 110, block; 110, 111; 110, 123; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:dataset; 114, attribute; 114, 115; 114, 122; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:filter; 119, argument_list; 119, 120; 120, dictionary_splat; 120, 121; 121, identifier:kwargs; 122, identifier:datasets; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:kwargs; 127, string:'kind'; 128, None; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 134; 131, subscript; 131, 132; 131, 133; 132, identifier:kwargs; 133, string:'dataset'; 134, identifier:dataset; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 140; 137, subscript; 137, 138; 137, 139; 138, identifier:kwargs; 139, string:'qualifier'; 140, None; 141, expression_statement; 141, 142; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:kwargs; 145, identifier:setdefault; 146, argument_list; 146, 147; 146, 148; 147, string:'context'; 148, list:['dataset', 'model', 'constraint', 'compute']; 148, 149; 148, 150; 148, 151; 148, 152; 149, string:'dataset'; 150, string:'model'; 151, string:'constraint'; 152, string:'compute'; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:self; 157, identifier:remove_parameters_all; 158, argument_list; 158, 159; 159, dictionary_splat; 159, 160; 160, identifier:kwargs; 161, expression_statement; 161, 162; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:self; 165, identifier:remove_parameters_all; 166, argument_list; 166, 167; 167, dictionary_splat; 167, 168; 168, identifier:kwargs; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:self; 173, identifier:_handle_dataset_selectparams; 174, argument_list; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:self; 179, identifier:_add_history; 180, argument_list; 180, 181; 180, 184; 180, 190; 180, 193; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:redo_func; 183, string:'remove_dataset'; 184, keyword_argument; 184, 185; 184, 186; 185, identifier:redo_kwargs; 186, dictionary; 186, 187; 187, pair; 187, 188; 187, 189; 188, string:'dataset'; 189, identifier:dataset; 190, keyword_argument; 190, 191; 190, 192; 191, identifier:undo_func; 192, None; 193, keyword_argument; 193, 194; 193, 195; 194, identifier:undo_kwargs; 195, dictionary; 196, return_statement | def remove_dataset(self, dataset=None, **kwargs):
self._kwargs_checks(kwargs)
if dataset is None and not len(kwargs.items()):
raise ValueError("must provide some value to filter for datasets")
kind = kwargs.get('kind', None)
if kind is not None:
if isinstance(kind, str):
kind = [kind]
kind_deps = []
for kind_i in kind:
dep = '{}_dep'.format(kind_i)
if dep not in kind:
kind_deps.append(dep)
kind = kind + kind_deps
kwargs['kind'] = kind
if dataset is None:
dataset = self.filter(**kwargs).datasets
kwargs['kind'] = None
kwargs['dataset'] = dataset
kwargs['qualifier'] = None
kwargs.setdefault('context', ['dataset', 'model', 'constraint', 'compute'])
self.remove_parameters_all(**kwargs)
self.remove_parameters_all(**kwargs)
self._handle_dataset_selectparams()
self._add_history(redo_func='remove_dataset',
redo_kwargs={'dataset': dataset},
undo_func=None,
undo_kwargs={})
return |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:calls_sorted; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 73; 5, 79; 5, 95; 5, 103; 6, function_definition; 6, 7; 6, 8; 6, 10; 7, function_name:_z; 8, parameters; 8, 9; 9, identifier:call; 10, block; 10, 11; 11, if_statement; 11, 12; 11, 23; 11, 39; 11, 66; 12, call; 12, 13; 12, 14; 13, identifier:isinstance; 14, argument_list; 14, 15; 14, 20; 15, attribute; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:call; 18, identifier:z; 19, identifier:value; 20, attribute; 20, 21; 20, 22; 21, identifier:np; 22, identifier:ndarray; 23, block; 23, 24; 24, return_statement; 24, 25; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:np; 28, identifier:mean; 29, argument_list; 29, 30; 30, call; 30, 31; 30, 38; 31, attribute; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:call; 35, identifier:z; 36, identifier:value; 37, identifier:flatten; 38, argument_list; 39, elif_clause; 39, 40; 39, 59; 40, boolean_operator:or; 40, 41; 40, 50; 41, call; 41, 42; 41, 43; 42, identifier:isinstance; 43, argument_list; 43, 44; 43, 49; 44, attribute; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:call; 47, identifier:z; 48, identifier:value; 49, identifier:float; 50, call; 50, 51; 50, 52; 51, identifier:isinstance; 52, argument_list; 52, 53; 52, 58; 53, attribute; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:call; 56, identifier:z; 57, identifier:value; 58, identifier:int; 59, block; 59, 60; 60, return_statement; 60, 61; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:call; 64, identifier:z; 65, identifier:value; 66, else_clause; 66, 67; 67, block; 67, 68; 68, return_statement; 68, 69; 69, unary_operator:-; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:np; 72, identifier:inf; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:calls; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:_calls; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:zs; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:np; 85, identifier:array; 86, argument_list; 86, 87; 87, list_comprehension; 87, 88; 87, 92; 88, call; 88, 89; 88, 90; 89, identifier:_z; 90, argument_list; 90, 91; 91, identifier:c; 92, for_in_clause; 92, 93; 92, 94; 93, identifier:c; 94, identifier:calls; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:sorted_inds; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:zs; 101, identifier:argsort; 102, argument_list; 103, return_statement; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:_call; 107, identifier:make_callgroup; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 120; 110, attribute; 110, 111; 110, 119; 111, subscript; 111, 112; 111, 118; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:np; 115, identifier:array; 116, argument_list; 116, 117; 117, identifier:calls; 118, identifier:sorted_inds; 119, identifier:tolist; 120, argument_list | def calls_sorted(self):
def _z(call):
if isinstance(call.z.value, np.ndarray):
return np.mean(call.z.value.flatten())
elif isinstance(call.z.value, float) or isinstance(call.z.value, int):
return call.z.value
else:
return -np.inf
calls = self._calls
zs = np.array([_z(c) for c in calls])
sorted_inds = zs.argsort()
return _call.make_callgroup(np.array(calls)[sorted_inds].tolist()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_filter_library_state; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:items; 6, block; 6, 7; 6, 13; 6, 19; 6, 32; 6, 40; 6, 46; 7, if_statement; 7, 8; 7, 10; 8, not_operator; 8, 9; 9, identifier:items; 10, block; 10, 11; 11, return_statement; 11, 12; 12, identifier:items; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:top_most_item; 16, subscript; 16, 17; 16, 18; 17, identifier:items; 18, integer:0; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:top_most_state_v; 22, conditional_expression:if; 22, 23; 22, 24; 22, 29; 23, identifier:top_most_item; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:top_most_item; 28, identifier:StateView; 29, attribute; 29, 30; 29, 31; 30, identifier:top_most_item; 31, identifier:parent; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:state; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:top_most_state_v; 38, identifier:model; 39, identifier:state; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:global_gui_config; 43, attribute; 43, 44; 43, 45; 44, identifier:gui_helper_state_machine; 45, identifier:global_gui_config; 46, if_statement; 46, 47; 46, 53; 46, 84; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:global_gui_config; 50, identifier:get_config_value; 51, argument_list; 51, 52; 52, string:'STATE_SELECTION_INSIDE_LIBRARY_STATE_ENABLED'; 53, block; 53, 54; 53, 82; 54, if_statement; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:state; 57, identifier:is_root_state_of_library; 58, block; 58, 59; 58, 74; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:new_topmost_item; 62, call; 62, 63; 62, 70; 63, attribute; 63, 64; 63, 69; 64, attribute; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:view; 68, identifier:canvas; 69, identifier:get_view_for_core_element; 70, argument_list; 70, 71; 71, attribute; 71, 72; 71, 73; 72, identifier:state; 73, identifier:parent; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:self; 78, identifier:dismiss_upper_items; 79, argument_list; 79, 80; 79, 81; 80, identifier:items; 81, identifier:new_topmost_item; 82, return_statement; 82, 83; 83, identifier:items; 84, else_clause; 84, 85; 85, block; 85, 86; 85, 94; 85, 124; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:library_root_state; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:state; 92, identifier:get_uppermost_library_root_state; 93, argument_list; 94, if_statement; 94, 95; 94, 96; 95, identifier:library_root_state; 96, block; 96, 97; 96, 103; 96, 116; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:library_state; 100, attribute; 100, 101; 100, 102; 101, identifier:library_root_state; 102, identifier:parent; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:library_state_v; 106, call; 106, 107; 106, 114; 107, attribute; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:self; 111, identifier:view; 112, identifier:canvas; 113, identifier:get_view_for_core_element; 114, argument_list; 114, 115; 115, identifier:library_state; 116, return_statement; 116, 117; 117, call; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:dismiss_upper_items; 121, argument_list; 121, 122; 121, 123; 122, identifier:items; 123, identifier:library_state_v; 124, return_statement; 124, 125; 125, identifier:items | def _filter_library_state(self, items):
if not items:
return items
top_most_item = items[0]
top_most_state_v = top_most_item if isinstance(top_most_item, StateView) else top_most_item.parent
state = top_most_state_v.model.state
global_gui_config = gui_helper_state_machine.global_gui_config
if global_gui_config.get_config_value('STATE_SELECTION_INSIDE_LIBRARY_STATE_ENABLED'):
if state.is_root_state_of_library:
new_topmost_item = self.view.canvas.get_view_for_core_element(state.parent)
return self.dismiss_upper_items(items, new_topmost_item)
return items
else:
library_root_state = state.get_uppermost_library_root_state()
if library_root_state:
library_state = library_root_state.parent
library_state_v = self.view.canvas.get_view_for_core_element(library_state)
return self.dismiss_upper_items(items, library_state_v)
return items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_filter_hovered_items; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:items; 6, identifier:event; 7, block; 7, 8; 7, 17; 7, 23; 7, 29; 7, 43; 7, 63; 7, 76; 7, 222; 7, 258; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:items; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_filter_library_state; 15, argument_list; 15, 16; 16, identifier:items; 17, if_statement; 17, 18; 17, 20; 18, not_operator; 18, 19; 19, identifier:items; 20, block; 20, 21; 21, return_statement; 21, 22; 22, identifier:items; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:top_most_item; 26, subscript; 26, 27; 26, 28; 27, identifier:items; 28, integer:0; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:second_top_most_item; 32, conditional_expression:if; 32, 33; 32, 36; 32, 42; 33, subscript; 33, 34; 33, 35; 34, identifier:items; 35, integer:1; 36, comparison_operator:>; 36, 37; 36, 41; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:items; 41, integer:1; 42, None; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:first_state_v; 46, call; 46, 47; 46, 48; 47, identifier:next; 48, argument_list; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:filter; 51, argument_list; 51, 52; 51, 62; 52, lambda; 52, 53; 52, 55; 53, lambda_parameters; 53, 54; 54, identifier:item; 55, call; 55, 56; 55, 57; 56, identifier:isinstance; 57, argument_list; 57, 58; 57, 59; 58, identifier:item; 59, tuple; 59, 60; 59, 61; 60, identifier:NameView; 61, identifier:StateView; 62, identifier:items; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:first_state_v; 66, conditional_expression:if; 66, 67; 66, 70; 66, 75; 67, attribute; 67, 68; 67, 69; 68, identifier:first_state_v; 69, identifier:parent; 70, call; 70, 71; 70, 72; 71, identifier:isinstance; 72, argument_list; 72, 73; 72, 74; 73, identifier:first_state_v; 74, identifier:NameView; 75, identifier:first_state_v; 76, if_statement; 76, 77; 76, 78; 77, identifier:first_state_v; 78, block; 78, 79; 78, 106; 78, 110; 78, 118; 78, 139; 78, 150; 78, 189; 79, for_statement; 79, 80; 79, 81; 79, 82; 80, identifier:item; 81, identifier:items; 82, block; 82, 83; 82, 105; 83, if_statement; 83, 84; 83, 89; 84, call; 84, 85; 84, 86; 85, identifier:isinstance; 86, argument_list; 86, 87; 86, 88; 87, identifier:item; 88, identifier:ConnectionView; 89, block; 89, 90; 90, if_statement; 90, 91; 90, 103; 91, comparison_operator:is; 91, 92; 91, 102; 92, call; 92, 93; 92, 100; 93, attribute; 93, 94; 93, 99; 94, attribute; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:view; 98, identifier:canvas; 99, identifier:get_parent; 100, argument_list; 100, 101; 101, identifier:top_most_item; 102, identifier:first_state_v; 103, block; 103, 104; 104, continue_statement; 105, break_statement; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:port_beneath_cursor; 109, False; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:state_ports; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:first_state_v; 116, identifier:get_all_ports; 117, argument_list; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:position; 121, call; 121, 122; 121, 132; 122, attribute; 122, 123; 122, 131; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:view; 128, identifier:get_matrix_v2i; 129, argument_list; 129, 130; 130, identifier:first_state_v; 131, identifier:transform_point; 132, argument_list; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:event; 135, identifier:x; 136, attribute; 136, 137; 136, 138; 137, identifier:event; 138, identifier:y; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:i2v_matrix; 142, call; 142, 143; 142, 148; 143, attribute; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:view; 147, identifier:get_matrix_i2v; 148, argument_list; 148, 149; 149, identifier:first_state_v; 150, for_statement; 150, 151; 150, 152; 150, 153; 151, identifier:port_v; 152, identifier:state_ports; 153, block; 153, 154; 153, 167; 153, 179; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:item_distance; 157, subscript; 157, 158; 157, 166; 158, call; 158, 159; 158, 164; 159, attribute; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:port_v; 162, identifier:port; 163, identifier:glue; 164, argument_list; 164, 165; 165, identifier:position; 166, integer:1; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:view_distance; 170, subscript; 170, 171; 170, 178; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:i2v_matrix; 174, identifier:transform_distance; 175, argument_list; 175, 176; 175, 177; 176, identifier:item_distance; 177, integer:0; 178, integer:0; 179, if_statement; 179, 180; 179, 183; 180, comparison_operator:==; 180, 181; 180, 182; 181, identifier:view_distance; 182, integer:0; 183, block; 183, 184; 183, 188; 184, expression_statement; 184, 185; 185, assignment; 185, 186; 185, 187; 186, identifier:port_beneath_cursor; 187, True; 188, break_statement; 189, if_statement; 189, 190; 189, 191; 190, identifier:port_beneath_cursor; 191, block; 191, 192; 191, 202; 191, 208; 192, expression_statement; 192, 193; 193, assignment; 193, 194; 193, 195; 194, identifier:items; 195, call; 195, 196; 195, 199; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:dismiss_upper_items; 199, argument_list; 199, 200; 199, 201; 200, identifier:items; 201, identifier:item; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:top_most_item; 205, subscript; 205, 206; 205, 207; 206, identifier:items; 207, integer:0; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:second_top_most_item; 211, conditional_expression:if; 211, 212; 211, 215; 211, 221; 212, subscript; 212, 213; 212, 214; 213, identifier:items; 214, integer:1; 215, comparison_operator:>; 215, 216; 215, 220; 216, call; 216, 217; 216, 218; 217, identifier:len; 218, argument_list; 218, 219; 219, identifier:items; 220, integer:1; 221, None; 222, if_statement; 222, 223; 222, 228; 223, call; 223, 224; 223, 225; 224, identifier:isinstance; 225, argument_list; 225, 226; 225, 227; 226, identifier:top_most_item; 227, identifier:NameView; 228, block; 228, 229; 228, 233; 229, expression_statement; 229, 230; 230, assignment; 230, 231; 230, 232; 231, identifier:state_v; 232, identifier:second_top_most_item; 233, if_statement; 233, 234; 233, 249; 234, boolean_operator:and; 234, 235; 234, 242; 235, comparison_operator:not; 235, 236; 235, 237; 236, identifier:state_v; 237, attribute; 237, 238; 237, 241; 238, attribute; 238, 239; 238, 240; 239, identifier:self; 240, identifier:view; 241, identifier:selected_items; 242, comparison_operator:not; 242, 243; 242, 244; 243, identifier:top_most_item; 244, attribute; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:self; 247, identifier:view; 248, identifier:selected_items; 249, block; 249, 250; 250, expression_statement; 250, 251; 251, assignment; 251, 252; 251, 253; 252, identifier:items; 253, subscript; 253, 254; 253, 255; 254, identifier:items; 255, slice; 255, 256; 255, 257; 256, integer:1; 257, colon; 258, return_statement; 258, 259; 259, identifier:items | def _filter_hovered_items(self, items, event):
items = self._filter_library_state(items)
if not items:
return items
top_most_item = items[0]
second_top_most_item = items[1] if len(items) > 1 else None
first_state_v = next(filter(lambda item: isinstance(item, (NameView, StateView)), items))
first_state_v = first_state_v.parent if isinstance(first_state_v, NameView) else first_state_v
if first_state_v:
for item in items:
if isinstance(item, ConnectionView):
if self.view.canvas.get_parent(top_most_item) is not first_state_v:
continue
break
port_beneath_cursor = False
state_ports = first_state_v.get_all_ports()
position = self.view.get_matrix_v2i(first_state_v).transform_point(event.x, event.y)
i2v_matrix = self.view.get_matrix_i2v(first_state_v)
for port_v in state_ports:
item_distance = port_v.port.glue(position)[1]
view_distance = i2v_matrix.transform_distance(item_distance, 0)[0]
if view_distance == 0:
port_beneath_cursor = True
break
if port_beneath_cursor:
items = self.dismiss_upper_items(items, item)
top_most_item = items[0]
second_top_most_item = items[1] if len(items) > 1 else None
if isinstance(top_most_item, NameView):
state_v = second_top_most_item
if state_v not in self.view.selected_items and top_most_item not in self.view.selected_items:
items = items[1:]
return items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:compare_variables; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:tree_model; 5, identifier:iter1; 6, identifier:iter2; 7, default_parameter; 7, 8; 7, 9; 8, identifier:user_data; 9, None; 10, block; 10, 11; 10, 22; 10, 33; 10, 41; 10, 49; 10, 68; 10, 87; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:path1; 14, subscript; 14, 15; 14, 21; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:tree_model; 18, identifier:get_path; 19, argument_list; 19, 20; 20, identifier:iter1; 21, integer:0; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:path2; 25, subscript; 25, 26; 25, 32; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:tree_model; 29, identifier:get_path; 30, argument_list; 30, 31; 31, identifier:iter2; 32, integer:0; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:name1; 36, subscript; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:tree_model; 39, identifier:path1; 40, integer:0; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:name2; 44, subscript; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:tree_model; 47, identifier:path2; 48, integer:0; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:name1_as_bits; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, string:' '; 55, identifier:join; 56, generator_expression; 56, 57; 56, 65; 57, call; 57, 58; 57, 59; 58, identifier:format; 59, argument_list; 59, 60; 59, 64; 60, call; 60, 61; 60, 62; 61, identifier:ord; 62, argument_list; 62, 63; 63, identifier:x; 64, string:'b'; 65, for_in_clause; 65, 66; 65, 67; 66, identifier:x; 67, identifier:name1; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:name2_as_bits; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, string:' '; 74, identifier:join; 75, generator_expression; 75, 76; 75, 84; 76, call; 76, 77; 76, 78; 77, identifier:format; 78, argument_list; 78, 79; 78, 83; 79, call; 79, 80; 79, 81; 80, identifier:ord; 81, argument_list; 81, 82; 82, identifier:x; 83, string:'b'; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:x; 86, identifier:name2; 87, if_statement; 87, 88; 87, 91; 87, 94; 87, 101; 88, comparison_operator:==; 88, 89; 88, 90; 89, identifier:name1_as_bits; 90, identifier:name2_as_bits; 91, block; 91, 92; 92, return_statement; 92, 93; 93, integer:0; 94, elif_clause; 94, 95; 94, 98; 95, comparison_operator:>; 95, 96; 95, 97; 96, identifier:name1_as_bits; 97, identifier:name2_as_bits; 98, block; 98, 99; 99, return_statement; 99, 100; 100, integer:1; 101, else_clause; 101, 102; 102, block; 102, 103; 103, return_statement; 103, 104; 104, unary_operator:-; 104, 105; 105, integer:1 | def compare_variables(tree_model, iter1, iter2, user_data=None):
path1 = tree_model.get_path(iter1)[0]
path2 = tree_model.get_path(iter2)[0]
name1 = tree_model[path1][0]
name2 = tree_model[path2][0]
name1_as_bits = ' '.join(format(ord(x), 'b') for x in name1)
name2_as_bits = ' '.join(format(ord(x), 'b') for x in name2)
if name1_as_bits == name2_as_bits:
return 0
elif name1_as_bits > name2_as_bits:
return 1
else:
return -1 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:load_hook_files; 3, parameters; 3, 4; 4, identifier:pathname; 5, block; 5, 6; 5, 8; 5, 54; 6, global_statement; 6, 7; 7, identifier:hooks; 8, if_statement; 8, 9; 8, 24; 8, 40; 9, boolean_operator:and; 9, 10; 9, 17; 10, comparison_operator:>; 10, 11; 10, 16; 11, subscript; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:sys; 14, identifier:version_info; 15, integer:0; 16, integer:2; 17, comparison_operator:>; 17, 18; 17, 23; 18, subscript; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:sys; 21, identifier:version_info; 22, integer:1; 23, integer:4; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:fsglob; 28, call; 28, 29; 28, 30; 29, identifier:sorted; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:glob; 34, identifier:iglob; 35, argument_list; 35, 36; 35, 37; 36, identifier:pathname; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:recursive; 39, True; 40, else_clause; 40, 41; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:fsglob; 45, call; 45, 46; 45, 47; 46, identifier:sorted; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:glob; 51, identifier:iglob; 52, argument_list; 52, 53; 53, identifier:pathname; 54, for_statement; 54, 55; 54, 56; 54, 57; 55, identifier:path; 56, identifier:fsglob; 57, block; 57, 58; 57, 69; 57, 99; 57, 116; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:real_path; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:os; 65, identifier:path; 66, identifier:realpath; 67, argument_list; 67, 68; 68, identifier:path; 69, if_statement; 69, 70; 69, 82; 70, comparison_operator:not; 70, 71; 70, 79; 71, call; 71, 72; 71, 77; 72, attribute; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:os; 75, identifier:path; 76, identifier:dirname; 77, argument_list; 77, 78; 78, identifier:real_path; 79, attribute; 79, 80; 79, 81; 80, identifier:sys; 81, identifier:path; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 90; 85, attribute; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:sys; 88, identifier:path; 89, identifier:append; 90, argument_list; 90, 91; 91, call; 91, 92; 91, 97; 92, attribute; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:os; 95, identifier:path; 96, identifier:dirname; 97, argument_list; 97, 98; 98, identifier:real_path; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:module; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:imp; 105, identifier:load_source; 106, argument_list; 106, 107; 106, 115; 107, call; 107, 108; 107, 113; 108, attribute; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:os; 111, identifier:path; 112, identifier:basename; 113, argument_list; 113, 114; 114, identifier:path; 115, identifier:real_path; 116, for_statement; 116, 117; 116, 118; 116, 122; 117, identifier:name; 118, call; 118, 119; 118, 120; 119, identifier:dir; 120, argument_list; 120, 121; 121, identifier:module; 122, block; 122, 123; 122, 131; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:obj; 126, call; 126, 127; 126, 128; 127, identifier:getattr; 128, argument_list; 128, 129; 128, 130; 129, identifier:module; 130, identifier:name; 131, if_statement; 131, 132; 131, 142; 132, boolean_operator:and; 132, 133; 132, 138; 133, call; 133, 134; 133, 135; 134, identifier:hasattr; 135, argument_list; 135, 136; 135, 137; 136, identifier:obj; 137, string:'dredd_hooks'; 138, call; 138, 139; 138, 140; 139, identifier:callable; 140, argument_list; 140, 141; 141, identifier:obj; 142, block; 142, 143; 142, 151; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 146; 145, identifier:func_hooks; 146, call; 146, 147; 146, 148; 147, identifier:getattr; 148, argument_list; 148, 149; 148, 150; 149, identifier:obj; 150, string:'dredd_hooks'; 151, for_statement; 151, 152; 151, 155; 151, 156; 152, pattern_list; 152, 153; 152, 154; 153, identifier:hook; 154, identifier:name; 155, identifier:func_hooks; 156, block; 156, 157; 156, 171; 156, 185; 156, 199; 156, 213; 156, 227; 156, 241; 156, 255; 157, if_statement; 157, 158; 157, 161; 158, comparison_operator:==; 158, 159; 158, 160; 159, identifier:hook; 160, identifier:BEFORE_ALL; 161, block; 161, 162; 162, expression_statement; 162, 163; 163, call; 163, 164; 163, 169; 164, attribute; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:hooks; 167, identifier:_before_all; 168, identifier:append; 169, argument_list; 169, 170; 170, identifier:obj; 171, if_statement; 171, 172; 171, 175; 172, comparison_operator:==; 172, 173; 172, 174; 173, identifier:hook; 174, identifier:AFTER_ALL; 175, block; 175, 176; 176, expression_statement; 176, 177; 177, call; 177, 178; 177, 183; 178, attribute; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:hooks; 181, identifier:_after_all; 182, identifier:append; 183, argument_list; 183, 184; 184, identifier:obj; 185, if_statement; 185, 186; 185, 189; 186, comparison_operator:==; 186, 187; 186, 188; 187, identifier:hook; 188, identifier:BEFORE_EACH; 189, block; 189, 190; 190, expression_statement; 190, 191; 191, call; 191, 192; 191, 197; 192, attribute; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:hooks; 195, identifier:_before_each; 196, identifier:append; 197, argument_list; 197, 198; 198, identifier:obj; 199, if_statement; 199, 200; 199, 203; 200, comparison_operator:==; 200, 201; 200, 202; 201, identifier:hook; 202, identifier:AFTER_EACH; 203, block; 203, 204; 204, expression_statement; 204, 205; 205, call; 205, 206; 205, 211; 206, attribute; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:hooks; 209, identifier:_after_each; 210, identifier:append; 211, argument_list; 211, 212; 212, identifier:obj; 213, if_statement; 213, 214; 213, 217; 214, comparison_operator:==; 214, 215; 214, 216; 215, identifier:hook; 216, identifier:BEFORE_EACH_VALIDATION; 217, block; 217, 218; 218, expression_statement; 218, 219; 219, call; 219, 220; 219, 225; 220, attribute; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:hooks; 223, identifier:_before_each_validation; 224, identifier:append; 225, argument_list; 225, 226; 226, identifier:obj; 227, if_statement; 227, 228; 227, 231; 228, comparison_operator:==; 228, 229; 228, 230; 229, identifier:hook; 230, identifier:BEFORE_VALIDATION; 231, block; 231, 232; 232, expression_statement; 232, 233; 233, call; 233, 234; 233, 235; 234, identifier:add_named_hook; 235, argument_list; 235, 236; 235, 239; 235, 240; 236, attribute; 236, 237; 236, 238; 237, identifier:hooks; 238, identifier:_before_validation; 239, identifier:obj; 240, identifier:name; 241, if_statement; 241, 242; 241, 245; 242, comparison_operator:==; 242, 243; 242, 244; 243, identifier:hook; 244, identifier:BEFORE; 245, block; 245, 246; 246, expression_statement; 246, 247; 247, call; 247, 248; 247, 249; 248, identifier:add_named_hook; 249, argument_list; 249, 250; 249, 253; 249, 254; 250, attribute; 250, 251; 250, 252; 251, identifier:hooks; 252, identifier:_before; 253, identifier:obj; 254, identifier:name; 255, if_statement; 255, 256; 255, 259; 256, comparison_operator:==; 256, 257; 256, 258; 257, identifier:hook; 258, identifier:AFTER; 259, block; 259, 260; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 263; 262, identifier:add_named_hook; 263, argument_list; 263, 264; 263, 267; 263, 268; 264, attribute; 264, 265; 264, 266; 265, identifier:hooks; 266, identifier:_after; 267, identifier:obj; 268, identifier:name | def load_hook_files(pathname):
global hooks
if sys.version_info[0] > 2 and sys.version_info[1] > 4:
fsglob = sorted(glob.iglob(pathname, recursive=True))
else:
fsglob = sorted(glob.iglob(pathname))
for path in fsglob:
real_path = os.path.realpath(path)
if os.path.dirname(real_path) not in sys.path:
sys.path.append(os.path.dirname(real_path))
module = imp.load_source(os.path.basename(path), real_path)
for name in dir(module):
obj = getattr(module, name)
if hasattr(obj, 'dredd_hooks') and callable(obj):
func_hooks = getattr(obj, 'dredd_hooks')
for hook, name in func_hooks:
if hook == BEFORE_ALL:
hooks._before_all.append(obj)
if hook == AFTER_ALL:
hooks._after_all.append(obj)
if hook == BEFORE_EACH:
hooks._before_each.append(obj)
if hook == AFTER_EACH:
hooks._after_each.append(obj)
if hook == BEFORE_EACH_VALIDATION:
hooks._before_each_validation.append(obj)
if hook == BEFORE_VALIDATION:
add_named_hook(hooks._before_validation, obj, name)
if hook == BEFORE:
add_named_hook(hooks._before, obj, name)
if hook == AFTER:
add_named_hook(hooks._after, obj, name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:imports; 5, default_parameter; 5, 6; 5, 7; 6, identifier:separate; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:import_before_from; 10, True; 11, dictionary_splat_pattern; 11, 12; 12, identifier:classify_kwargs; 13, block; 13, 14; 13, 67; 13, 101; 13, 110; 13, 126; 13, 148; 14, if_statement; 14, 15; 14, 16; 14, 39; 15, identifier:separate; 16, block; 16, 17; 16, 33; 17, function_definition; 17, 18; 17, 19; 17, 21; 18, function_name:classify_func; 19, parameters; 19, 20; 20, identifier:obj; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:classify_import; 25, argument_list; 25, 26; 25, 31; 26, attribute; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:obj; 29, identifier:import_statement; 30, identifier:module; 31, dictionary_splat; 31, 32; 32, identifier:classify_kwargs; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:types; 36, attribute; 36, 37; 36, 38; 37, identifier:ImportType; 38, identifier:__all__; 39, else_clause; 39, 40; 40, block; 40, 41; 40, 61; 41, function_definition; 41, 42; 41, 43; 41, 45; 42, function_name:classify_func; 43, parameters; 43, 44; 44, identifier:obj; 45, block; 45, 46; 46, return_statement; 46, 47; 47, comparison_operator:==; 47, 48; 47, 58; 48, call; 48, 49; 48, 50; 49, identifier:classify_import; 50, argument_list; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:obj; 54, identifier:import_statement; 55, identifier:module; 56, dictionary_splat; 56, 57; 57, identifier:classify_kwargs; 58, attribute; 58, 59; 58, 60; 59, identifier:ImportType; 60, identifier:FUTURE; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:types; 64, list:[True, False]; 64, 65; 64, 66; 65, True; 66, False; 67, if_statement; 67, 68; 67, 69; 67, 87; 68, identifier:import_before_from; 69, block; 69, 70; 70, function_definition; 70, 71; 70, 72; 70, 74; 71, function_name:sort_within; 72, parameters; 72, 73; 73, identifier:obj; 74, block; 74, 75; 75, return_statement; 75, 76; 76, binary_operator:+; 76, 77; 76, 84; 77, tuple; 77, 78; 78, subscript; 78, 79; 78, 80; 79, identifier:CLS_TO_INDEX; 80, call; 80, 81; 80, 82; 81, identifier:type; 82, argument_list; 82, 83; 83, identifier:obj; 84, attribute; 84, 85; 84, 86; 85, identifier:obj; 86, identifier:sort_key; 87, else_clause; 87, 88; 88, block; 88, 89; 89, function_definition; 89, 90; 89, 91; 89, 93; 90, function_name:sort_within; 91, parameters; 91, 92; 92, identifier:obj; 93, block; 93, 94; 94, return_statement; 94, 95; 95, call; 95, 96; 95, 97; 96, identifier:tuple; 97, argument_list; 97, 98; 98, attribute; 98, 99; 98, 100; 99, identifier:obj; 100, identifier:sort_key; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:imports_partitioned; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:collections; 107, identifier:defaultdict; 108, argument_list; 108, 109; 109, identifier:list; 110, for_statement; 110, 111; 110, 112; 110, 113; 111, identifier:import_obj; 112, identifier:imports; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 124; 116, attribute; 116, 117; 116, 123; 117, subscript; 117, 118; 117, 119; 118, identifier:imports_partitioned; 119, call; 119, 120; 119, 121; 120, identifier:classify_func; 121, argument_list; 121, 122; 122, identifier:import_obj; 123, identifier:append; 124, argument_list; 124, 125; 125, identifier:import_obj; 126, for_statement; 126, 127; 126, 130; 126, 135; 127, pattern_list; 127, 128; 127, 129; 128, identifier:segment_key; 129, identifier:val; 130, call; 130, 131; 130, 134; 131, attribute; 131, 132; 131, 133; 132, identifier:imports_partitioned; 133, identifier:items; 134, argument_list; 135, block; 135, 136; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:imports_partitioned; 140, identifier:segment_key; 141, call; 141, 142; 141, 143; 142, identifier:sorted; 143, argument_list; 143, 144; 143, 145; 144, identifier:val; 145, keyword_argument; 145, 146; 145, 147; 146, identifier:key; 147, identifier:sort_within; 148, return_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:tuple; 151, generator_expression; 151, 152; 151, 158; 151, 161; 152, call; 152, 153; 152, 154; 153, identifier:tuple; 154, argument_list; 154, 155; 155, subscript; 155, 156; 155, 157; 156, identifier:imports_partitioned; 157, identifier:key; 158, for_in_clause; 158, 159; 158, 160; 159, identifier:key; 160, identifier:types; 161, if_clause; 161, 162; 162, comparison_operator:in; 162, 163; 162, 164; 163, identifier:key; 164, identifier:imports_partitioned | def sort(imports, separate=True, import_before_from=True, **classify_kwargs):
if separate:
def classify_func(obj):
return classify_import(
obj.import_statement.module, **classify_kwargs
)
types = ImportType.__all__
else:
def classify_func(obj):
return classify_import(
obj.import_statement.module, **classify_kwargs
) == ImportType.FUTURE
types = [True, False]
if import_before_from:
def sort_within(obj):
return (CLS_TO_INDEX[type(obj)],) + obj.sort_key
else:
def sort_within(obj):
return tuple(obj.sort_key)
imports_partitioned = collections.defaultdict(list)
for import_obj in imports:
imports_partitioned[classify_func(import_obj)].append(import_obj)
for segment_key, val in imports_partitioned.items():
imports_partitioned[segment_key] = sorted(val, key=sort_within)
return tuple(
tuple(imports_partitioned[key])
for key in types if key in imports_partitioned
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_recursive; 3, parameters; 3, 4; 4, identifier:data; 5, block; 5, 6; 5, 10; 5, 53; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:newdict; 9, dictionary; 10, for_statement; 10, 11; 10, 12; 10, 17; 11, identifier:i; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:data; 15, identifier:items; 16, argument_list; 17, block; 17, 18; 18, if_statement; 18, 19; 18, 27; 18, 41; 19, comparison_operator:is; 19, 20; 19, 26; 20, call; 20, 21; 20, 22; 21, identifier:type; 22, argument_list; 22, 23; 23, subscript; 23, 24; 23, 25; 24, identifier:i; 25, integer:1; 26, identifier:dict; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 35; 30, subscript; 30, 31; 30, 32; 31, identifier:newdict; 32, subscript; 32, 33; 32, 34; 33, identifier:i; 34, integer:0; 35, call; 35, 36; 35, 37; 36, identifier:sort_recursive; 37, argument_list; 37, 38; 38, subscript; 38, 39; 38, 40; 39, identifier:i; 40, integer:1; 41, else_clause; 41, 42; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 50; 45, subscript; 45, 46; 45, 47; 46, identifier:newdict; 47, subscript; 47, 48; 47, 49; 48, identifier:i; 49, integer:0; 50, subscript; 50, 51; 50, 52; 51, identifier:i; 52, integer:1; 53, return_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:OrderedDict; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:sorted; 59, argument_list; 59, 60; 59, 65; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:newdict; 63, identifier:items; 64, argument_list; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:key; 67, lambda; 67, 68; 67, 70; 68, lambda_parameters; 68, 69; 69, identifier:item; 70, tuple; 70, 71; 70, 80; 71, call; 71, 72; 71, 73; 72, identifier:compare_type; 73, argument_list; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:type; 76, argument_list; 76, 77; 77, subscript; 77, 78; 77, 79; 78, identifier:item; 79, integer:1; 80, subscript; 80, 81; 80, 82; 81, identifier:item; 82, integer:0 | def sort_recursive(data):
newdict = {}
for i in data.items():
if type(i[1]) is dict:
newdict[i[0]] = sort_recursive(i[1])
else:
newdict[i[0]] = i[1]
return OrderedDict(sorted(newdict.items(), key=lambda item: (compare_type(type(item[1])), item[0]))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:names_to_abbreviations; 3, parameters; 3, 4; 4, identifier:reporters; 5, block; 5, 6; 5, 10; 5, 70; 5, 92; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:names; 9, dictionary; 10, for_statement; 10, 11; 10, 14; 10, 19; 11, pattern_list; 11, 12; 11, 13; 12, identifier:reporter_key; 13, identifier:data_list; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:reporters; 17, identifier:items; 18, argument_list; 19, block; 19, 20; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:data; 22, identifier:data_list; 23, block; 23, 24; 23, 34; 23, 52; 23, 62; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:abbrevs; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:data; 31, string:'editions'; 32, identifier:keys; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:sort_func; 37, lambda; 37, 38; 37, 40; 38, lambda_parameters; 38, 39; 39, identifier:x; 40, binary_operator:+; 40, 41; 40, 51; 41, call; 41, 42; 41, 43; 42, identifier:str; 43, argument_list; 43, 44; 44, subscript; 44, 45; 44, 50; 45, subscript; 45, 46; 45, 49; 46, subscript; 46, 47; 46, 48; 47, identifier:data; 48, string:'editions'; 49, identifier:x; 50, string:'start'; 51, identifier:x; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:abbrevs; 55, call; 55, 56; 55, 57; 56, identifier:sorted; 57, argument_list; 57, 58; 57, 59; 58, identifier:abbrevs; 59, keyword_argument; 59, 60; 59, 61; 60, identifier:key; 61, identifier:sort_func; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 69; 64, subscript; 64, 65; 64, 66; 65, identifier:names; 66, subscript; 66, 67; 66, 68; 67, identifier:data; 68, string:'name'; 69, identifier:abbrevs; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:sorted_names; 73, call; 73, 74; 73, 75; 74, identifier:OrderedDict; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 78; 77, identifier:sorted; 78, argument_list; 78, 79; 78, 84; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:names; 82, identifier:items; 83, argument_list; 84, keyword_argument; 84, 85; 84, 86; 85, identifier:key; 86, lambda; 86, 87; 86, 89; 87, lambda_parameters; 87, 88; 88, identifier:t; 89, subscript; 89, 90; 89, 91; 90, identifier:t; 91, integer:0; 92, return_statement; 92, 93; 93, identifier:sorted_names | def names_to_abbreviations(reporters):
names = {}
for reporter_key, data_list in reporters.items():
for data in data_list:
abbrevs = data['editions'].keys()
sort_func = lambda x: str(data['editions'][x]['start']) + x
abbrevs = sorted(abbrevs, key=sort_func)
names[data['name']] = abbrevs
sorted_names = OrderedDict(sorted(names.items(), key=lambda t: t[0]))
return sorted_names |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:flatten; 3, parameters; 3, 4; 4, identifier:weights; 5, block; 5, 6; 5, 126; 6, if_statement; 6, 7; 6, 14; 6, 37; 6, 119; 7, call; 7, 8; 7, 9; 8, identifier:isinstance; 9, argument_list; 9, 10; 9, 11; 10, identifier:weights; 11, attribute; 11, 12; 11, 13; 12, identifier:pd; 13, identifier:DataFrame; 14, block; 14, 15; 14, 27; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:wts; 18, call; 18, 19; 18, 26; 19, attribute; 19, 20; 19, 25; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:weights; 23, identifier:stack; 24, argument_list; 25, identifier:reset_index; 26, argument_list; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:wts; 31, identifier:columns; 32, list:["date", "contract", "generic", "weight"]; 32, 33; 32, 34; 32, 35; 32, 36; 33, string:"date"; 34, string:"contract"; 35, string:"generic"; 36, string:"weight"; 37, elif_clause; 37, 38; 37, 43; 38, call; 38, 39; 38, 40; 39, identifier:isinstance; 40, argument_list; 40, 41; 40, 42; 41, identifier:weights; 42, identifier:dict; 43, block; 43, 44; 43, 48; 43, 100; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:wts; 47, list:[]; 48, for_statement; 48, 49; 48, 50; 48, 58; 49, identifier:key; 50, call; 50, 51; 50, 52; 51, identifier:sorted; 52, argument_list; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:weights; 56, identifier:keys; 57, argument_list; 58, block; 58, 59; 58, 73; 58, 83; 58, 93; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:wt; 62, call; 62, 63; 62, 72; 63, attribute; 63, 64; 63, 71; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:weights; 68, identifier:key; 69, identifier:stack; 70, argument_list; 71, identifier:reset_index; 72, argument_list; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:wt; 77, identifier:columns; 78, list:["date", "contract", "generic", "weight"]; 78, 79; 78, 80; 78, 81; 78, 82; 79, string:"date"; 80, string:"contract"; 81, string:"generic"; 82, string:"weight"; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 92; 85, subscript; 85, 86; 85, 89; 85, 91; 86, attribute; 86, 87; 86, 88; 87, identifier:wt; 88, identifier:loc; 89, slice; 89, 90; 90, colon; 91, string:"key"; 92, identifier:key; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:wts; 97, identifier:append; 98, argument_list; 98, 99; 99, identifier:wt; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:wts; 103, call; 103, 104; 103, 115; 104, attribute; 104, 105; 104, 114; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:pd; 108, identifier:concat; 109, argument_list; 109, 110; 109, 111; 110, identifier:wts; 111, keyword_argument; 111, 112; 111, 113; 112, identifier:axis; 113, integer:0; 114, identifier:reset_index; 115, argument_list; 115, 116; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:drop; 118, True; 119, else_clause; 119, 120; 120, block; 120, 121; 121, raise_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:ValueError; 124, argument_list; 124, 125; 125, string:"weights must be pd.DataFrame or dict"; 126, return_statement; 126, 127; 127, identifier:wts | def flatten(weights):
if isinstance(weights, pd.DataFrame):
wts = weights.stack().reset_index()
wts.columns = ["date", "contract", "generic", "weight"]
elif isinstance(weights, dict):
wts = []
for key in sorted(weights.keys()):
wt = weights[key].stack().reset_index()
wt.columns = ["date", "contract", "generic", "weight"]
wt.loc[:, "key"] = key
wts.append(wt)
wts = pd.concat(wts, axis=0).reset_index(drop=True)
else:
raise ValueError("weights must be pd.DataFrame or dict")
return wts |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:calc_trades; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 4, identifier:current_contracts; 5, identifier:desired_holdings; 6, identifier:trade_weights; 7, identifier:prices; 8, identifier:multipliers; 9, dictionary_splat_pattern; 9, 10; 10, identifier:kwargs; 11, block; 11, 12; 11, 27; 11, 31; 11, 46; 11, 86; 11, 90; 11, 191; 11, 203; 11, 215; 11, 225; 11, 233; 12, if_statement; 12, 13; 12, 19; 13, not_operator; 13, 14; 14, call; 14, 15; 14, 16; 15, identifier:isinstance; 16, argument_list; 16, 17; 16, 18; 17, identifier:trade_weights; 18, identifier:dict; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:trade_weights; 23, dictionary; 23, 24; 24, pair; 24, 25; 24, 26; 25, string:""; 26, identifier:trade_weights; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:generics; 30, list:[]; 31, for_statement; 31, 32; 31, 33; 31, 34; 32, identifier:key; 33, identifier:trade_weights; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:generics; 39, identifier:extend; 40, argument_list; 40, 41; 41, attribute; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:trade_weights; 44, identifier:key; 45, identifier:columns; 46, if_statement; 46, 47; 46, 62; 47, not_operator; 47, 48; 48, call; 48, 49; 48, 57; 49, attribute; 49, 50; 49, 56; 50, call; 50, 51; 50, 52; 51, identifier:set; 52, argument_list; 52, 53; 53, attribute; 53, 54; 53, 55; 54, identifier:desired_holdings; 55, identifier:index; 56, identifier:issubset; 57, argument_list; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:set; 60, argument_list; 60, 61; 61, identifier:generics; 62, block; 62, 63; 63, raise_statement; 63, 64; 64, call; 64, 65; 64, 66; 65, identifier:ValueError; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 75; 68, attribute; 68, 69; 68, 74; 69, concatenated_string; 69, 70; 69, 71; 69, 72; 69, 73; 70, string:"'desired_holdings.index' contains values which "; 71, string:"cannot be mapped to tradeables.\n"; 72, string:"Received: 'desired_holdings.index'\n {0}\n"; 73, string:"Expected in 'trade_weights' set of columns:\n {1}\n"; 74, identifier:format; 75, argument_list; 75, 76; 75, 82; 76, call; 76, 77; 76, 78; 77, identifier:sorted; 78, argument_list; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:desired_holdings; 81, identifier:index; 82, call; 82, 83; 82, 84; 83, identifier:sorted; 84, argument_list; 84, 85; 85, identifier:generics; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:desired_contracts; 89, list:[]; 90, for_statement; 90, 91; 90, 92; 90, 93; 91, identifier:root_key; 92, identifier:trade_weights; 93, block; 93, 94; 93, 100; 93, 113; 93, 121; 93, 131; 93, 150; 93, 156; 93, 167; 93, 177; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:gnrc_weights; 97, subscript; 97, 98; 97, 99; 98, identifier:trade_weights; 99, identifier:root_key; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:subset; 103, call; 103, 104; 103, 109; 104, attribute; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:gnrc_weights; 107, identifier:columns; 108, identifier:intersection; 109, argument_list; 109, 110; 110, attribute; 110, 111; 110, 112; 111, identifier:desired_holdings; 112, identifier:index; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:gnrc_des_hlds; 116, subscript; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:desired_holdings; 119, identifier:loc; 120, identifier:subset; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:gnrc_weights; 124, subscript; 124, 125; 124, 128; 124, 130; 125, attribute; 125, 126; 125, 127; 126, identifier:gnrc_weights; 127, identifier:loc; 128, slice; 128, 129; 129, colon; 130, identifier:subset; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:gnrc_weights; 134, subscript; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:gnrc_weights; 137, identifier:loc; 138, unary_operator:~; 138, 139; 139, call; 139, 140; 139, 146; 140, attribute; 140, 141; 140, 145; 141, parenthesized_expression; 141, 142; 142, comparison_operator:==; 142, 143; 142, 144; 143, identifier:gnrc_weights; 144, integer:0; 145, identifier:all; 146, argument_list; 146, 147; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:axis; 149, integer:1; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:instr_des_hlds; 153, binary_operator:*; 153, 154; 153, 155; 154, identifier:gnrc_des_hlds; 155, identifier:gnrc_weights; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 159; 158, identifier:instr_des_hlds; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:instr_des_hlds; 162, identifier:sum; 163, argument_list; 163, 164; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:axis; 166, integer:1; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:wprices; 170, subscript; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:prices; 173, identifier:loc; 174, attribute; 174, 175; 174, 176; 175, identifier:instr_des_hlds; 176, identifier:index; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:desired_contracts; 181, identifier:append; 182, argument_list; 182, 183; 183, call; 183, 184; 183, 185; 184, identifier:to_contracts; 185, argument_list; 185, 186; 185, 187; 185, 188; 185, 189; 186, identifier:instr_des_hlds; 187, identifier:wprices; 188, identifier:multipliers; 189, dictionary_splat; 189, 190; 190, identifier:kwargs; 191, expression_statement; 191, 192; 192, assignment; 192, 193; 192, 194; 193, identifier:desired_contracts; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:pd; 197, identifier:concat; 198, argument_list; 198, 199; 198, 200; 199, identifier:desired_contracts; 200, keyword_argument; 200, 201; 200, 202; 201, identifier:axis; 202, integer:0; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:trades; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:desired_contracts; 209, identifier:subtract; 210, argument_list; 210, 211; 210, 212; 211, identifier:current_contracts; 212, keyword_argument; 212, 213; 212, 214; 213, identifier:fill_value; 214, integer:0; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:trades; 218, subscript; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:trades; 221, identifier:loc; 222, comparison_operator:!=; 222, 223; 222, 224; 223, identifier:trades; 224, integer:0; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:trades; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:trades; 231, identifier:sort_index; 232, argument_list; 233, return_statement; 233, 234; 234, identifier:trades | def calc_trades(current_contracts, desired_holdings, trade_weights, prices,
multipliers, **kwargs):
if not isinstance(trade_weights, dict):
trade_weights = {"": trade_weights}
generics = []
for key in trade_weights:
generics.extend(trade_weights[key].columns)
if not set(desired_holdings.index).issubset(set(generics)):
raise ValueError("'desired_holdings.index' contains values which "
"cannot be mapped to tradeables.\n"
"Received: 'desired_holdings.index'\n {0}\n"
"Expected in 'trade_weights' set of columns:\n {1}\n"
.format(sorted(desired_holdings.index),
sorted(generics)))
desired_contracts = []
for root_key in trade_weights:
gnrc_weights = trade_weights[root_key]
subset = gnrc_weights.columns.intersection(desired_holdings.index)
gnrc_des_hlds = desired_holdings.loc[subset]
gnrc_weights = gnrc_weights.loc[:, subset]
gnrc_weights = gnrc_weights.loc[~(gnrc_weights == 0).all(axis=1)]
instr_des_hlds = gnrc_des_hlds * gnrc_weights
instr_des_hlds = instr_des_hlds.sum(axis=1)
wprices = prices.loc[instr_des_hlds.index]
desired_contracts.append(to_contracts(instr_des_hlds, wprices,
multipliers, **kwargs))
desired_contracts = pd.concat(desired_contracts, axis=0)
trades = desired_contracts.subtract(current_contracts, fill_value=0)
trades = trades.loc[trades != 0]
trades = trades.sort_index()
return trades |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_multiplier; 3, parameters; 3, 4; 3, 5; 4, identifier:weights; 5, identifier:root_generic_multiplier; 6, block; 6, 7; 6, 29; 6, 33; 6, 37; 6, 93; 6, 103; 6, 111; 7, if_statement; 7, 8; 7, 21; 8, boolean_operator:and; 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:root_generic_multiplier; 14, integer:1; 15, not_operator; 15, 16; 16, call; 16, 17; 16, 18; 17, identifier:isinstance; 18, argument_list; 18, 19; 18, 20; 19, identifier:weights; 20, identifier:dict; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, concatenated_string; 26, 27; 26, 28; 27, string:"For multiple generic instruments weights must be a "; 28, string:"dictionary"; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:mults; 32, list:[]; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:intrs; 36, list:[]; 37, for_statement; 37, 38; 37, 41; 37, 46; 38, pattern_list; 38, 39; 38, 40; 39, identifier:ast; 40, identifier:multiplier; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:root_generic_multiplier; 44, identifier:iteritems; 45, argument_list; 46, block; 46, 47; 46, 70; 46, 86; 47, if_statement; 47, 48; 47, 53; 47, 62; 48, call; 48, 49; 48, 50; 49, identifier:isinstance; 50, argument_list; 50, 51; 50, 52; 51, identifier:weights; 52, identifier:dict; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:weights_ast; 57, attribute; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:weights; 60, identifier:ast; 61, identifier:index; 62, else_clause; 62, 63; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:weights_ast; 67, attribute; 67, 68; 67, 69; 68, identifier:weights; 69, identifier:index; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:mults; 74, identifier:extend; 75, argument_list; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:np; 79, identifier:repeat; 80, argument_list; 80, 81; 80, 82; 81, identifier:multiplier; 82, call; 82, 83; 82, 84; 83, identifier:len; 84, argument_list; 84, 85; 85, identifier:weights_ast; 86, expression_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:intrs; 90, identifier:extend; 91, argument_list; 91, 92; 92, identifier:weights_ast; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:imults; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:pd; 99, identifier:Series; 100, argument_list; 100, 101; 100, 102; 101, identifier:mults; 102, identifier:intrs; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:imults; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:imults; 109, identifier:sort_index; 110, argument_list; 111, return_statement; 111, 112; 112, identifier:imults | def get_multiplier(weights, root_generic_multiplier):
if len(root_generic_multiplier) > 1 and not isinstance(weights, dict):
raise ValueError("For multiple generic instruments weights must be a "
"dictionary")
mults = []
intrs = []
for ast, multiplier in root_generic_multiplier.iteritems():
if isinstance(weights, dict):
weights_ast = weights[ast].index
else:
weights_ast = weights.index
mults.extend(np.repeat(multiplier, len(weights_ast)))
intrs.extend(weights_ast)
imults = pd.Series(mults, intrs)
imults = imults.sort_index()
return imults |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:roller; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:timestamps; 5, identifier:contract_dates; 6, identifier:get_weights; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 17; 9, 25; 9, 30; 9, 34; 9, 38; 9, 44; 9, 60; 9, 64; 9, 88; 9, 95; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:timestamps; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, argument_list; 15, 16; 16, identifier:timestamps; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:contract_dates; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:contract_dates; 23, identifier:sort_values; 24, argument_list; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:_check_contract_dates; 28, argument_list; 28, 29; 29, identifier:contract_dates; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:weights; 33, list:[]; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:validate_inputs; 37, True; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:ts; 41, subscript; 41, 42; 41, 43; 42, identifier:timestamps; 43, integer:0; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:weights; 48, identifier:extend; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:get_weights; 52, argument_list; 52, 53; 52, 54; 52, 55; 52, 58; 53, identifier:ts; 54, identifier:contract_dates; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:validate_inputs; 57, identifier:validate_inputs; 58, dictionary_splat; 58, 59; 59, identifier:kwargs; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:validate_inputs; 63, False; 64, for_statement; 64, 65; 64, 66; 64, 71; 65, identifier:ts; 66, subscript; 66, 67; 66, 68; 67, identifier:timestamps; 68, slice; 68, 69; 68, 70; 69, integer:1; 70, colon; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:weights; 76, identifier:extend; 77, argument_list; 77, 78; 78, call; 78, 79; 78, 80; 79, identifier:get_weights; 80, argument_list; 80, 81; 80, 82; 80, 83; 80, 86; 81, identifier:ts; 82, identifier:contract_dates; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:validate_inputs; 85, identifier:validate_inputs; 86, dictionary_splat; 86, 87; 87, identifier:kwargs; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:weights; 91, call; 91, 92; 91, 93; 92, identifier:aggregate_weights; 93, argument_list; 93, 94; 94, identifier:weights; 95, return_statement; 95, 96; 96, identifier:weights | def roller(timestamps, contract_dates, get_weights, **kwargs):
timestamps = sorted(timestamps)
contract_dates = contract_dates.sort_values()
_check_contract_dates(contract_dates)
weights = []
validate_inputs = True
ts = timestamps[0]
weights.extend(get_weights(ts, contract_dates,
validate_inputs=validate_inputs, **kwargs))
validate_inputs = False
for ts in timestamps[1:]:
weights.extend(get_weights(ts, contract_dates,
validate_inputs=validate_inputs, **kwargs))
weights = aggregate_weights(weights)
return weights |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:strictly_monotonic; 3, parameters; 3, 4; 4, identifier:bb; 5, block; 5, 6; 5, 8; 5, 21; 5, 27; 5, 42; 5, 53; 5, 65; 6, expression_statement; 6, 7; 7, string:'''
bb is an index array which may have numerous double or triple
occurrences of indices, such as for example the decay_index_pointer.
This method removes all entries <= -, then all dublicates and
finally returns a sorted list of indices.
'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:cc; 11, subscript; 11, 12; 11, 13; 12, identifier:bb; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:where; 17, argument_list; 17, 18; 18, comparison_operator:>=; 18, 19; 18, 20; 19, identifier:bb; 20, integer:0; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:cc; 25, identifier:sort; 26, argument_list; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:dc; 30, binary_operator:-; 30, 31; 30, 36; 31, subscript; 31, 32; 31, 33; 32, identifier:cc; 33, slice; 33, 34; 33, 35; 34, integer:1; 35, colon; 36, subscript; 36, 37; 36, 38; 37, identifier:cc; 38, slice; 38, 39; 38, 40; 39, colon; 40, unary_operator:-; 40, 41; 41, integer:1; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:dc; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:np; 48, identifier:insert; 49, argument_list; 49, 50; 49, 51; 49, 52; 50, identifier:dc; 51, integer:0; 52, integer:1; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:dc_mask; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:np; 60, identifier:ma; 61, identifier:masked_equal; 62, argument_list; 62, 63; 62, 64; 63, identifier:dc; 64, integer:0; 65, return_statement; 65, 66; 66, call; 66, 67; 66, 82; 67, attribute; 67, 68; 67, 81; 68, call; 68, 69; 68, 74; 69, attribute; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:np; 72, identifier:ma; 73, identifier:array; 74, argument_list; 74, 75; 74, 76; 75, identifier:cc; 76, keyword_argument; 76, 77; 76, 78; 77, identifier:mask; 78, attribute; 78, 79; 78, 80; 79, identifier:dc_mask; 80, identifier:mask; 81, identifier:compressed; 82, argument_list | def strictly_monotonic(bb):
'''
bb is an index array which may have numerous double or triple
occurrences of indices, such as for example the decay_index_pointer.
This method removes all entries <= -, then all dublicates and
finally returns a sorted list of indices.
'''
cc=bb[np.where(bb>=0)]
cc.sort()
dc=cc[1:]-cc[:-1]
dc=np.insert(dc,0,1)
dc_mask=np.ma.masked_equal(dc,0)
return np.ma.array(cc,mask=dc_mask.mask).compressed() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sort_shared_logical_disks; 3, parameters; 3, 4; 4, identifier:logical_disks; 5, block; 5, 6; 5, 24; 5, 45; 5, 49; 5, 53; 5, 75; 5, 79; 5, 83; 5, 106; 5, 119; 5, 123; 5, 203; 5, 212; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:is_shared; 9, parenthesized_expression; 9, 10; 10, lambda; 10, 11; 10, 13; 11, lambda_parameters; 11, 12; 12, identifier:x; 13, conditional_expression:if; 13, 14; 13, 15; 13, 23; 14, True; 15, parenthesized_expression; 15, 16; 16, boolean_operator:and; 16, 17; 16, 20; 17, comparison_operator:in; 17, 18; 17, 19; 18, string:'share_physical_disks'; 19, identifier:x; 20, subscript; 20, 21; 20, 22; 21, identifier:x; 22, string:'share_physical_disks'; 23, False; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:num_of_disks; 27, parenthesized_expression; 27, 28; 28, lambda; 28, 29; 28, 31; 29, lambda_parameters; 29, 30; 30, identifier:x; 31, conditional_expression:if; 31, 32; 31, 35; 31, 38; 32, subscript; 32, 33; 32, 34; 33, identifier:x; 34, string:'number_of_physical_disks'; 35, comparison_operator:in; 35, 36; 35, 37; 36, string:'number_of_physical_disks'; 37, identifier:x; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:constants; 41, identifier:RAID_LEVEL_MIN_DISKS; 42, subscript; 42, 43; 42, 44; 43, identifier:x; 44, string:'raid_level'; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:logical_disks_shared; 48, list:[]; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:logical_disks_nonshared; 52, list:[]; 53, for_statement; 53, 54; 53, 55; 53, 56; 54, identifier:x; 55, identifier:logical_disks; 56, block; 56, 57; 56, 68; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:target; 60, parenthesized_expression; 60, 61; 61, conditional_expression:if; 61, 62; 61, 63; 61, 67; 62, identifier:logical_disks_shared; 63, call; 63, 64; 63, 65; 64, identifier:is_shared; 65, argument_list; 65, 66; 66, identifier:x; 67, identifier:logical_disks_nonshared; 68, expression_statement; 68, 69; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:target; 72, identifier:append; 73, argument_list; 73, 74; 74, identifier:x; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:logical_disks_shared_raid1; 78, list:[]; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:logical_disks_shared_excl_raid1; 82, list:[]; 83, for_statement; 83, 84; 83, 85; 83, 86; 84, identifier:x; 85, identifier:logical_disks_shared; 86, block; 86, 87; 86, 99; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 90; 89, identifier:target; 90, parenthesized_expression; 90, 91; 91, conditional_expression:if; 91, 92; 91, 93; 91, 98; 92, identifier:logical_disks_shared_raid1; 93, comparison_operator:==; 93, 94; 93, 97; 94, subscript; 94, 95; 94, 96; 95, identifier:x; 96, string:'raid_level'; 97, string:'1'; 98, identifier:logical_disks_shared_excl_raid1; 99, expression_statement; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:target; 103, identifier:append; 104, argument_list; 104, 105; 105, identifier:x; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:logical_disks_shared; 109, call; 109, 110; 109, 111; 110, identifier:sorted; 111, argument_list; 111, 112; 111, 113; 111, 116; 112, identifier:logical_disks_shared_excl_raid1; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:reverse; 115, True; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:key; 118, identifier:num_of_disks; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:check; 122, True; 123, for_statement; 123, 124; 123, 125; 123, 126; 124, identifier:x; 125, identifier:logical_disks_shared; 126, block; 126, 127; 126, 180; 127, if_statement; 127, 128; 127, 133; 128, comparison_operator:==; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:x; 131, string:'raid_level'; 132, string:"1+0"; 133, block; 133, 134; 133, 141; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:x_num; 137, call; 137, 138; 137, 139; 138, identifier:num_of_disks; 139, argument_list; 139, 140; 140, identifier:x; 141, for_statement; 141, 142; 141, 143; 141, 144; 142, identifier:y; 143, identifier:logical_disks_shared; 144, block; 144, 145; 145, if_statement; 145, 146; 145, 151; 146, comparison_operator:!=; 146, 147; 146, 150; 147, subscript; 147, 148; 147, 149; 148, identifier:y; 149, string:'raid_level'; 150, string:"1+0"; 151, block; 151, 152; 151, 159; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:y_num; 155, call; 155, 156; 155, 157; 156, identifier:num_of_disks; 157, argument_list; 157, 158; 158, identifier:y; 159, if_statement; 159, 160; 159, 163; 160, comparison_operator:<; 160, 161; 160, 162; 161, identifier:x_num; 162, identifier:y_num; 163, block; 163, 164; 163, 176; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:check; 167, parenthesized_expression; 167, 168; 168, conditional_expression:if; 168, 169; 168, 170; 168, 175; 169, True; 170, comparison_operator:==; 170, 171; 170, 174; 171, binary_operator:%; 171, 172; 171, 173; 172, identifier:y_num; 173, integer:2; 174, integer:0; 175, False; 176, if_statement; 176, 177; 176, 178; 177, identifier:check; 178, block; 178, 179; 179, break_statement; 180, if_statement; 180, 181; 180, 183; 181, not_operator; 181, 182; 182, identifier:check; 183, block; 183, 184; 183, 191; 183, 199; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:logical_disks_shared; 188, identifier:remove; 189, argument_list; 189, 190; 190, identifier:x; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:logical_disks_shared; 195, identifier:insert; 196, argument_list; 196, 197; 196, 198; 197, integer:0; 198, identifier:x; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:check; 202, True; 203, expression_statement; 203, 204; 204, assignment; 204, 205; 204, 206; 205, identifier:logical_disks_sorted; 206, parenthesized_expression; 206, 207; 207, binary_operator:+; 207, 208; 207, 211; 208, binary_operator:+; 208, 209; 208, 210; 209, identifier:logical_disks_nonshared; 210, identifier:logical_disks_shared_raid1; 211, identifier:logical_disks_shared; 212, return_statement; 212, 213; 213, identifier:logical_disks_sorted | def _sort_shared_logical_disks(logical_disks):
is_shared = (lambda x: True if ('share_physical_disks' in x and
x['share_physical_disks']) else False)
num_of_disks = (lambda x: x['number_of_physical_disks']
if 'number_of_physical_disks' in x else
constants.RAID_LEVEL_MIN_DISKS[x['raid_level']])
logical_disks_shared = []
logical_disks_nonshared = []
for x in logical_disks:
target = (logical_disks_shared if is_shared(x)
else logical_disks_nonshared)
target.append(x)
logical_disks_shared_raid1 = []
logical_disks_shared_excl_raid1 = []
for x in logical_disks_shared:
target = (logical_disks_shared_raid1 if x['raid_level'] == '1'
else logical_disks_shared_excl_raid1)
target.append(x)
logical_disks_shared = sorted(logical_disks_shared_excl_raid1,
reverse=True,
key=num_of_disks)
check = True
for x in logical_disks_shared:
if x['raid_level'] == "1+0":
x_num = num_of_disks(x)
for y in logical_disks_shared:
if y['raid_level'] != "1+0":
y_num = num_of_disks(y)
if x_num < y_num:
check = (True if y_num % 2 == 0 else False)
if check:
break
if not check:
logical_disks_shared.remove(x)
logical_disks_shared.insert(0, x)
check = True
logical_disks_sorted = (logical_disks_nonshared +
logical_disks_shared_raid1 +
logical_disks_shared)
return logical_disks_sorted |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_versions; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cls; 5, identifier:bucket; 6, identifier:key; 7, default_parameter; 7, 8; 7, 9; 8, identifier:desc; 9, True; 10, block; 10, 11; 10, 28; 10, 47; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:filters; 14, list:[
cls.bucket_id == as_bucket_id(bucket),
cls.key == key,
]; 14, 15; 14, 23; 15, comparison_operator:==; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:cls; 18, identifier:bucket_id; 19, call; 19, 20; 19, 21; 20, identifier:as_bucket_id; 21, argument_list; 21, 22; 22, identifier:bucket; 23, comparison_operator:==; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:cls; 26, identifier:key; 27, identifier:key; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:order; 31, conditional_expression:if; 31, 32; 31, 39; 31, 40; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:cls; 36, identifier:created; 37, identifier:desc; 38, argument_list; 39, identifier:desc; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:cls; 44, identifier:created; 45, identifier:asc; 46, argument_list; 47, return_statement; 47, 48; 48, call; 48, 49; 48, 60; 49, attribute; 49, 50; 49, 59; 50, call; 50, 51; 50, 56; 51, attribute; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:cls; 54, identifier:query; 55, identifier:filter; 56, argument_list; 56, 57; 57, list_splat; 57, 58; 58, identifier:filters; 59, identifier:order_by; 60, argument_list; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:cls; 63, identifier:key; 64, identifier:order | def get_versions(cls, bucket, key, desc=True):
filters = [
cls.bucket_id == as_bucket_id(bucket),
cls.key == key,
]
order = cls.created.desc() if desc else cls.created.asc()
return cls.query.filter(*filters).order_by(cls.key, order) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort_by; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:ids; 7, block; 7, 8; 7, 25; 7, 58; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:files; 11, dictionary_comprehension; 11, 12; 11, 22; 12, pair; 12, 13; 12, 19; 13, call; 13, 14; 13, 15; 14, identifier:str; 15, argument_list; 15, 16; 16, attribute; 16, 17; 16, 18; 17, identifier:f_; 18, identifier:file_id; 19, attribute; 19, 20; 19, 21; 20, identifier:f_; 21, identifier:key; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:f_; 24, identifier:self; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:filesmap; 30, call; 30, 31; 30, 32; 31, identifier:OrderedDict; 32, argument_list; 32, 33; 33, list_comprehension; 33, 34; 33, 55; 34, tuple; 34, 35; 34, 42; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:files; 38, identifier:get; 39, argument_list; 39, 40; 39, 41; 40, identifier:id_; 41, identifier:id_; 42, call; 42, 43; 42, 54; 43, attribute; 43, 44; 43, 53; 44, subscript; 44, 45; 44, 46; 45, identifier:self; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:files; 49, identifier:get; 50, argument_list; 50, 51; 50, 52; 51, identifier:id_; 52, identifier:id_; 53, identifier:dumps; 54, argument_list; 55, for_in_clause; 55, 56; 55, 57; 56, identifier:id_; 57, identifier:ids; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:flush; 63, argument_list | def sort_by(self, *ids):
files = {str(f_.file_id): f_.key for f_ in self}
self.filesmap = OrderedDict([
(files.get(id_, id_), self[files.get(id_, id_)].dumps())
for id_ in ids
])
self.flush() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sorted_files_from_bucket; 3, parameters; 3, 4; 3, 5; 4, identifier:bucket; 5, default_parameter; 5, 6; 5, 7; 6, identifier:keys; 7, None; 8, block; 8, 9; 8, 15; 8, 22; 8, 36; 8, 49; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:keys; 12, boolean_operator:or; 12, 13; 12, 14; 13, identifier:keys; 14, list:[]; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:total; 18, call; 18, 19; 18, 20; 19, identifier:len; 20, argument_list; 20, 21; 21, identifier:keys; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sortby; 25, call; 25, 26; 25, 27; 26, identifier:dict; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:zip; 30, argument_list; 30, 31; 30, 32; 31, identifier:keys; 32, call; 32, 33; 32, 34; 33, identifier:range; 34, argument_list; 34, 35; 35, identifier:total; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:values; 39, call; 39, 40; 39, 48; 40, attribute; 40, 41; 40, 47; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:ObjectVersion; 44, identifier:get_by_bucket; 45, argument_list; 45, 46; 46, identifier:bucket; 47, identifier:all; 48, argument_list; 49, return_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:sorted; 52, argument_list; 52, 53; 52, 54; 53, identifier:values; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:key; 56, lambda; 56, 57; 56, 59; 57, lambda_parameters; 57, 58; 58, identifier:x; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:sortby; 62, identifier:get; 63, argument_list; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:x; 66, identifier:key; 67, identifier:total | def sorted_files_from_bucket(bucket, keys=None):
keys = keys or []
total = len(keys)
sortby = dict(zip(keys, range(total)))
values = ObjectVersion.get_by_bucket(bucket).all()
return sorted(values, key=lambda x: sortby.get(x.key, total)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_data; 3, parameters; 3, 4; 3, 5; 4, identifier:x; 5, identifier:y; 6, block; 6, 7; 6, 18; 6, 28; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:xy; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:zip; 15, argument_list; 15, 16; 15, 17; 16, identifier:x; 17, identifier:y; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:x; 22, identifier:y; 23, call; 23, 24; 23, 25; 24, identifier:zip; 25, argument_list; 25, 26; 26, list_splat; 26, 27; 27, identifier:xy; 28, return_statement; 28, 29; 29, expression_list; 29, 30; 29, 31; 30, identifier:x; 31, identifier:y | def sort_data(x, y):
xy = sorted(zip(x, y))
x, y = zip(*xy)
return x, y |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:unsort_vector; 3, parameters; 3, 4; 3, 5; 4, identifier:data; 5, identifier:indices_of_increasing; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:numpy; 11, identifier:array; 12, argument_list; 12, 13; 13, list_comprehension; 13, 14; 13, 22; 14, subscript; 14, 15; 14, 16; 15, identifier:data; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:indices_of_increasing; 19, identifier:index; 20, argument_list; 20, 21; 21, identifier:i; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:i; 24, call; 24, 25; 24, 26; 25, identifier:range; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:data | def unsort_vector(data, indices_of_increasing):
return numpy.array([data[indices_of_increasing.index(i)] for i in range(len(data))]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_compute_sorted_indices; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 55; 5, 63; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:sorted_indices; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 20; 11, identifier:to_sort; 12, binary_operator:+; 12, 13; 12, 17; 13, list:[self.y]; 13, 14; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:y; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:x; 20, block; 20, 21; 20, 36; 20, 42; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:data_w_indices; 24, list_comprehension; 24, 25; 24, 28; 25, tuple; 25, 26; 25, 27; 26, identifier:val; 27, identifier:i; 28, for_in_clause; 28, 29; 28, 32; 29, tuple_pattern; 29, 30; 29, 31; 30, identifier:i; 31, identifier:val; 32, call; 32, 33; 32, 34; 33, identifier:enumerate; 34, argument_list; 34, 35; 35, identifier:to_sort; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:data_w_indices; 40, identifier:sort; 41, argument_list; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:sorted_indices; 46, identifier:append; 47, argument_list; 47, 48; 48, list_comprehension; 48, 49; 48, 50; 49, identifier:i; 50, for_in_clause; 50, 51; 50, 54; 51, pattern_list; 51, 52; 51, 53; 52, identifier:val; 53, identifier:i; 54, identifier:data_w_indices; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:_yi_sorted; 60, subscript; 60, 61; 60, 62; 61, identifier:sorted_indices; 62, integer:0; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_xi_sorted; 68, subscript; 68, 69; 68, 70; 69, identifier:sorted_indices; 70, slice; 70, 71; 70, 72; 71, integer:1; 72, colon | def _compute_sorted_indices(self):
sorted_indices = []
for to_sort in [self.y] + self.x:
data_w_indices = [(val, i) for (i, val) in enumerate(to_sort)]
data_w_indices.sort()
sorted_indices.append([i for val, i in data_w_indices])
self._yi_sorted = sorted_indices[0]
self._xi_sorted = sorted_indices[1:] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:specify_data_set; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:x_input; 6, identifier:y_input; 7, default_parameter; 7, 8; 7, 9; 8, identifier:sort_data; 9, False; 10, block; 10, 11; 10, 88; 10, 94; 11, if_statement; 11, 12; 11, 13; 11, 78; 12, identifier:sort_data; 13, block; 13, 14; 13, 25; 13, 35; 13, 42; 13, 57; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:xy; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:zip; 22, argument_list; 22, 23; 22, 24; 23, identifier:x_input; 24, identifier:y_input; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, pattern_list; 27, 28; 27, 29; 28, identifier:x; 29, identifier:y; 30, call; 30, 31; 30, 32; 31, identifier:zip; 32, argument_list; 32, 33; 33, list_splat; 33, 34; 34, identifier:xy; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:x_input_list; 38, call; 38, 39; 38, 40; 39, identifier:list; 40, argument_list; 40, 41; 41, identifier:x_input; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:_original_index_of_xvalue; 47, list_comprehension; 47, 48; 47, 54; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:x_input_list; 51, identifier:index; 52, argument_list; 52, 53; 53, identifier:xi; 54, for_in_clause; 54, 55; 54, 56; 55, identifier:xi; 56, identifier:x; 57, if_statement; 57, 58; 57, 72; 58, comparison_operator:!=; 58, 59; 58, 68; 59, call; 59, 60; 59, 61; 60, identifier:len; 61, argument_list; 61, 62; 62, call; 62, 63; 62, 64; 63, identifier:set; 64, argument_list; 64, 65; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:_original_index_of_xvalue; 68, call; 68, 69; 68, 70; 69, identifier:len; 70, argument_list; 70, 71; 71, identifier:x; 72, block; 72, 73; 73, raise_statement; 73, 74; 74, call; 74, 75; 74, 76; 75, identifier:RuntimeError; 76, argument_list; 76, 77; 77, string:'There are some non-unique x-values'; 78, else_clause; 78, 79; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 85; 82, pattern_list; 82, 83; 82, 84; 83, identifier:x; 84, identifier:y; 85, expression_list; 85, 86; 85, 87; 86, identifier:x_input; 87, identifier:y_input; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:x; 93, identifier:x; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:self; 98, identifier:y; 99, identifier:y | def specify_data_set(self, x_input, y_input, sort_data=False):
if sort_data:
xy = sorted(zip(x_input, y_input))
x, y = zip(*xy)
x_input_list = list(x_input)
self._original_index_of_xvalue = [x_input_list.index(xi) for xi in x]
if len(set(self._original_index_of_xvalue)) != len(x):
raise RuntimeError('There are some non-unique x-values')
else:
x, y = x_input, y_input
self.x = x
self.y = y |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:_aggregate; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:data; 5, default_parameter; 5, 6; 5, 7; 6, identifier:norm; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort_by; 10, string:'value'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:keys; 13, None; 14, block; 14, 15; 14, 17; 14, 70; 14, 86; 14, 121; 14, 131; 14, 175; 15, expression_statement; 15, 16; 16, string:'''
Counts the number of occurances of each item in 'data'.
Inputs
data: a list of values.
norm: normalize the resulting counts (as percent)
sort_by: how to sort the retured data. Options are 'value' and 'count'.
Output
a non-redundant list of values (from 'data') and a list of counts.
'''; 17, if_statement; 17, 18; 17, 19; 17, 45; 18, identifier:keys; 19, block; 19, 20; 19, 30; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:vdict; 23, dictionary_comprehension; 23, 24; 23, 27; 24, pair; 24, 25; 24, 26; 25, identifier:k; 26, integer:0; 27, for_in_clause; 27, 28; 27, 29; 28, identifier:k; 29, identifier:keys; 30, for_statement; 30, 31; 30, 32; 30, 33; 31, identifier:d; 32, identifier:data; 33, block; 33, 34; 34, if_statement; 34, 35; 34, 38; 35, comparison_operator:in; 35, 36; 35, 37; 36, identifier:d; 37, identifier:keys; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, augmented_assignment:+=; 40, 41; 40, 44; 41, subscript; 41, 42; 41, 43; 42, identifier:vdict; 43, identifier:d; 44, integer:1; 45, else_clause; 45, 46; 46, block; 46, 47; 46, 51; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:vdict; 50, dictionary; 51, for_statement; 51, 52; 51, 53; 51, 54; 52, identifier:d; 53, identifier:data; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, subscript; 57, 58; 57, 59; 58, identifier:vdict; 59, identifier:d; 60, conditional_expression:if; 60, 61; 60, 66; 60, 69; 61, binary_operator:+; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:vdict; 64, identifier:d; 65, integer:1; 66, comparison_operator:in; 66, 67; 66, 68; 67, identifier:d; 68, identifier:vdict; 69, integer:1; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:vals; 73, list_comprehension; 73, 74; 73, 77; 74, tuple; 74, 75; 74, 76; 75, identifier:k; 76, identifier:v; 77, for_in_clause; 77, 78; 77, 81; 78, pattern_list; 78, 79; 78, 80; 79, identifier:k; 80, identifier:v; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:vdict; 84, identifier:items; 85, argument_list; 86, if_statement; 86, 87; 86, 90; 86, 105; 87, comparison_operator:==; 87, 88; 87, 89; 88, identifier:sort_by; 89, string:'value'; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:vals; 95, identifier:sort; 96, argument_list; 96, 97; 97, keyword_argument; 97, 98; 97, 99; 98, identifier:key; 99, lambda; 99, 100; 99, 102; 100, lambda_parameters; 100, 101; 101, identifier:x; 102, subscript; 102, 103; 102, 104; 103, identifier:x; 104, integer:0; 105, else_clause; 105, 106; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:vals; 111, identifier:sort; 112, argument_list; 112, 113; 113, keyword_argument; 113, 114; 113, 115; 114, identifier:key; 115, lambda; 115, 116; 115, 118; 116, lambda_parameters; 116, 117; 117, identifier:x; 118, subscript; 118, 119; 118, 120; 119, identifier:x; 120, integer:1; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:xs; 124, list_comprehension; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:v; 127, integer:0; 128, for_in_clause; 128, 129; 128, 130; 129, identifier:v; 130, identifier:vals; 131, if_statement; 131, 132; 131, 133; 131, 163; 132, identifier:norm; 133, block; 133, 134; 133, 144; 133, 151; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:raw_y; 137, list_comprehension; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:v; 140, integer:1; 141, for_in_clause; 141, 142; 141, 143; 142, identifier:v; 143, identifier:vals; 144, expression_statement; 144, 145; 145, assignment; 145, 146; 145, 147; 146, identifier:total_y; 147, call; 147, 148; 147, 149; 148, identifier:sum; 149, argument_list; 149, 150; 150, identifier:raw_y; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:ys; 154, list_comprehension; 154, 155; 154, 160; 155, binary_operator:/; 155, 156; 155, 159; 156, binary_operator:*; 156, 157; 156, 158; 157, float:100.; 158, identifier:y; 159, identifier:total_y; 160, for_in_clause; 160, 161; 160, 162; 161, identifier:y; 162, identifier:raw_y; 163, else_clause; 163, 164; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:ys; 168, list_comprehension; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:v; 171, integer:1; 172, for_in_clause; 172, 173; 172, 174; 173, identifier:v; 174, identifier:vals; 175, return_statement; 175, 176; 176, expression_list; 176, 177; 176, 178; 177, identifier:xs; 178, identifier:ys | def _aggregate(data, norm=True, sort_by='value', keys=None):
'''
Counts the number of occurances of each item in 'data'.
Inputs
data: a list of values.
norm: normalize the resulting counts (as percent)
sort_by: how to sort the retured data. Options are 'value' and 'count'.
Output
a non-redundant list of values (from 'data') and a list of counts.
'''
if keys:
vdict = {k: 0 for k in keys}
for d in data:
if d in keys:
vdict[d] += 1
else:
vdict = {}
for d in data:
vdict[d] = vdict[d] + 1 if d in vdict else 1
vals = [(k, v) for k, v in vdict.items()]
if sort_by == 'value':
vals.sort(key=lambda x: x[0])
else:
vals.sort(key=lambda x: x[1])
xs = [v[0] for v in vals]
if norm:
raw_y = [v[1] for v in vals]
total_y = sum(raw_y)
ys = [100. * y / total_y for y in raw_y]
else:
ys = [v[1] for v in vals]
return xs, ys |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:list_files; 3, parameters; 3, 4; 3, 5; 4, identifier:d; 5, default_parameter; 5, 6; 5, 7; 6, identifier:extension; 7, None; 8, block; 8, 9; 8, 11; 8, 53; 8, 125; 9, expression_statement; 9, 10; 10, string:'''
Lists files in a given directory.
Args:
d (str): Path to a directory.
extension (str): If supplied, only files that contain the
specificied extension will be returned. Default is ``False``,
which returns all files in ``d``.
Returns:
list: A sorted list of file paths.
'''; 11, if_statement; 11, 12; 11, 20; 11, 46; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:os; 16, identifier:path; 17, identifier:isdir; 18, argument_list; 18, 19; 19, identifier:d; 20, block; 20, 21; 20, 32; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:expanded_dir; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:os; 28, identifier:path; 29, identifier:expanduser; 30, argument_list; 30, 31; 31, identifier:d; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:files; 35, call; 35, 36; 35, 37; 36, identifier:sorted; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:glob; 41, identifier:glob; 42, argument_list; 42, 43; 43, binary_operator:+; 43, 44; 43, 45; 44, identifier:expanded_dir; 45, string:'/*'; 46, else_clause; 46, 47; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:files; 51, list:[d, ]; 51, 52; 52, identifier:d; 53, if_statement; 53, 54; 53, 57; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:extension; 56, None; 57, block; 57, 58; 57, 71; 58, if_statement; 58, 59; 58, 65; 59, comparison_operator:in; 59, 60; 59, 64; 60, call; 60, 61; 60, 62; 61, identifier:type; 62, argument_list; 62, 63; 63, identifier:extension; 64, identifier:STR_TYPES; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:extension; 69, list:[extension, ]; 69, 70; 70, identifier:extension; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:files; 74, list_comprehension; 74, 75; 74, 76; 74, 79; 75, identifier:f; 76, for_in_clause; 76, 77; 76, 78; 77, identifier:f; 78, identifier:files; 79, if_clause; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:any; 82, argument_list; 82, 83; 83, list:[f.split('.')[-1] in extension,
f.split('.')[-1].upper() in extension,
f.split('.')[-1].lower() in extension]; 83, 84; 83, 95; 83, 110; 84, comparison_operator:in; 84, 85; 84, 94; 85, subscript; 85, 86; 85, 92; 86, call; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:f; 89, identifier:split; 90, argument_list; 90, 91; 91, string:'.'; 92, unary_operator:-; 92, 93; 93, integer:1; 94, identifier:extension; 95, comparison_operator:in; 95, 96; 95, 109; 96, call; 96, 97; 96, 108; 97, attribute; 97, 98; 97, 107; 98, subscript; 98, 99; 98, 105; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:f; 102, identifier:split; 103, argument_list; 103, 104; 104, string:'.'; 105, unary_operator:-; 105, 106; 106, integer:1; 107, identifier:upper; 108, argument_list; 109, identifier:extension; 110, comparison_operator:in; 110, 111; 110, 124; 111, call; 111, 112; 111, 123; 112, attribute; 112, 113; 112, 122; 113, subscript; 113, 114; 113, 120; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:f; 117, identifier:split; 118, argument_list; 118, 119; 119, string:'.'; 120, unary_operator:-; 120, 121; 121, integer:1; 122, identifier:lower; 123, argument_list; 124, identifier:extension; 125, return_statement; 125, 126; 126, identifier:files | def list_files(d, extension=None):
'''
Lists files in a given directory.
Args:
d (str): Path to a directory.
extension (str): If supplied, only files that contain the
specificied extension will be returned. Default is ``False``,
which returns all files in ``d``.
Returns:
list: A sorted list of file paths.
'''
if os.path.isdir(d):
expanded_dir = os.path.expanduser(d)
files = sorted(glob.glob(expanded_dir + '/*'))
else:
files = [d, ]
if extension is not None:
if type(extension) in STR_TYPES:
extension = [extension, ]
files = [f for f in files if any([f.split('.')[-1] in extension,
f.split('.')[-1].upper() in extension,
f.split('.')[-1].lower() in extension])]
return files |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_collections; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:db; 5, default_parameter; 5, 6; 5, 7; 6, identifier:collection; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:prefix; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:suffix; 13, None; 14, block; 14, 15; 14, 17; 14, 25; 14, 36; 14, 56; 14, 76; 15, expression_statement; 15, 16; 16, string:'''
Returns a sorted list of collection names found in ``db``.
Arguments:
db (Database): A pymongo Database object. Can be obtained
with ``get_db``.
collection (str): Name of a collection. If the collection is
present in the MongoDB database, a single-element list will
be returned with the collecion name. If not, an empty list
will be returned. This option is primarly included to allow
for quick checking to see if a collection name is present.
Default is None, which results in this option being ignored.
prefix (str): If supplied, only collections that begin with
``prefix`` will be returned.
suffix (str): If supplied, only collections that end with
``suffix`` will be returned.
Returns:
list: A sorted list of collection names.
'''; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:collection; 20, None; 21, block; 21, 22; 22, return_statement; 22, 23; 23, list:[collection, ]; 23, 24; 24, identifier:collection; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:collections; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:db; 31, identifier:collection_names; 32, argument_list; 32, 33; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:include_system_collections; 35, False; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:prefix; 39, None; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:collections; 44, list_comprehension; 44, 45; 44, 46; 44, 49; 45, identifier:c; 46, for_in_clause; 46, 47; 46, 48; 47, identifier:c; 48, identifier:collections; 49, if_clause; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:c; 53, identifier:startswith; 54, argument_list; 54, 55; 55, identifier:prefix; 56, if_statement; 56, 57; 56, 60; 57, comparison_operator:is; 57, 58; 57, 59; 58, identifier:suffix; 59, None; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:collections; 64, list_comprehension; 64, 65; 64, 66; 64, 69; 65, identifier:c; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:c; 68, identifier:collections; 69, if_clause; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:c; 73, identifier:endswith; 74, argument_list; 74, 75; 75, identifier:suffix; 76, return_statement; 76, 77; 77, call; 77, 78; 77, 79; 78, identifier:sorted; 79, argument_list; 79, 80; 80, identifier:collections | def get_collections(db, collection=None, prefix=None, suffix=None):
'''
Returns a sorted list of collection names found in ``db``.
Arguments:
db (Database): A pymongo Database object. Can be obtained
with ``get_db``.
collection (str): Name of a collection. If the collection is
present in the MongoDB database, a single-element list will
be returned with the collecion name. If not, an empty list
will be returned. This option is primarly included to allow
for quick checking to see if a collection name is present.
Default is None, which results in this option being ignored.
prefix (str): If supplied, only collections that begin with
``prefix`` will be returned.
suffix (str): If supplied, only collections that end with
``suffix`` will be returned.
Returns:
list: A sorted list of collection names.
'''
if collection is not None:
return [collection, ]
collections = db.collection_names(include_system_collections=False)
if prefix is not None:
collections = [c for c in collections if c.startswith(prefix)]
if suffix is not None:
collections = [c for c in collections if c.endswith(suffix)]
return sorted(collections) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:leaf_nodes; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 23; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:deps; 9, set_comprehension; 9, 10; 9, 11; 9, 20; 10, identifier:item; 11, for_in_clause; 11, 12; 11, 13; 12, identifier:sublist; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:edges; 18, identifier:values; 19, argument_list; 20, for_in_clause; 20, 21; 20, 22; 21, identifier:item; 22, identifier:sublist; 23, return_statement; 23, 24; 24, binary_operator:-; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:nodes; 28, identifier:deps | def leaf_nodes(self):
deps = {item for sublist in self.edges.values() for item in sublist}
return self.nodes - deps |
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; 6, while_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:nodes; 10, block; 10, 11; 10, 15; 10, 37; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:iterated; 14, False; 15, for_statement; 15, 16; 15, 17; 15, 22; 16, identifier:node; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:leaf_nodes; 21, argument_list; 22, block; 22, 23; 22, 27; 22, 34; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:iterated; 26, True; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:prune_node; 32, argument_list; 32, 33; 33, identifier:node; 34, expression_statement; 34, 35; 35, yield; 35, 36; 36, identifier:node; 37, if_statement; 37, 38; 37, 40; 38, not_operator; 38, 39; 39, identifier:iterated; 40, block; 40, 41; 41, raise_statement; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:CyclicGraphError; 44, argument_list; 44, 45; 45, string:"Sorting has found a cyclic graph." | def sort(self):
while self.nodes:
iterated = False
for node in self.leaf_nodes():
iterated = True
self.prune_node(node)
yield node
if not iterated:
raise CyclicGraphError("Sorting has found a cyclic graph.") |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:cycles; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 54; 5, 75; 5, 81; 5, 119; 6, function_definition; 6, 7; 6, 8; 6, 11; 7, function_name:walk_node; 8, parameters; 8, 9; 8, 10; 9, identifier:node; 10, identifier:seen; 11, block; 11, 12; 11, 22; 11, 29; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:in; 13, 14; 13, 15; 14, identifier:node; 15, identifier:seen; 16, block; 16, 17; 16, 21; 17, expression_statement; 17, 18; 18, yield; 18, 19; 19, tuple; 19, 20; 20, identifier:node; 21, return_statement; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:seen; 26, identifier:add; 27, argument_list; 27, 28; 28, identifier:node; 29, for_statement; 29, 30; 29, 31; 29, 36; 30, identifier:edge; 31, subscript; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:edges; 35, identifier:node; 36, block; 36, 37; 37, for_statement; 37, 38; 37, 39; 37, 47; 38, identifier:cycle; 39, call; 39, 40; 39, 41; 40, identifier:walk_node; 41, argument_list; 41, 42; 41, 43; 42, identifier:edge; 43, call; 43, 44; 43, 45; 44, identifier:set; 45, argument_list; 45, 46; 46, identifier:seen; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, yield; 49, 50; 50, binary_operator:+; 50, 51; 50, 53; 51, tuple; 51, 52; 52, identifier:node; 53, identifier:cycle; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:cycles; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:chain; 60, identifier:from_iterable; 61, argument_list; 61, 62; 62, generator_expression; 62, 63; 62, 70; 63, call; 63, 64; 63, 65; 64, identifier:walk_node; 65, argument_list; 65, 66; 65, 67; 66, identifier:node; 67, call; 67, 68; 67, 69; 68, identifier:set; 69, argument_list; 70, for_in_clause; 70, 71; 70, 72; 71, identifier:node; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:nodes; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:shortest; 78, call; 78, 79; 78, 80; 79, identifier:set; 80, argument_list; 81, for_statement; 81, 82; 81, 83; 81, 90; 82, identifier:cycle; 83, call; 83, 84; 83, 85; 84, identifier:sorted; 85, argument_list; 85, 86; 85, 87; 86, identifier:cycles; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:key; 89, identifier:len; 90, block; 90, 91; 91, for_statement; 91, 92; 91, 93; 91, 94; 91, 110; 92, identifier:el; 93, identifier:shortest; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 108; 96, call; 96, 97; 96, 103; 97, attribute; 97, 98; 97, 102; 98, call; 98, 99; 98, 100; 99, identifier:set; 100, argument_list; 100, 101; 101, identifier:el; 102, identifier:issubset; 103, argument_list; 103, 104; 104, call; 104, 105; 104, 106; 105, identifier:set; 106, argument_list; 106, 107; 107, identifier:cycle; 108, block; 108, 109; 109, break_statement; 110, else_clause; 110, 111; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:shortest; 116, identifier:add; 117, argument_list; 117, 118; 118, identifier:cycle; 119, return_statement; 119, 120; 120, identifier:shortest | def cycles(self):
def walk_node(node, seen):
if node in seen:
yield (node,)
return
seen.add(node)
for edge in self.edges[node]:
for cycle in walk_node(edge, set(seen)):
yield (node,) + cycle
cycles = chain.from_iterable(
(walk_node(node, set()) for node in self.nodes))
shortest = set()
for cycle in sorted(cycles, key=len):
for el in shortest:
if set(el).issubset(set(cycle)):
break
else:
shortest.add(cycle)
return shortest |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_prepare_imports; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:dicts; 6, block; 6, 7; 6, 13; 6, 17; 6, 33; 6, 70; 6, 83; 6, 146; 6, 152; 6, 158; 6, 162; 6, 211; 6, 237; 6, 254; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:pseudo_ids; 10, call; 10, 11; 10, 12; 11, identifier:set; 12, argument_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:pseudo_matches; 16, dictionary; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:prepared; 20, call; 20, 21; 20, 22; 21, identifier:dict; 22, argument_list; 22, 23; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, call; 25, 26; 25, 27; 26, identifier:super; 27, argument_list; 27, 28; 27, 29; 28, identifier:OrganizationImporter; 29, identifier:self; 30, identifier:_prepare_imports; 31, argument_list; 31, 32; 32, identifier:dicts; 33, for_statement; 33, 34; 33, 37; 33, 42; 34, pattern_list; 34, 35; 34, 36; 35, identifier:_; 36, identifier:data; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:prepared; 40, identifier:items; 41, argument_list; 42, block; 42, 43; 42, 55; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:parent_id; 46, boolean_operator:or; 46, 47; 46, 54; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:data; 50, identifier:get; 51, argument_list; 51, 52; 51, 53; 52, string:'parent_id'; 53, None; 54, string:''; 55, if_statement; 55, 56; 55, 62; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:parent_id; 59, identifier:startswith; 60, argument_list; 60, 61; 61, string:'~'; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:pseudo_ids; 67, identifier:add; 68, argument_list; 68, 69; 69, identifier:parent_id; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 73; 72, identifier:pseudo_ids; 73, list_comprehension; 73, 74; 73, 80; 74, tuple; 74, 75; 74, 76; 75, identifier:ppid; 76, call; 76, 77; 76, 78; 77, identifier:get_pseudo_id; 78, argument_list; 78, 79; 79, identifier:ppid; 80, for_in_clause; 80, 81; 80, 82; 81, identifier:ppid; 82, identifier:pseudo_ids; 83, for_statement; 83, 84; 83, 87; 83, 92; 84, pattern_list; 84, 85; 84, 86; 85, identifier:json_id; 86, identifier:data; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:prepared; 90, identifier:items; 91, argument_list; 92, block; 92, 93; 93, for_statement; 93, 94; 93, 97; 93, 98; 94, pattern_list; 94, 95; 94, 96; 95, identifier:ppid; 96, identifier:spec; 97, identifier:pseudo_ids; 98, block; 98, 99; 98, 103; 98, 125; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:match; 102, True; 103, for_statement; 103, 104; 103, 107; 103, 112; 104, pattern_list; 104, 105; 104, 106; 105, identifier:k; 106, identifier:v; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:spec; 110, identifier:items; 111, argument_list; 112, block; 112, 113; 113, if_statement; 113, 114; 113, 119; 114, comparison_operator:!=; 114, 115; 114, 118; 115, subscript; 115, 116; 115, 117; 116, identifier:data; 117, identifier:k; 118, identifier:v; 119, block; 119, 120; 119, 124; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:match; 123, False; 124, break_statement; 125, if_statement; 125, 126; 125, 127; 126, identifier:match; 127, block; 127, 128; 127, 140; 128, if_statement; 128, 129; 128, 132; 129, comparison_operator:in; 129, 130; 129, 131; 130, identifier:ppid; 131, identifier:pseudo_matches; 132, block; 132, 133; 133, raise_statement; 133, 134; 134, call; 134, 135; 134, 136; 135, identifier:UnresolvedIdError; 136, argument_list; 136, 137; 137, binary_operator:+; 137, 138; 137, 139; 138, string:'multiple matches for pseudo id: '; 139, identifier:ppid; 140, expression_statement; 140, 141; 141, assignment; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:pseudo_matches; 144, identifier:ppid; 145, identifier:json_id; 146, expression_statement; 146, 147; 147, assignment; 147, 148; 147, 149; 148, identifier:network; 149, call; 149, 150; 149, 151; 150, identifier:Network; 151, argument_list; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:in_network; 155, call; 155, 156; 155, 157; 156, identifier:set; 157, argument_list; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:import_order; 161, list:[]; 162, for_statement; 162, 163; 162, 166; 162, 171; 163, pattern_list; 163, 164; 163, 165; 164, identifier:json_id; 165, identifier:data; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:prepared; 169, identifier:items; 170, argument_list; 171, block; 171, 172; 171, 182; 171, 193; 171, 200; 172, expression_statement; 172, 173; 173, assignment; 173, 174; 173, 175; 174, identifier:parent_id; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:data; 178, identifier:get; 179, argument_list; 179, 180; 179, 181; 180, string:'parent_id'; 181, None; 182, if_statement; 182, 183; 182, 186; 183, comparison_operator:in; 183, 184; 183, 185; 184, identifier:parent_id; 185, identifier:pseudo_matches; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, assignment; 188, 189; 188, 190; 189, identifier:parent_id; 190, subscript; 190, 191; 190, 192; 191, identifier:pseudo_matches; 192, identifier:parent_id; 193, expression_statement; 193, 194; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:network; 197, identifier:add_node; 198, argument_list; 198, 199; 199, identifier:json_id; 200, if_statement; 200, 201; 200, 202; 201, identifier:parent_id; 202, block; 202, 203; 203, expression_statement; 203, 204; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, identifier:network; 207, identifier:add_edge; 208, argument_list; 208, 209; 208, 210; 209, identifier:parent_id; 210, identifier:json_id; 211, for_statement; 211, 212; 211, 213; 211, 218; 212, identifier:jid; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:network; 216, identifier:sort; 217, argument_list; 218, block; 218, 219; 218, 230; 219, expression_statement; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:import_order; 223, identifier:append; 224, argument_list; 224, 225; 225, tuple; 225, 226; 225, 227; 226, identifier:jid; 227, subscript; 227, 228; 227, 229; 228, identifier:prepared; 229, identifier:jid; 230, expression_statement; 230, 231; 231, call; 231, 232; 231, 235; 232, attribute; 232, 233; 232, 234; 233, identifier:in_network; 234, identifier:add; 235, argument_list; 235, 236; 236, identifier:jid; 237, if_statement; 237, 238; 237, 248; 238, comparison_operator:!=; 238, 239; 238, 240; 239, identifier:in_network; 240, call; 240, 241; 240, 242; 241, identifier:set; 242, argument_list; 242, 243; 243, call; 243, 244; 243, 247; 244, attribute; 244, 245; 244, 246; 245, identifier:prepared; 246, identifier:keys; 247, argument_list; 248, block; 248, 249; 249, raise_statement; 249, 250; 250, call; 250, 251; 250, 252; 251, identifier:PupaInternalError; 252, argument_list; 252, 253; 253, string:"import is missing nodes in network set"; 254, return_statement; 254, 255; 255, identifier:import_order | def _prepare_imports(self, dicts):
pseudo_ids = set()
pseudo_matches = {}
prepared = dict(super(OrganizationImporter, self)._prepare_imports(dicts))
for _, data in prepared.items():
parent_id = data.get('parent_id', None) or ''
if parent_id.startswith('~'):
pseudo_ids.add(parent_id)
pseudo_ids = [(ppid, get_pseudo_id(ppid)) for ppid in pseudo_ids]
for json_id, data in prepared.items():
for ppid, spec in pseudo_ids:
match = True
for k, v in spec.items():
if data[k] != v:
match = False
break
if match:
if ppid in pseudo_matches:
raise UnresolvedIdError('multiple matches for pseudo id: ' + ppid)
pseudo_matches[ppid] = json_id
network = Network()
in_network = set()
import_order = []
for json_id, data in prepared.items():
parent_id = data.get('parent_id', None)
if parent_id in pseudo_matches:
parent_id = pseudo_matches[parent_id]
network.add_node(json_id)
if parent_id:
network.add_edge(parent_id, json_id)
for jid in network.sort():
import_order.append((jid, prepared[jid]))
in_network.add(jid)
if in_network != set(prepared.keys()):
raise PupaInternalError("import is missing nodes in network set")
return import_order |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:initial; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 8; 4, identifier:self; 5, identifier:request; 6, list_splat_pattern; 6, 7; 7, identifier:args; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 26; 10, 47; 10, 69; 11, expression_statement; 11, 12; 12, call; 12, 13; 12, 20; 13, attribute; 13, 14; 13, 19; 14, call; 14, 15; 14, 16; 15, identifier:super; 16, argument_list; 16, 17; 16, 18; 17, identifier:FlatMultipleModelMixin; 18, identifier:self; 19, identifier:initial; 20, argument_list; 20, 21; 20, 22; 20, 24; 21, identifier:request; 22, list_splat; 22, 23; 23, identifier:args; 24, dictionary_splat; 24, 25; 25, identifier:kwargs; 26, assert_statement; 26, 27; 26, 36; 27, not_operator; 27, 28; 28, parenthesized_expression; 28, 29; 29, boolean_operator:and; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:sorting_field; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:sorting_fields; 36, call; 36, 37; 36, 41; 37, attribute; 37, 38; 37, 39; 37, 40; 38, string:'{} should either define ``sorting_field`` or ``sorting_fields`` property, not both.'; 39, line_continuation:\; 40, identifier:format; 41, argument_list; 41, 42; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:__class__; 46, identifier:__name__; 47, if_statement; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:sorting_field; 51, block; 51, 52; 51, 60; 52, expression_statement; 52, 53; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:warnings; 56, identifier:warn; 57, argument_list; 57, 58; 57, 59; 58, string:'``sorting_field`` property is pending its deprecation. Use ``sorting_fields`` instead.'; 59, identifier:DeprecationWarning; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:sorting_fields; 65, list:[self.sorting_field]; 65, 66; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:sorting_field; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:_sorting_fields; 74, attribute; 74, 75; 74, 76; 75, identifier:self; 76, identifier:sorting_fields | def initial(self, request, *args, **kwargs):
super(FlatMultipleModelMixin, self).initial(request, *args, **kwargs)
assert not (self.sorting_field and self.sorting_fields), \
'{} should either define ``sorting_field`` or ``sorting_fields`` property, not both.' \
.format(self.__class__.__name__)
if self.sorting_field:
warnings.warn(
'``sorting_field`` property is pending its deprecation. Use ``sorting_fields`` instead.',
DeprecationWarning
)
self.sorting_fields = [self.sorting_field]
self._sorting_fields = self.sorting_fields |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:prepare_sorting_fields; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 47; 6, if_statement; 6, 7; 6, 16; 7, comparison_operator:in; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:sorting_parameter_name; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:request; 15, identifier:query_params; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_sorting_fields; 22, list_comprehension; 22, 23; 22, 28; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:_; 26, identifier:strip; 27, argument_list; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:_; 30, call; 30, 31; 30, 45; 31, attribute; 31, 32; 31, 44; 32, call; 32, 33; 32, 40; 33, attribute; 33, 34; 33, 39; 34, attribute; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:request; 38, identifier:query_params; 39, identifier:get; 40, argument_list; 40, 41; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:sorting_parameter_name; 44, identifier:split; 45, argument_list; 45, 46; 46, string:','; 47, if_statement; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:self; 50, identifier:_sorting_fields; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:_sorting_fields; 57, list_comprehension; 57, 58; 57, 83; 58, tuple; 58, 59; 58, 78; 59, call; 59, 60; 59, 65; 60, attribute; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:sorting_fields_map; 64, identifier:get; 65, argument_list; 65, 66; 65, 72; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:field; 69, identifier:lstrip; 70, argument_list; 70, 71; 71, string:'-'; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:field; 75, identifier:lstrip; 76, argument_list; 76, 77; 77, string:'-'; 78, comparison_operator:==; 78, 79; 78, 82; 79, subscript; 79, 80; 79, 81; 80, identifier:field; 81, integer:0; 82, string:'-'; 83, for_in_clause; 83, 84; 83, 85; 84, identifier:field; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_sorting_fields | def prepare_sorting_fields(self):
if self.sorting_parameter_name in self.request.query_params:
self._sorting_fields = [
_.strip() for _ in self.request.query_params.get(self.sorting_parameter_name).split(',')
]
if self._sorting_fields:
self._sorting_fields = [
(self.sorting_fields_map.get(field.lstrip('-'), field.lstrip('-')), field[0] == '-')
for field in self._sorting_fields
] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:JSONList; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:args; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 13; 8, 31; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:type_; 12, identifier:JSON; 13, try_statement; 13, 14; 13, 27; 14, block; 14, 15; 15, if_statement; 15, 16; 15, 22; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:pop; 20, argument_list; 20, 21; 21, string:"unique_sorted"; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:type_; 26, identifier:JSONUniqueListType; 27, except_clause; 27, 28; 27, 29; 28, identifier:KeyError; 29, block; 29, 30; 30, pass_statement; 31, return_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:MutationList; 35, identifier:as_mutable; 36, argument_list; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:type_; 39, argument_list; 39, 40; 39, 42; 40, list_splat; 40, 41; 41, identifier:args; 42, dictionary_splat; 42, 43; 43, identifier:kwargs | def JSONList(*args, **kwargs):
type_ = JSON
try:
if kwargs.pop("unique_sorted"):
type_ = JSONUniqueListType
except KeyError:
pass
return MutationList.as_mutable(type_(*args, **kwargs)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:setup_coords; 3, parameters; 3, 4; 3, 7; 3, 10; 3, 13; 4, default_parameter; 4, 5; 4, 6; 5, identifier:arr_names; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:sort; 9, list:[]; 10, default_parameter; 10, 11; 10, 12; 11, identifier:dims; 12, dictionary; 13, dictionary_splat_pattern; 13, 14; 14, identifier:kwargs; 15, block; 15, 16; 15, 29; 15, 54; 15, 61; 15, 80; 15, 86; 15, 172; 15, 195; 16, try_statement; 16, 17; 16, 23; 17, block; 17, 18; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:OrderedDict; 21, argument_list; 21, 22; 22, identifier:arr_names; 23, except_clause; 23, 24; 23, 27; 24, tuple; 24, 25; 24, 26; 25, identifier:ValueError; 26, identifier:TypeError; 27, block; 27, 28; 28, pass_statement; 29, if_statement; 29, 30; 29, 33; 29, 41; 30, comparison_operator:is; 30, 31; 30, 32; 31, identifier:arr_names; 32, None; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:arr_names; 37, call; 37, 38; 37, 39; 38, identifier:repeat; 39, argument_list; 39, 40; 40, string:'arr{0}'; 41, elif_clause; 41, 42; 41, 46; 42, call; 42, 43; 42, 44; 43, identifier:isstring; 44, argument_list; 44, 45; 45, identifier:arr_names; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:arr_names; 50, call; 50, 51; 50, 52; 51, identifier:repeat; 52, argument_list; 52, 53; 53, identifier:arr_names; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:dims; 57, call; 57, 58; 57, 59; 58, identifier:OrderedDict; 59, argument_list; 59, 60; 60, identifier:dims; 61, for_statement; 61, 62; 61, 65; 61, 71; 62, pattern_list; 62, 63; 62, 64; 63, identifier:key; 64, identifier:val; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:six; 68, identifier:iteritems; 69, argument_list; 69, 70; 70, identifier:kwargs; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:dims; 76, identifier:setdefault; 77, argument_list; 77, 78; 77, 79; 78, identifier:key; 79, identifier:val; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:sorted_dims; 83, call; 83, 84; 83, 85; 84, identifier:OrderedDict; 85, argument_list; 86, if_statement; 86, 87; 86, 88; 86, 121; 87, identifier:sort; 88, block; 88, 89; 88, 104; 89, for_statement; 89, 90; 89, 91; 89, 92; 90, identifier:key; 91, identifier:sort; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 98; 95, subscript; 95, 96; 95, 97; 96, identifier:sorted_dims; 97, identifier:key; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:dims; 101, identifier:pop; 102, argument_list; 102, 103; 103, identifier:key; 104, for_statement; 104, 105; 104, 108; 104, 114; 105, pattern_list; 105, 106; 105, 107; 106, identifier:key; 107, identifier:val; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:six; 111, identifier:iteritems; 112, argument_list; 112, 113; 113, identifier:dims; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:sorted_dims; 119, identifier:key; 120, identifier:val; 121, else_clause; 121, 122; 122, block; 122, 123; 122, 134; 122, 153; 123, if_statement; 123, 124; 123, 127; 124, comparison_operator:in; 124, 125; 124, 126; 125, string:'name'; 126, identifier:dims; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:sorted_dims; 132, string:'name'; 133, None; 134, for_statement; 134, 135; 134, 138; 134, 146; 135, pattern_list; 135, 136; 135, 137; 136, identifier:key; 137, identifier:val; 138, call; 138, 139; 138, 140; 139, identifier:sorted; 140, argument_list; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:dims; 144, identifier:items; 145, argument_list; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:sorted_dims; 151, identifier:key; 152, identifier:val; 153, for_statement; 153, 154; 153, 157; 153, 163; 154, pattern_list; 154, 155; 154, 156; 155, identifier:key; 156, identifier:val; 157, call; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:six; 160, identifier:iteritems; 161, argument_list; 161, 162; 162, identifier:kwargs; 163, block; 163, 164; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:sorted_dims; 168, identifier:setdefault; 169, argument_list; 169, 170; 169, 171; 170, identifier:key; 171, identifier:val; 172, for_statement; 172, 173; 172, 176; 172, 182; 173, pattern_list; 173, 174; 173, 175; 174, identifier:key; 175, identifier:val; 176, call; 176, 177; 176, 180; 177, attribute; 177, 178; 177, 179; 178, identifier:six; 179, identifier:iteritems; 180, argument_list; 180, 181; 181, identifier:sorted_dims; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:sorted_dims; 187, identifier:key; 188, call; 188, 189; 188, 190; 189, identifier:iter; 190, argument_list; 190, 191; 191, call; 191, 192; 191, 193; 192, identifier:safe_list; 193, argument_list; 193, 194; 194, identifier:val; 195, return_statement; 195, 196; 196, call; 196, 197; 196, 198; 197, identifier:OrderedDict; 198, argument_list; 198, 199; 199, list_comprehension; 199, 200; 199, 219; 200, tuple; 200, 201; 200, 207; 201, call; 201, 202; 201, 205; 202, attribute; 202, 203; 202, 204; 203, identifier:arr_name; 204, identifier:format; 205, argument_list; 205, 206; 206, identifier:i; 207, call; 207, 208; 207, 209; 208, identifier:dict; 209, argument_list; 209, 210; 210, call; 210, 211; 210, 212; 211, identifier:zip; 212, argument_list; 212, 213; 212, 218; 213, call; 213, 214; 213, 217; 214, attribute; 214, 215; 214, 216; 215, identifier:sorted_dims; 216, identifier:keys; 217, argument_list; 218, identifier:dim_tuple; 219, for_in_clause; 219, 220; 219, 225; 220, pattern_list; 220, 221; 220, 222; 221, identifier:i; 222, tuple_pattern; 222, 223; 222, 224; 223, identifier:arr_name; 224, identifier:dim_tuple; 225, call; 225, 226; 225, 227; 226, identifier:enumerate; 227, argument_list; 227, 228; 228, call; 228, 229; 228, 230; 229, identifier:zip; 230, argument_list; 230, 231; 230, 232; 231, identifier:arr_names; 232, call; 232, 233; 232, 234; 233, identifier:product; 234, argument_list; 234, 235; 235, list_splat; 235, 236; 236, call; 236, 237; 236, 238; 237, identifier:map; 238, argument_list; 238, 239; 238, 240; 239, identifier:list; 240, call; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:sorted_dims; 243, identifier:values; 244, argument_list | def setup_coords(arr_names=None, sort=[], dims={}, **kwargs):
try:
return OrderedDict(arr_names)
except (ValueError, TypeError):
pass
if arr_names is None:
arr_names = repeat('arr{0}')
elif isstring(arr_names):
arr_names = repeat(arr_names)
dims = OrderedDict(dims)
for key, val in six.iteritems(kwargs):
dims.setdefault(key, val)
sorted_dims = OrderedDict()
if sort:
for key in sort:
sorted_dims[key] = dims.pop(key)
for key, val in six.iteritems(dims):
sorted_dims[key] = val
else:
if 'name' in dims:
sorted_dims['name'] = None
for key, val in sorted(dims.items()):
sorted_dims[key] = val
for key, val in six.iteritems(kwargs):
sorted_dims.setdefault(key, val)
for key, val in six.iteritems(sorted_dims):
sorted_dims[key] = iter(safe_list(val))
return OrderedDict([
(arr_name.format(i), dict(zip(sorted_dims.keys(), dim_tuple)))
for i, (arr_name, dim_tuple) in enumerate(zip(
arr_names, product(
*map(list, sorted_dims.values()))))]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_tdata; 3, parameters; 3, 4; 3, 5; 4, identifier:t_format; 5, identifier:files; 6, block; 6, 7; 6, 33; 6, 36; 6, 41; 6, 45; 6, 65; 6, 74; 6, 87; 6, 138; 6, 147; 6, 158; 6, 169; 7, function_definition; 7, 8; 7, 9; 7, 11; 8, function_name:median; 9, parameters; 9, 10; 10, identifier:arr; 11, block; 11, 12; 12, return_statement; 12, 13; 13, binary_operator:+; 13, 14; 13, 19; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:arr; 17, identifier:min; 18, argument_list; 19, binary_operator:/; 19, 20; 19, 32; 20, parenthesized_expression; 20, 21; 21, binary_operator:-; 21, 22; 21, 27; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:arr; 25, identifier:max; 26, argument_list; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:arr; 30, identifier:min; 31, argument_list; 32, integer:2; 33, import_statement; 33, 34; 34, dotted_name; 34, 35; 35, identifier:re; 36, import_from_statement; 36, 37; 36, 39; 37, dotted_name; 37, 38; 38, identifier:pandas; 39, dotted_name; 39, 40; 40, identifier:Index; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:t_pattern; 44, identifier:t_format; 45, for_statement; 45, 46; 45, 49; 45, 54; 46, pattern_list; 46, 47; 46, 48; 47, identifier:fmt; 48, identifier:patt; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:t_patterns; 52, identifier:items; 53, argument_list; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:t_pattern; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:t_pattern; 61, identifier:replace; 62, argument_list; 62, 63; 62, 64; 63, identifier:fmt; 64, identifier:patt; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:t_pattern; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:re; 71, identifier:compile; 72, argument_list; 72, 73; 73, identifier:t_pattern; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:time; 77, call; 77, 78; 77, 79; 78, identifier:list; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:range; 82, argument_list; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:len; 85, argument_list; 85, 86; 86, identifier:files; 87, for_statement; 87, 88; 87, 91; 87, 95; 88, pattern_list; 88, 89; 88, 90; 89, identifier:i; 90, identifier:f; 91, call; 91, 92; 91, 93; 92, identifier:enumerate; 93, argument_list; 93, 94; 94, identifier:files; 95, block; 95, 96; 96, expression_statement; 96, 97; 97, assignment; 97, 98; 97, 101; 98, subscript; 98, 99; 98, 100; 99, identifier:time; 100, identifier:i; 101, call; 101, 102; 101, 103; 102, identifier:median; 103, argument_list; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:np; 107, identifier:array; 108, argument_list; 108, 109; 109, call; 109, 110; 109, 111; 110, identifier:list; 111, argument_list; 111, 112; 112, call; 112, 113; 112, 114; 113, identifier:map; 114, argument_list; 114, 115; 114, 132; 115, lambda; 115, 116; 115, 118; 116, lambda_parameters; 116, 117; 117, identifier:s; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:np; 121, identifier:datetime64; 122, argument_list; 122, 123; 123, call; 123, 124; 123, 129; 124, attribute; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:dt; 127, identifier:datetime; 128, identifier:strptime; 129, argument_list; 129, 130; 129, 131; 130, identifier:s; 131, identifier:t_format; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:t_pattern; 135, identifier:findall; 136, argument_list; 136, 137; 137, identifier:f; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:ind; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:np; 144, identifier:argsort; 145, argument_list; 145, 146; 146, identifier:time; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:files; 150, subscript; 150, 151; 150, 157; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:np; 154, identifier:array; 155, argument_list; 155, 156; 156, identifier:files; 157, identifier:ind; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:time; 161, subscript; 161, 162; 161, 168; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:np; 165, identifier:array; 166, argument_list; 166, 167; 167, identifier:time; 168, identifier:ind; 169, return_statement; 169, 170; 170, expression_list; 170, 171; 170, 181; 171, call; 171, 172; 171, 173; 172, identifier:to_datetime; 173, argument_list; 173, 174; 174, call; 174, 175; 174, 176; 175, identifier:Index; 176, argument_list; 176, 177; 176, 178; 177, identifier:time; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:name; 180, string:'time'; 181, identifier:files | def get_tdata(t_format, files):
def median(arr):
return arr.min() + (arr.max() - arr.min())/2
import re
from pandas import Index
t_pattern = t_format
for fmt, patt in t_patterns.items():
t_pattern = t_pattern.replace(fmt, patt)
t_pattern = re.compile(t_pattern)
time = list(range(len(files)))
for i, f in enumerate(files):
time[i] = median(np.array(list(map(
lambda s: np.datetime64(dt.datetime.strptime(s, t_format)),
t_pattern.findall(f)))))
ind = np.argsort(time)
files = np.array(files)[ind]
time = np.array(time)[ind]
return to_datetime(Index(time, name='time')), files |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_set_and_filter; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 16; 5, 38; 5, 217; 5, 227; 5, 239; 5, 245; 5, 253; 5, 261; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:fmtos; 9, list:[]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:seen; 13, call; 13, 14; 13, 15; 14, identifier:set; 15, argument_list; 16, for_statement; 16, 17; 16, 18; 16, 21; 17, identifier:key; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_force; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_registered_updates; 28, identifier:setdefault; 29, argument_list; 29, 30; 29, 31; 30, identifier:key; 31, attribute; 31, 32; 31, 37; 32, call; 32, 33; 32, 34; 33, identifier:getattr; 34, argument_list; 34, 35; 34, 36; 35, identifier:self; 36, identifier:key; 37, identifier:value; 38, for_statement; 38, 39; 38, 42; 38, 76; 39, pattern_list; 39, 40; 39, 41; 40, identifier:key; 41, identifier:value; 42, call; 42, 43; 42, 44; 43, identifier:chain; 44, argument_list; 44, 45; 44, 53; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:six; 48, identifier:iteritems; 49, argument_list; 49, 50; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:_registered_updates; 53, conditional_expression:if; 53, 54; 53, 72; 53, 75; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:six; 57, identifier:iteritems; 58, argument_list; 58, 59; 59, dictionary_comprehension; 59, 60; 59, 69; 60, pair; 60, 61; 60, 62; 61, identifier:key; 62, attribute; 62, 63; 62, 68; 63, call; 63, 64; 63, 65; 64, identifier:getattr; 65, argument_list; 65, 66; 65, 67; 66, identifier:self; 67, identifier:key; 68, identifier:default; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:key; 71, identifier:self; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_todefault; 75, tuple; 76, block; 76, 77; 76, 83; 76, 90; 76, 98; 76, 197; 76, 207; 77, if_statement; 77, 78; 77, 81; 78, comparison_operator:in; 78, 79; 78, 80; 79, identifier:key; 80, identifier:seen; 81, block; 81, 82; 82, continue_statement; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:seen; 87, identifier:add; 88, argument_list; 88, 89; 89, identifier:key; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:fmto; 93, call; 93, 94; 93, 95; 94, identifier:getattr; 95, argument_list; 95, 96; 95, 97; 96, identifier:self; 97, identifier:key; 98, if_statement; 98, 99; 98, 110; 98, 145; 99, boolean_operator:and; 99, 100; 99, 105; 100, comparison_operator:in; 100, 101; 100, 102; 101, identifier:key; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:_shared; 105, comparison_operator:not; 105, 106; 105, 107; 106, identifier:key; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:_force; 110, block; 110, 111; 110, 141; 111, if_statement; 111, 112; 111, 122; 112, not_operator; 112, 113; 113, attribute; 113, 114; 113, 121; 114, attribute; 114, 115; 114, 120; 115, subscript; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:self; 118, identifier:_shared; 119, identifier:key; 120, identifier:plotter; 121, identifier:_updating; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:warn; 126, argument_list; 126, 127; 126, 136; 127, binary_operator:%; 127, 128; 127, 132; 128, parenthesized_expression; 128, 129; 129, concatenated_string; 129, 130; 129, 131; 130, string:"%s formatoption is shared with another plotter."; 131, string:" Use the unshare method to enable the updating"; 132, parenthesized_expression; 132, 133; 133, attribute; 133, 134; 133, 135; 134, identifier:fmto; 135, identifier:key; 136, keyword_argument; 136, 137; 136, 138; 137, identifier:logger; 138, attribute; 138, 139; 138, 140; 139, identifier:self; 140, identifier:logger; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:changed; 144, False; 145, else_clause; 145, 146; 146, block; 146, 147; 147, try_statement; 147, 148; 147, 169; 148, block; 148, 149; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:changed; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:fmto; 155, identifier:check_and_set; 156, argument_list; 156, 157; 156, 158; 156, 163; 157, identifier:value; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:todefault; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:_todefault; 163, keyword_argument; 163, 164; 163, 165; 164, identifier:validate; 165, not_operator; 165, 166; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:no_validation; 169, except_clause; 169, 170; 169, 174; 170, as_pattern; 170, 171; 170, 172; 171, identifier:Exception; 172, as_pattern_target; 172, 173; 173, identifier:e; 174, block; 174, 175; 174, 185; 174, 195; 175, expression_statement; 175, 176; 176, call; 176, 177; 176, 182; 177, attribute; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:self; 180, identifier:_registered_updates; 181, identifier:pop; 182, argument_list; 182, 183; 182, 184; 183, identifier:key; 184, None; 185, expression_statement; 185, 186; 186, call; 186, 187; 186, 192; 187, attribute; 187, 188; 187, 191; 188, attribute; 188, 189; 188, 190; 189, identifier:self; 190, identifier:logger; 191, identifier:debug; 192, argument_list; 192, 193; 192, 194; 193, string:'Failed to set %s'; 194, identifier:key; 195, raise_statement; 195, 196; 196, identifier:e; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 200; 199, identifier:changed; 200, boolean_operator:or; 200, 201; 200, 202; 201, identifier:changed; 202, comparison_operator:in; 202, 203; 202, 204; 203, identifier:key; 204, attribute; 204, 205; 204, 206; 205, identifier:self; 206, identifier:_force; 207, if_statement; 207, 208; 207, 209; 208, identifier:changed; 209, block; 209, 210; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:fmtos; 214, identifier:append; 215, argument_list; 215, 216; 216, identifier:fmto; 217, expression_statement; 217, 218; 218, assignment; 218, 219; 218, 220; 219, identifier:fmtos; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:_insert_additionals; 224, argument_list; 224, 225; 224, 226; 225, identifier:fmtos; 226, identifier:seen; 227, for_statement; 227, 228; 227, 229; 227, 230; 228, identifier:fmto; 229, identifier:fmtos; 230, block; 230, 231; 231, expression_statement; 231, 232; 232, call; 232, 233; 232, 238; 233, attribute; 233, 234; 233, 237; 234, attribute; 234, 235; 234, 236; 235, identifier:fmto; 236, identifier:lock; 237, identifier:acquire; 238, argument_list; 239, expression_statement; 239, 240; 240, assignment; 240, 241; 240, 244; 241, attribute; 241, 242; 241, 243; 242, identifier:self; 243, identifier:_todefault; 244, False; 245, expression_statement; 245, 246; 246, call; 246, 247; 246, 252; 247, attribute; 247, 248; 247, 251; 248, attribute; 248, 249; 248, 250; 249, identifier:self; 250, identifier:_registered_updates; 251, identifier:clear; 252, argument_list; 253, expression_statement; 253, 254; 254, call; 254, 255; 254, 260; 255, attribute; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:self; 258, identifier:_force; 259, identifier:clear; 260, argument_list; 261, return_statement; 261, 262; 262, identifier:fmtos | def _set_and_filter(self):
fmtos = []
seen = set()
for key in self._force:
self._registered_updates.setdefault(key, getattr(self, key).value)
for key, value in chain(
six.iteritems(self._registered_updates),
six.iteritems(
{key: getattr(self, key).default for key in self})
if self._todefault else ()):
if key in seen:
continue
seen.add(key)
fmto = getattr(self, key)
if key in self._shared and key not in self._force:
if not self._shared[key].plotter._updating:
warn(("%s formatoption is shared with another plotter."
" Use the unshare method to enable the updating") % (
fmto.key),
logger=self.logger)
changed = False
else:
try:
changed = fmto.check_and_set(
value, todefault=self._todefault,
validate=not self.no_validation)
except Exception as e:
self._registered_updates.pop(key, None)
self.logger.debug('Failed to set %s', key)
raise e
changed = changed or key in self._force
if changed:
fmtos.append(fmto)
fmtos = self._insert_additionals(fmtos, seen)
for fmto in fmtos:
fmto.lock.acquire()
self._todefault = False
self._registered_updates.clear()
self._force.clear()
return fmtos |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_sorted_by_priority; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:fmtos; 6, default_parameter; 6, 7; 6, 8; 7, identifier:changed; 8, None; 9, block; 9, 10; 9, 35; 9, 112; 9, 129; 9, 139; 9, 150; 9, 160; 10, function_definition; 10, 11; 10, 12; 10, 14; 11, function_name:pop_fmto; 12, parameters; 12, 13; 13, identifier:key; 14, block; 14, 15; 14, 24; 14, 28; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:idx; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:fmtos_keys; 21, identifier:index; 22, argument_list; 22, 23; 23, identifier:key; 24, delete_statement; 24, 25; 25, subscript; 25, 26; 25, 27; 26, identifier:fmtos_keys; 27, identifier:idx; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:fmtos; 32, identifier:pop; 33, argument_list; 33, 34; 34, identifier:idx; 35, function_definition; 35, 36; 35, 37; 35, 40; 36, function_name:get_children; 37, parameters; 37, 38; 37, 39; 38, identifier:fmto; 39, identifier:parents_keys; 40, block; 40, 41; 40, 47; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:all_fmtos; 44, binary_operator:+; 44, 45; 44, 46; 45, identifier:fmtos_keys; 46, identifier:parents_keys; 47, for_statement; 47, 48; 47, 49; 47, 56; 48, identifier:key; 49, binary_operator:+; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:fmto; 52, identifier:children; 53, attribute; 53, 54; 53, 55; 54, identifier:fmto; 55, identifier:dependencies; 56, block; 56, 57; 56, 63; 56, 70; 56, 86; 56, 109; 57, if_statement; 57, 58; 57, 61; 58, comparison_operator:not; 58, 59; 58, 60; 59, identifier:key; 60, identifier:fmtos_keys; 61, block; 61, 62; 62, continue_statement; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:child_fmto; 66, call; 66, 67; 66, 68; 67, identifier:pop_fmto; 68, argument_list; 68, 69; 69, identifier:key; 70, for_statement; 70, 71; 70, 72; 70, 82; 71, identifier:childs_child; 72, call; 72, 73; 72, 74; 73, identifier:get_children; 74, argument_list; 74, 75; 74, 76; 75, identifier:child_fmto; 76, binary_operator:+; 76, 77; 76, 78; 77, identifier:parents_keys; 78, list:[child_fmto.key]; 78, 79; 79, attribute; 79, 80; 79, 81; 80, identifier:child_fmto; 81, identifier:key; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, yield; 84, 85; 85, identifier:childs_child; 86, if_statement; 86, 87; 86, 107; 87, parenthesized_expression; 87, 88; 88, boolean_operator:or; 88, 89; 88, 100; 89, call; 89, 90; 89, 91; 90, identifier:any; 91, generator_expression; 91, 92; 91, 95; 92, comparison_operator:in; 92, 93; 92, 94; 93, identifier:key; 94, identifier:all_fmtos; 95, for_in_clause; 95, 96; 95, 97; 96, identifier:key; 97, attribute; 97, 98; 97, 99; 98, identifier:child_fmto; 99, identifier:parents; 100, comparison_operator:in; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:fmto; 103, identifier:key; 104, attribute; 104, 105; 104, 106; 105, identifier:child_fmto; 106, identifier:parents; 107, block; 107, 108; 108, continue_statement; 109, expression_statement; 109, 110; 110, yield; 110, 111; 111, identifier:child_fmto; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:fmtos; 116, identifier:sort; 117, argument_list; 117, 118; 117, 126; 118, keyword_argument; 118, 119; 118, 120; 119, identifier:key; 120, lambda; 120, 121; 120, 123; 121, lambda_parameters; 121, 122; 122, identifier:fmto; 123, attribute; 123, 124; 123, 125; 124, identifier:fmto; 125, identifier:priority; 126, keyword_argument; 126, 127; 126, 128; 127, identifier:reverse; 128, True; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:fmtos_keys; 132, list_comprehension; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:fmto; 135, identifier:key; 136, for_in_clause; 136, 137; 136, 138; 137, identifier:fmto; 138, identifier:fmtos; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:self; 143, identifier:_last_update; 144, boolean_operator:or; 144, 145; 144, 146; 145, identifier:changed; 146, subscript; 146, 147; 146, 148; 147, identifier:fmtos_keys; 148, slice; 148, 149; 149, colon; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 157; 152, attribute; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:logger; 156, identifier:debug; 157, argument_list; 157, 158; 157, 159; 158, string:"Update the formatoptions %s"; 159, identifier:fmtos_keys; 160, while_statement; 160, 161; 160, 162; 161, identifier:fmtos; 162, block; 162, 163; 162, 167; 162, 176; 162, 190; 162, 204; 163, delete_statement; 163, 164; 164, subscript; 164, 165; 164, 166; 165, identifier:fmtos_keys; 166, integer:0; 167, expression_statement; 167, 168; 168, assignment; 168, 169; 168, 170; 169, identifier:fmto; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:fmtos; 173, identifier:pop; 174, argument_list; 174, 175; 175, integer:0; 176, for_statement; 176, 177; 176, 178; 176, 186; 177, identifier:child_fmto; 178, call; 178, 179; 178, 180; 179, identifier:get_children; 180, argument_list; 180, 181; 180, 182; 181, identifier:fmto; 182, list:[fmto.key]; 182, 183; 183, attribute; 183, 184; 183, 185; 184, identifier:fmto; 185, identifier:key; 186, block; 186, 187; 187, expression_statement; 187, 188; 188, yield; 188, 189; 189, identifier:child_fmto; 190, if_statement; 190, 191; 190, 202; 191, call; 191, 192; 191, 193; 192, identifier:any; 193, generator_expression; 193, 194; 193, 197; 194, comparison_operator:in; 194, 195; 194, 196; 195, identifier:key; 196, identifier:fmtos_keys; 197, for_in_clause; 197, 198; 197, 199; 198, identifier:key; 199, attribute; 199, 200; 199, 201; 200, identifier:fmto; 201, identifier:parents; 202, block; 202, 203; 203, continue_statement; 204, expression_statement; 204, 205; 205, yield; 205, 206; 206, identifier:fmto | def _sorted_by_priority(self, fmtos, changed=None):
def pop_fmto(key):
idx = fmtos_keys.index(key)
del fmtos_keys[idx]
return fmtos.pop(idx)
def get_children(fmto, parents_keys):
all_fmtos = fmtos_keys + parents_keys
for key in fmto.children + fmto.dependencies:
if key not in fmtos_keys:
continue
child_fmto = pop_fmto(key)
for childs_child in get_children(
child_fmto, parents_keys + [child_fmto.key]):
yield childs_child
if (any(key in all_fmtos for key in child_fmto.parents) or
fmto.key in child_fmto.parents):
continue
yield child_fmto
fmtos.sort(key=lambda fmto: fmto.priority, reverse=True)
fmtos_keys = [fmto.key for fmto in fmtos]
self._last_update = changed or fmtos_keys[:]
self.logger.debug("Update the formatoptions %s", fmtos_keys)
while fmtos:
del fmtos_keys[0]
fmto = fmtos.pop(0)
for child_fmto in get_children(fmto, [fmto.key]):
yield child_fmto
if any(key in fmtos_keys for key in fmto.parents):
continue
yield fmto |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:sort_kwargs; 3, parameters; 3, 4; 3, 5; 4, identifier:kwargs; 5, list_splat_pattern; 5, 6; 6, identifier:param_lists; 7, block; 7, 8; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 11; 10, identifier:chain; 11, argument_list; 11, 12; 11, 37; 12, generator_expression; 12, 13; 12, 30; 13, dictionary_comprehension; 13, 14; 13, 22; 14, pair; 14, 15; 14, 16; 15, identifier:key; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:pop; 20, argument_list; 20, 21; 21, identifier:key; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:key; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:params; 27, identifier:intersection; 28, argument_list; 28, 29; 29, identifier:kwargs; 30, for_in_clause; 30, 31; 30, 32; 31, identifier:params; 32, call; 32, 33; 32, 34; 33, identifier:map; 34, argument_list; 34, 35; 34, 36; 35, identifier:set; 36, identifier:param_lists; 37, list:[kwargs]; 37, 38; 38, identifier:kwargs | def sort_kwargs(kwargs, *param_lists):
return chain(
({key: kwargs.pop(key) for key in params.intersection(kwargs)}
for params in map(set, param_lists)), [kwargs]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:iterkeys; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 18; 5, 24; 5, 83; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:patterns; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:patterns; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:replace; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:replace; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:seen; 21, call; 21, 22; 21, 23; 22, identifier:set; 23, argument_list; 24, for_statement; 24, 25; 24, 26; 24, 34; 25, identifier:key; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:six; 29, identifier:iterkeys; 30, argument_list; 30, 31; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:base; 34, block; 34, 35; 35, for_statement; 35, 36; 35, 37; 35, 38; 36, identifier:pattern; 37, identifier:patterns; 38, block; 38, 39; 38, 48; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:m; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:pattern; 45, identifier:match; 46, argument_list; 46, 47; 47, identifier:key; 48, if_statement; 48, 49; 48, 50; 49, identifier:m; 50, block; 50, 51; 50, 67; 50, 82; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:ret; 54, conditional_expression:if; 54, 55; 54, 61; 54, 62; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:m; 58, identifier:group; 59, argument_list; 59, 60; 60, string:'key'; 61, identifier:replace; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:m; 65, identifier:group; 66, argument_list; 67, if_statement; 67, 68; 67, 71; 68, comparison_operator:not; 68, 69; 68, 70; 69, identifier:ret; 70, identifier:seen; 71, block; 71, 72; 71, 79; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:seen; 76, identifier:add; 77, argument_list; 77, 78; 78, identifier:ret; 79, expression_statement; 79, 80; 80, yield; 80, 81; 81, identifier:ret; 82, break_statement; 83, for_statement; 83, 84; 83, 85; 83, 91; 84, identifier:key; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:DictMethods; 88, identifier:iterkeys; 89, argument_list; 89, 90; 90, identifier:self; 91, block; 91, 92; 92, if_statement; 92, 93; 92, 96; 93, comparison_operator:not; 93, 94; 93, 95; 94, identifier:key; 95, identifier:seen; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, yield; 98, 99; 99, identifier:key | def iterkeys(self):
patterns = self.patterns
replace = self.replace
seen = set()
for key in six.iterkeys(self.base):
for pattern in patterns:
m = pattern.match(key)
if m:
ret = m.group('key') if replace else m.group()
if ret not in seen:
seen.add(ret)
yield ret
break
for key in DictMethods.iterkeys(self):
if key not in seen:
yield key |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:keys; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 18; 5, 24; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:k; 9, call; 9, 10; 9, 11; 10, identifier:list; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:dict; 15, identifier:keys; 16, argument_list; 16, 17; 17, identifier:self; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:k; 22, identifier:sort; 23, argument_list; 24, return_statement; 24, 25; 25, identifier:k | def keys(self):
k = list(dict.keys(self))
k.sort()
return k |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:get_reports_page; 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:is_enclave; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:enclave_ids; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:tag; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:excluded_tags; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:from_time; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:to_time; 22, None; 23, block; 23, 24; 23, 28; 23, 47; 23, 58; 23, 80; 23, 94; 23, 110; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:distribution_type; 27, None; 28, if_statement; 28, 29; 28, 30; 28, 37; 29, identifier:is_enclave; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:distribution_type; 34, attribute; 34, 35; 34, 36; 35, identifier:DistributionType; 36, identifier:ENCLAVE; 37, elif_clause; 37, 38; 37, 40; 38, not_operator; 38, 39; 39, identifier:is_enclave; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:distribution_type; 44, attribute; 44, 45; 44, 46; 45, identifier:DistributionType; 46, identifier:COMMUNITY; 47, if_statement; 47, 48; 47, 51; 48, comparison_operator:is; 48, 49; 48, 50; 49, identifier:enclave_ids; 50, None; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:enclave_ids; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:enclave_ids; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:params; 61, dictionary; 61, 62; 61, 65; 61, 68; 61, 71; 61, 74; 61, 77; 62, pair; 62, 63; 62, 64; 63, string:'from'; 64, identifier:from_time; 65, pair; 65, 66; 65, 67; 66, string:'to'; 67, identifier:to_time; 68, pair; 68, 69; 68, 70; 69, string:'distributionType'; 70, identifier:distribution_type; 71, pair; 71, 72; 71, 73; 72, string:'enclaveIds'; 73, identifier:enclave_ids; 74, pair; 74, 75; 74, 76; 75, string:'tags'; 76, identifier:tag; 77, pair; 77, 78; 77, 79; 78, string:'excludedTags'; 79, identifier:excluded_tags; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:resp; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_client; 88, identifier:get; 89, argument_list; 89, 90; 89, 91; 90, string:"reports"; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:params; 93, identifier:params; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:result; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:Page; 100, identifier:from_dict; 101, argument_list; 101, 102; 101, 107; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:resp; 105, identifier:json; 106, argument_list; 107, keyword_argument; 107, 108; 107, 109; 108, identifier:content_type; 109, identifier:Report; 110, return_statement; 110, 111; 111, identifier:result | def get_reports_page(self, is_enclave=None, enclave_ids=None, tag=None, excluded_tags=None,
from_time=None, to_time=None):
distribution_type = None
if is_enclave:
distribution_type = DistributionType.ENCLAVE
elif not is_enclave:
distribution_type = DistributionType.COMMUNITY
if enclave_ids is None:
enclave_ids = self.enclave_ids
params = {
'from': from_time,
'to': to_time,
'distributionType': distribution_type,
'enclaveIds': enclave_ids,
'tags': tag,
'excludedTags': excluded_tags
}
resp = self._client.get("reports", params=params)
result = Page.from_dict(resp.json(), content_type=Report)
return result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 1, 11; 2, function_name:hashify_targets; 3, parameters; 3, 4; 3, 8; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:targets; 6, type; 6, 7; 7, identifier:list; 8, identifier:build_context; 9, type; 9, 10; 10, identifier:list; 11, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, generator_expression; 15, 16; 15, 26; 16, call; 16, 17; 16, 24; 17, attribute; 17, 18; 17, 23; 18, subscript; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:build_context; 21, identifier:targets; 22, identifier:target_name; 23, identifier:hash; 24, argument_list; 24, 25; 25, identifier:build_context; 26, for_in_clause; 26, 27; 26, 28; 27, identifier:target_name; 28, call; 28, 29; 28, 30; 29, identifier:listify; 30, argument_list; 30, 31; 31, identifier:targets | def hashify_targets(targets: list, build_context) -> list:
return sorted(build_context.targets[target_name].hash(build_context)
for target_name in listify(targets)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:stable_reverse_topological_sort; 3, parameters; 3, 4; 4, identifier:graph; 5, block; 5, 6; 5, 21; 5, 27; 5, 33; 6, if_statement; 6, 7; 6, 13; 7, not_operator; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:graph; 11, identifier:is_directed; 12, argument_list; 13, block; 13, 14; 14, raise_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:networkx; 18, identifier:NetworkXError; 19, argument_list; 19, 20; 20, string:'Topological sort not defined on undirected graphs.'; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:seen; 24, call; 24, 25; 24, 26; 25, identifier:set; 26, argument_list; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:explored; 30, call; 30, 31; 30, 32; 31, identifier:set; 32, argument_list; 33, for_statement; 33, 34; 33, 35; 33, 43; 34, identifier:v; 35, call; 35, 36; 35, 37; 36, identifier:sorted; 37, argument_list; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:graph; 41, identifier:nodes; 42, argument_list; 43, block; 43, 44; 43, 50; 43, 55; 44, if_statement; 44, 45; 44, 48; 45, comparison_operator:in; 45, 46; 45, 47; 46, identifier:v; 47, identifier:explored; 48, block; 48, 49; 49, continue_statement; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:fringe; 53, list:[v]; 53, 54; 54, identifier:v; 55, while_statement; 55, 56; 55, 57; 56, identifier:fringe; 57, block; 57, 58; 57, 65; 57, 77; 57, 84; 57, 88; 57, 121; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:w; 61, subscript; 61, 62; 61, 63; 62, identifier:fringe; 63, unary_operator:-; 63, 64; 64, integer:1; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:in; 66, 67; 66, 68; 67, identifier:w; 68, identifier:explored; 69, block; 69, 70; 69, 76; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:fringe; 74, identifier:pop; 75, argument_list; 76, continue_statement; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:seen; 81, identifier:add; 82, argument_list; 82, 83; 83, identifier:w; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:new_nodes; 87, list:[]; 88, for_statement; 88, 89; 88, 90; 88, 96; 89, identifier:n; 90, call; 90, 91; 90, 92; 91, identifier:sorted; 92, argument_list; 92, 93; 93, subscript; 93, 94; 93, 95; 94, identifier:graph; 95, identifier:w; 96, block; 96, 97; 97, if_statement; 97, 98; 97, 101; 98, comparison_operator:not; 98, 99; 98, 100; 99, identifier:n; 100, identifier:explored; 101, block; 101, 102; 101, 114; 102, if_statement; 102, 103; 102, 106; 103, comparison_operator:in; 103, 104; 103, 105; 104, identifier:n; 105, identifier:seen; 106, block; 106, 107; 107, raise_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:networkx; 111, identifier:NetworkXUnfeasible; 112, argument_list; 112, 113; 113, string:'Graph contains a cycle.'; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:new_nodes; 118, identifier:append; 119, argument_list; 119, 120; 120, identifier:n; 121, if_statement; 121, 122; 121, 123; 121, 131; 122, identifier:new_nodes; 123, block; 123, 124; 124, expression_statement; 124, 125; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:fringe; 128, identifier:extend; 129, argument_list; 129, 130; 130, identifier:new_nodes; 131, else_clause; 131, 132; 132, block; 132, 133; 132, 140; 132, 143; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:explored; 137, identifier:add; 138, argument_list; 138, 139; 139, identifier:w; 140, expression_statement; 140, 141; 141, yield; 141, 142; 142, identifier:w; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:fringe; 147, identifier:pop; 148, argument_list | def stable_reverse_topological_sort(graph):
if not graph.is_directed():
raise networkx.NetworkXError(
'Topological sort not defined on undirected graphs.')
seen = set()
explored = set()
for v in sorted(graph.nodes()):
if v in explored:
continue
fringe = [v]
while fringe:
w = fringe[-1]
if w in explored:
fringe.pop()
continue
seen.add(w)
new_nodes = []
for n in sorted(graph[w]):
if n not in explored:
if n in seen:
raise networkx.NetworkXUnfeasible(
'Graph contains a cycle.')
new_nodes.append(n)
if new_nodes:
fringe.extend(new_nodes)
else:
explored.add(w)
yield w
fringe.pop() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:walk_target_deps_topological_order; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, typed_parameter; 5, 6; 5, 7; 6, identifier:target; 7, type; 7, 8; 8, identifier:Target; 9, block; 9, 10; 9, 22; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:all_deps; 13, call; 13, 14; 13, 15; 14, identifier:get_descendants; 15, argument_list; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:target_graph; 19, attribute; 19, 20; 19, 21; 20, identifier:target; 21, identifier:name; 22, for_statement; 22, 23; 22, 24; 22, 30; 23, identifier:dep_name; 24, call; 24, 25; 24, 26; 25, identifier:topological_sort; 26, argument_list; 26, 27; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:target_graph; 30, block; 30, 31; 31, if_statement; 31, 32; 31, 35; 32, comparison_operator:in; 32, 33; 32, 34; 33, identifier:dep_name; 34, identifier:all_deps; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, yield; 37, 38; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:targets; 42, identifier:dep_name | def walk_target_deps_topological_order(self, target: Target):
all_deps = get_descendants(self.target_graph, target.name)
for dep_name in topological_sort(self.target_graph):
if dep_name in all_deps:
yield self.targets[dep_name] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:_print_message; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:prefix; 6, identifier:message; 7, default_parameter; 7, 8; 7, 9; 8, identifier:verbose; 9, True; 10, block; 10, 11; 10, 13; 10, 22; 10, 273; 11, expression_statement; 11, 12; 12, string:'Prints a message and takes care of all sorts of nasty code'; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:output; 16, list:['\n', prefix, message['message']]; 16, 17; 16, 18; 16, 19; 17, string:'\n'; 18, identifier:prefix; 19, subscript; 19, 20; 19, 21; 20, identifier:message; 21, string:'message'; 22, if_statement; 22, 23; 22, 24; 23, identifier:verbose; 24, block; 24, 25; 24, 29; 24, 48; 24, 68; 24, 97; 24, 108; 24, 114; 24, 175; 24, 191; 24, 213; 24, 254; 24, 261; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:verbose_output; 28, list:[]; 29, if_statement; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:message; 32, string:'description'; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:verbose_output; 38, identifier:append; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_flatten_list; 44, argument_list; 44, 45; 45, subscript; 45, 46; 45, 47; 46, identifier:message; 47, string:'description'; 48, if_statement; 48, 49; 48, 55; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:message; 52, identifier:get; 53, argument_list; 53, 54; 54, string:'signing_severity'; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:verbose_output; 60, identifier:append; 61, argument_list; 61, 62; 62, parenthesized_expression; 62, 63; 63, binary_operator:%; 63, 64; 63, 65; 64, string:'\tAutomated signing severity: %s'; 65, subscript; 65, 66; 65, 67; 66, identifier:message; 67, string:'signing_severity'; 68, if_statement; 68, 69; 68, 75; 69, call; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:message; 72, identifier:get; 73, argument_list; 73, 74; 74, string:'signing_help'; 75, block; 75, 76; 75, 83; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:verbose_output; 80, identifier:append; 81, argument_list; 81, 82; 82, string:'\tSuggestions for passing automated signing:'; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:verbose_output; 87, identifier:append; 88, argument_list; 88, 89; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:self; 92, identifier:_flatten_list; 93, argument_list; 93, 94; 94, subscript; 94, 95; 94, 96; 95, identifier:message; 96, string:'signing_help'; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:verbose_output; 101, identifier:append; 102, argument_list; 102, 103; 103, binary_operator:%; 103, 104; 103, 105; 104, string:'\tTier:\t%d'; 105, subscript; 105, 106; 105, 107; 106, identifier:message; 107, string:'tier'; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:files; 111, subscript; 111, 112; 111, 113; 112, identifier:message; 113, string:'file'; 114, if_statement; 114, 115; 114, 122; 115, boolean_operator:and; 115, 116; 115, 119; 116, comparison_operator:is; 116, 117; 116, 118; 117, identifier:files; 118, None; 119, comparison_operator:!=; 119, 120; 119, 121; 120, identifier:files; 121, string:''; 122, block; 122, 123; 122, 127; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:fmsg; 126, string:'\tFile:\t%s'; 127, if_statement; 127, 128; 127, 134; 127, 164; 128, comparison_operator:is; 128, 129; 128, 133; 129, call; 129, 130; 129, 131; 130, identifier:type; 131, argument_list; 131, 132; 132, identifier:files; 133, identifier:list; 134, block; 134, 135; 134, 150; 135, if_statement; 135, 136; 135, 142; 136, comparison_operator:==; 136, 137; 136, 141; 137, subscript; 137, 138; 137, 139; 138, identifier:files; 139, unary_operator:-; 139, 140; 140, integer:1; 141, string:''; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 149; 145, subscript; 145, 146; 145, 147; 146, identifier:files; 147, unary_operator:-; 147, 148; 148, integer:1; 149, string:'(none)'; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:verbose_output; 154, identifier:append; 155, argument_list; 155, 156; 156, binary_operator:%; 156, 157; 156, 158; 157, identifier:fmsg; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, string:' > '; 161, identifier:join; 162, argument_list; 162, 163; 163, identifier:files; 164, else_clause; 164, 165; 165, block; 165, 166; 166, expression_statement; 166, 167; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:verbose_output; 170, identifier:append; 171, argument_list; 171, 172; 172, binary_operator:%; 172, 173; 172, 174; 173, identifier:fmsg; 174, identifier:files; 175, if_statement; 175, 176; 175, 179; 176, subscript; 176, 177; 176, 178; 177, identifier:message; 178, string:'line'; 179, block; 179, 180; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:verbose_output; 184, identifier:append; 185, argument_list; 185, 186; 186, binary_operator:%; 186, 187; 186, 188; 187, string:'\tLine:\t%s'; 188, subscript; 188, 189; 188, 190; 189, identifier:message; 190, string:'line'; 191, if_statement; 191, 192; 191, 201; 192, boolean_operator:and; 192, 193; 192, 196; 193, subscript; 193, 194; 193, 195; 194, identifier:message; 195, string:'column'; 196, comparison_operator:!=; 196, 197; 196, 200; 197, subscript; 197, 198; 197, 199; 198, identifier:message; 199, string:'column'; 200, integer:0; 201, block; 201, 202; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:verbose_output; 206, identifier:append; 207, argument_list; 207, 208; 208, binary_operator:%; 208, 209; 208, 210; 209, string:'\tColumn:\t%d'; 210, subscript; 210, 211; 210, 212; 211, identifier:message; 212, string:'column'; 213, if_statement; 213, 214; 213, 220; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:message; 217, identifier:get; 218, argument_list; 218, 219; 219, string:'context'; 220, block; 220, 221; 220, 228; 221, expression_statement; 221, 222; 222, call; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:verbose_output; 225, identifier:append; 226, argument_list; 226, 227; 227, string:'\tContext:'; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:verbose_output; 232, identifier:extend; 233, argument_list; 233, 234; 234, list_comprehension; 234, 235; 234, 249; 235, parenthesized_expression; 235, 236; 236, conditional_expression:if; 236, 237; 236, 240; 236, 243; 237, binary_operator:%; 237, 238; 237, 239; 238, string:'\t> %s'; 239, identifier:x; 240, comparison_operator:is; 240, 241; 240, 242; 241, identifier:x; 242, None; 243, binary_operator:+; 243, 244; 243, 245; 244, string:'\t>'; 245, parenthesized_expression; 245, 246; 246, binary_operator:*; 246, 247; 246, 248; 247, string:'-'; 248, integer:20; 249, for_in_clause; 249, 250; 249, 251; 250, identifier:x; 251, subscript; 251, 252; 251, 253; 252, identifier:message; 253, string:'context'; 254, expression_statement; 254, 255; 255, call; 255, 256; 255, 259; 256, attribute; 256, 257; 256, 258; 257, identifier:output; 258, identifier:append; 259, argument_list; 259, 260; 260, string:'\n'; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:output; 265, identifier:append; 266, argument_list; 266, 267; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, string:'\n'; 270, identifier:join; 271, argument_list; 271, 272; 272, identifier:verbose_output; 273, expression_statement; 273, 274; 274, call; 274, 275; 274, 280; 275, attribute; 275, 276; 275, 279; 276, attribute; 276, 277; 276, 278; 277, identifier:self; 278, identifier:handler; 279, identifier:write; 280, argument_list; 280, 281; 281, call; 281, 282; 281, 285; 282, attribute; 282, 283; 282, 284; 283, string:u''; 284, identifier:join; 285, argument_list; 285, 286; 286, call; 286, 287; 286, 288; 287, identifier:map; 288, argument_list; 288, 289; 288, 292; 289, attribute; 289, 290; 289, 291; 290, identifier:unicodehelper; 291, identifier:decode; 292, identifier:output | def _print_message(self, prefix, message, verbose=True):
'Prints a message and takes care of all sorts of nasty code'
output = ['\n', prefix, message['message']]
if verbose:
verbose_output = []
if message['description']:
verbose_output.append(
self._flatten_list(message['description']))
if message.get('signing_severity'):
verbose_output.append(
('\tAutomated signing severity: %s' %
message['signing_severity']))
if message.get('signing_help'):
verbose_output.append(
'\tSuggestions for passing automated signing:')
verbose_output.append(
self._flatten_list(message['signing_help']))
verbose_output.append('\tTier:\t%d' % message['tier'])
files = message['file']
if files is not None and files != '':
fmsg = '\tFile:\t%s'
if type(files) is list:
if files[-1] == '':
files[-1] = '(none)'
verbose_output.append(fmsg % ' > '.join(files))
else:
verbose_output.append(fmsg % files)
if message['line']:
verbose_output.append('\tLine:\t%s' % message['line'])
if message['column'] and message['column'] != 0:
verbose_output.append('\tColumn:\t%d' % message['column'])
if message.get('context'):
verbose_output.append('\tContext:')
verbose_output.extend([('\t> %s' % x
if x is not None
else '\t>' + ('-' * 20))
for x
in message['context']])
output.append('\n')
output.append('\n'.join(verbose_output))
self.handler.write(u''.join(map(unicodehelper.decode, output))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:finish; 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:items; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort_methods; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:succeeded; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:update_listing; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:cache_to_disc; 19, True; 20, default_parameter; 20, 21; 20, 22; 21, identifier:view_mode; 22, None; 23, block; 23, 24; 23, 26; 23, 36; 23, 74; 23, 112; 23, 121; 24, expression_statement; 24, 25; 25, string:'''Adds the provided items to the XBMC interface.
:param items: an iterable of items where each item is either a
dictionary with keys/values suitable for passing to
:meth:`xbmcswift2.ListItem.from_dict` or an instance of
:class:`xbmcswift2.ListItem`.
:param sort_methods: a list of valid XBMC sort_methods. Each item in
the list can either be a sort method or a tuple of
``sort_method, label2_mask``. See
:meth:`add_sort_method` for
more detail concerning valid sort_methods.
Example call with sort_methods::
sort_methods = ['label', 'title', ('date', '%D')]
plugin.finish(items, sort_methods=sort_methods)
:param view_mode: can either be an integer (or parseable integer
string) corresponding to a view_mode or the name of a type of view.
Currrently the only view type supported is 'thumbnail'.
:returns: a list of all ListItems added to the XBMC interface.
'''; 26, if_statement; 26, 27; 26, 28; 27, identifier:items; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:add_items; 34, argument_list; 34, 35; 35, identifier:items; 36, if_statement; 36, 37; 36, 38; 37, identifier:sort_methods; 38, block; 38, 39; 39, for_statement; 39, 40; 39, 41; 39, 42; 40, identifier:sort_method; 41, identifier:sort_methods; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 56; 43, 65; 44, boolean_operator:and; 44, 45; 44, 51; 45, not_operator; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:isinstance; 48, argument_list; 48, 49; 48, 50; 49, identifier:sort_method; 50, identifier:basestring; 51, call; 51, 52; 51, 53; 52, identifier:hasattr; 53, argument_list; 53, 54; 53, 55; 54, identifier:sort_method; 55, string:'__len__'; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:add_sort_method; 62, argument_list; 62, 63; 63, list_splat; 63, 64; 64, identifier:sort_method; 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:self; 71, identifier:add_sort_method; 72, argument_list; 72, 73; 73, identifier:sort_method; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:view_mode; 77, None; 78, block; 78, 79; 78, 100; 79, try_statement; 79, 80; 79, 88; 80, block; 80, 81; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:view_mode_id; 84, call; 84, 85; 84, 86; 85, identifier:int; 86, argument_list; 86, 87; 87, identifier:view_mode; 88, except_clause; 88, 89; 88, 90; 89, identifier:ValueError; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:view_mode_id; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:get_view_mode_id; 98, argument_list; 98, 99; 99, identifier:view_mode; 100, if_statement; 100, 101; 100, 104; 101, comparison_operator:is; 101, 102; 101, 103; 102, identifier:view_mode_id; 103, None; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:set_view_mode; 110, argument_list; 110, 111; 111, identifier:view_mode_id; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:self; 116, identifier:end_of_directory; 117, argument_list; 117, 118; 117, 119; 117, 120; 118, identifier:succeeded; 119, identifier:update_listing; 120, identifier:cache_to_disc; 121, return_statement; 121, 122; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:added_items | def finish(self, items=None, sort_methods=None, succeeded=True,
update_listing=False, cache_to_disc=True, view_mode=None):
'''Adds the provided items to the XBMC interface.
:param items: an iterable of items where each item is either a
dictionary with keys/values suitable for passing to
:meth:`xbmcswift2.ListItem.from_dict` or an instance of
:class:`xbmcswift2.ListItem`.
:param sort_methods: a list of valid XBMC sort_methods. Each item in
the list can either be a sort method or a tuple of
``sort_method, label2_mask``. See
:meth:`add_sort_method` for
more detail concerning valid sort_methods.
Example call with sort_methods::
sort_methods = ['label', 'title', ('date', '%D')]
plugin.finish(items, sort_methods=sort_methods)
:param view_mode: can either be an integer (or parseable integer
string) corresponding to a view_mode or the name of a type of view.
Currrently the only view type supported is 'thumbnail'.
:returns: a list of all ListItems added to the XBMC interface.
'''
if items:
self.add_items(items)
if sort_methods:
for sort_method in sort_methods:
if not isinstance(sort_method, basestring) and hasattr(sort_method, '__len__'):
self.add_sort_method(*sort_method)
else:
self.add_sort_method(sort_method)
if view_mode is not None:
try:
view_mode_id = int(view_mode)
except ValueError:
view_mode_id = self.get_view_mode_id(view_mode)
if view_mode_id is not None:
self.set_view_mode(view_mode_id)
self.end_of_directory(succeeded, update_listing, cache_to_disc)
return self.added_items |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:followingPrefix; 3, parameters; 3, 4; 4, identifier:prefix; 5, block; 5, 6; 5, 14; 5, 23; 5, 41; 5, 49; 5, 64; 5, 74; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:prefixBytes; 9, call; 9, 10; 9, 11; 10, identifier:array; 11, argument_list; 11, 12; 11, 13; 12, string:'B'; 13, identifier:prefix; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:changeIndex; 17, binary_operator:-; 17, 18; 17, 22; 18, call; 18, 19; 18, 20; 19, identifier:len; 20, argument_list; 20, 21; 21, identifier:prefixBytes; 22, integer:1; 23, while_statement; 23, 24; 23, 34; 24, parenthesized_expression; 24, 25; 25, boolean_operator:and; 25, 26; 25, 29; 26, comparison_operator:>=; 26, 27; 26, 28; 27, identifier:changeIndex; 28, integer:0; 29, comparison_operator:==; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:prefixBytes; 32, identifier:changeIndex; 33, integer:0xff; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:changeIndex; 38, binary_operator:-; 38, 39; 38, 40; 39, identifier:changeIndex; 40, integer:1; 41, if_statement; 41, 42; 41, 46; 42, parenthesized_expression; 42, 43; 43, comparison_operator:<; 43, 44; 43, 45; 44, identifier:changeIndex; 45, integer:0; 46, block; 46, 47; 47, return_statement; 47, 48; 48, None; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:newBytes; 52, call; 52, 53; 52, 54; 53, identifier:array; 54, argument_list; 54, 55; 54, 56; 55, string:'B'; 56, subscript; 56, 57; 56, 58; 57, identifier:prefix; 58, slice; 58, 59; 58, 60; 58, 61; 59, integer:0; 60, colon; 61, binary_operator:+; 61, 62; 61, 63; 62, identifier:changeIndex; 63, integer:1; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:newBytes; 68, identifier:changeIndex; 69, binary_operator:+; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:newBytes; 72, identifier:changeIndex; 73, integer:1; 74, return_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:newBytes; 78, identifier:tostring; 79, argument_list | def followingPrefix(prefix):
prefixBytes = array('B', prefix)
changeIndex = len(prefixBytes) - 1
while (changeIndex >= 0 and prefixBytes[changeIndex] == 0xff ):
changeIndex = changeIndex - 1;
if(changeIndex < 0):
return None
newBytes = array('B', prefix[0:changeIndex + 1])
newBytes[changeIndex] = newBytes[changeIndex] + 1
return newBytes.tostring() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_maybe_numeric; 3, parameters; 3, 4; 4, identifier:x; 5, block; 5, 6; 5, 19; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:all_numeric; 9, call; 9, 10; 9, 11; 10, identifier:all; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:map; 14, argument_list; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:str; 17, identifier:isdigit; 18, identifier:x; 19, if_statement; 19, 20; 19, 21; 19, 30; 20, identifier:all_numeric; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:sorted; 25, argument_list; 25, 26; 25, 27; 26, identifier:x; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:key; 29, identifier:int; 30, else_clause; 30, 31; 31, block; 31, 32; 32, return_statement; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:sorted; 35, argument_list; 35, 36; 36, identifier:x | def sorted_maybe_numeric(x):
all_numeric = all(map(str.isdigit, x))
if all_numeric:
return sorted(x, key=int)
else:
return sorted(x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort_by; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:sf; 6, block; 6, 7; 6, 20; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:params; 10, call; 10, 11; 10, 12; 11, identifier:join_params; 12, argument_list; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:parameters; 16, dictionary; 16, 17; 17, pair; 17, 18; 17, 19; 18, string:"sf"; 19, identifier:sf; 20, return_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:__class__; 25, argument_list; 25, 26; 26, dictionary_splat; 26, 27; 27, identifier:params | def sort_by(self, sf):
params = join_params(self.parameters, {"sf": sf})
return self.__class__(**params) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_contributor_sort_value; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:obj; 6, block; 6, 7; 6, 13; 6, 38; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:user; 10, attribute; 10, 11; 10, 12; 11, identifier:obj; 12, identifier:contributor; 13, if_statement; 13, 14; 13, 21; 13, 30; 14, boolean_operator:or; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:user; 17, identifier:first_name; 18, attribute; 18, 19; 18, 20; 19, identifier:user; 20, identifier:last_name; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:contributor; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:user; 28, identifier:get_full_name; 29, argument_list; 30, else_clause; 30, 31; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:contributor; 35, attribute; 35, 36; 35, 37; 36, identifier:user; 37, identifier:username; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 47; 40, attribute; 40, 41; 40, 46; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:contributor; 44, identifier:strip; 45, argument_list; 46, identifier:lower; 47, argument_list | def get_contributor_sort_value(self, obj):
user = obj.contributor
if user.first_name or user.last_name:
contributor = user.get_full_name()
else:
contributor = user.username
return contributor.strip().lower() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_gen_cache_key_for_slice; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:url_dict; 5, identifier:start_int; 6, identifier:total_int; 7, identifier:authn_subj_list; 8, block; 8, 9; 8, 18; 8, 28; 8, 38; 8, 61; 8, 73; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:key_url_dict; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:copy; 15, identifier:deepcopy; 16, argument_list; 16, 17; 17, identifier:url_dict; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, subscript; 21, 22; 21, 23; 22, identifier:key_url_dict; 23, string:'query'; 24, identifier:pop; 25, argument_list; 25, 26; 25, 27; 26, string:'start'; 27, None; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, subscript; 31, 32; 31, 33; 32, identifier:key_url_dict; 33, string:'query'; 34, identifier:pop; 35, argument_list; 35, 36; 35, 37; 36, string:'count'; 37, None; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:key_json; 41, call; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:d1_common; 45, identifier:util; 46, identifier:serialize_to_normalized_compact_json; 47, argument_list; 47, 48; 48, dictionary; 48, 49; 48, 52; 48, 55; 48, 58; 49, pair; 49, 50; 49, 51; 50, string:'url_dict'; 51, identifier:key_url_dict; 52, pair; 52, 53; 52, 54; 53, string:'start'; 54, identifier:start_int; 55, pair; 55, 56; 55, 57; 56, string:'total'; 57, identifier:total_int; 58, pair; 58, 59; 58, 60; 59, string:'subject'; 60, identifier:authn_subj_list; 61, expression_statement; 61, 62; 62, call; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:logging; 65, identifier:debug; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, string:'key_json={}'; 70, identifier:format; 71, argument_list; 71, 72; 72, identifier:key_json; 73, return_statement; 73, 74; 74, call; 74, 75; 74, 88; 75, attribute; 75, 76; 75, 87; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:hashlib; 79, identifier:sha256; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:key_json; 84, identifier:encode; 85, argument_list; 85, 86; 86, string:'utf-8'; 87, identifier:hexdigest; 88, argument_list | def _gen_cache_key_for_slice(url_dict, start_int, total_int, authn_subj_list):
key_url_dict = copy.deepcopy(url_dict)
key_url_dict['query'].pop('start', None)
key_url_dict['query'].pop('count', None)
key_json = d1_common.util.serialize_to_normalized_compact_json(
{
'url_dict': key_url_dict,
'start': start_int,
'total': total_int,
'subject': authn_subj_list,
}
)
logging.debug('key_json={}'.format(key_json))
return hashlib.sha256(key_json.encode('utf-8')).hexdigest() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:normalize; 3, parameters; 3, 4; 4, identifier:rp_pyxb; 5, block; 5, 6; 5, 25; 5, 47; 5, 53; 6, function_definition; 6, 7; 6, 8; 6, 11; 7, function_name:sort; 8, parameters; 8, 9; 8, 10; 9, identifier:r; 10, identifier:a; 11, block; 11, 12; 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:d1_common; 17, identifier:xml; 18, identifier:sort_value_list_pyxb; 19, argument_list; 19, 20; 20, call; 20, 21; 20, 22; 21, identifier:_get_attr_or_list; 22, argument_list; 22, 23; 22, 24; 23, identifier:r; 24, identifier:a; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:rp_pyxb; 29, identifier:preferredMemberNode; 30, binary_operator:-; 30, 31; 30, 39; 31, call; 31, 32; 31, 33; 32, identifier:set; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:_get_attr_or_list; 36, argument_list; 36, 37; 36, 38; 37, identifier:rp_pyxb; 38, string:'pref'; 39, call; 39, 40; 39, 41; 40, identifier:set; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:_get_attr_or_list; 44, argument_list; 44, 45; 44, 46; 45, identifier:rp_pyxb; 46, string:'block'; 47, expression_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:sort; 50, argument_list; 50, 51; 50, 52; 51, identifier:rp_pyxb; 52, string:'block'; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 56; 55, identifier:sort; 56, argument_list; 56, 57; 56, 58; 57, identifier:rp_pyxb; 58, string:'pref' | def normalize(rp_pyxb):
def sort(r, a):
d1_common.xml.sort_value_list_pyxb(_get_attr_or_list(r, a))
rp_pyxb.preferredMemberNode = set(_get_attr_or_list(rp_pyxb, 'pref')) - set(
_get_attr_or_list(rp_pyxb, 'block')
)
sort(rp_pyxb, 'block')
sort(rp_pyxb, 'pref') |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:normalize; 3, parameters; 3, 4; 4, identifier:body_part_tup; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, string:'\n\n'; 10, identifier:join; 11, argument_list; 11, 12; 12, list_comprehension; 12, 13; 12, 32; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, string:'{}\n\n{}'; 16, identifier:format; 17, argument_list; 17, 18; 17, 29; 18, call; 18, 19; 18, 20; 19, identifier:str; 20, argument_list; 20, 21; 20, 26; 21, subscript; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:p; 24, identifier:headers; 25, string:b'Content-Disposition'; 26, attribute; 26, 27; 26, 28; 27, identifier:p; 28, identifier:encoding; 29, attribute; 29, 30; 29, 31; 30, identifier:p; 31, identifier:text; 32, for_in_clause; 32, 33; 32, 34; 33, identifier:p; 34, call; 34, 35; 34, 36; 35, identifier:sorted; 36, argument_list; 36, 37; 36, 38; 37, identifier:body_part_tup; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:key; 40, lambda; 40, 41; 40, 43; 41, lambda_parameters; 41, 42; 42, identifier:p; 43, subscript; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:p; 46, identifier:headers; 47, string:b'Content-Disposition' | def normalize(body_part_tup,):
return '\n\n'.join(
[
'{}\n\n{}'.format(
str(p.headers[b'Content-Disposition'], p.encoding), p.text
)
for p in sorted(
body_part_tup, key=lambda p: p.headers[b'Content-Disposition']
)
]
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:save_json; 3, parameters; 3, 4; 3, 5; 4, identifier:py_obj; 5, identifier:json_path; 6, block; 6, 7; 7, with_statement; 7, 8; 7, 21; 8, with_clause; 8, 9; 9, with_item; 9, 10; 10, as_pattern; 10, 11; 10, 19; 11, call; 11, 12; 11, 13; 12, identifier:open; 13, argument_list; 13, 14; 13, 15; 13, 16; 14, identifier:json_path; 15, string:'w'; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:encoding; 18, string:'utf-8'; 19, as_pattern_target; 19, 20; 20, identifier:f; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:f; 26, identifier:write; 27, argument_list; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:serialize_to_normalized_pretty_json; 30, argument_list; 30, 31; 31, identifier:py_obj | def save_json(py_obj, json_path):
with open(json_path, 'w', encoding='utf-8') as f:
f.write(serialize_to_normalized_pretty_json(py_obj)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.