sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 13; 2, function_name:interev_mag; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 11; 4, identifier:times; 5, identifier:mags; 6, default_parameter; 6, 7; 6, 8; 7, identifier:size; 8, tuple; 8, 9; 8, 10; 9, float:10.5; 10, float:7.5; 11, dictionary_splat_pattern; 11, 12; 12, identifier:kwargs; 13, block; 13, 14; 13, 20; 13, 40; 13, 54; 13, 64; 13, 74; 13, 92; 13, 100; 13, 104; 13, 108; 13, 169; 13, 183; 13, 192; 13, 201; 13, 210; 13, 228; 13, 243; 13, 252; 13, 261; 13, 275; 13, 289; 13, 307; 13, 318; 14, import_statement; 14, 15; 15, aliased_import; 15, 16; 15, 19; 16, dotted_name; 16, 17; 16, 18; 17, identifier:matplotlib; 18, identifier:pyplot; 19, identifier:plt; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:info; 23, list_comprehension; 23, 24; 23, 31; 24, tuple; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:times; 27, identifier:i; 28, subscript; 28, 29; 28, 30; 29, identifier:mags; 30, identifier:i; 31, for_in_clause; 31, 32; 31, 33; 32, identifier:i; 33, call; 33, 34; 33, 35; 34, identifier:range; 35, argument_list; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:len; 38, argument_list; 38, 39; 39, identifier:times; 40, expression_statement; 40, 41; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:info; 44, identifier:sort; 45, argument_list; 45, 46; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:key; 48, lambda; 48, 49; 48, 51; 49, lambda_parameters; 49, 50; 50, identifier:tup; 51, subscript; 51, 52; 51, 53; 52, identifier:tup; 53, integer:0; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:times; 57, list_comprehension; 57, 58; 57, 61; 58, subscript; 58, 59; 58, 60; 59, identifier:x; 60, integer:0; 61, for_in_clause; 61, 62; 61, 63; 62, identifier:x; 63, identifier:info; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:mags; 67, list_comprehension; 67, 68; 67, 71; 68, subscript; 68, 69; 68, 70; 69, identifier:x; 70, integer:1; 71, for_in_clause; 71, 72; 71, 73; 72, identifier:x; 73, identifier:info; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, pattern_list; 76, 77; 76, 78; 77, identifier:fig; 78, identifier:axes; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:plt; 82, identifier:subplots; 83, argument_list; 83, 84; 83, 85; 83, 86; 83, 89; 84, integer:1; 85, integer:2; 86, keyword_argument; 86, 87; 86, 88; 87, identifier:sharey; 88, True; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:figsize; 91, identifier:size; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:axes; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:axes; 98, identifier:ravel; 99, argument_list; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:pre_times; 103, list:[]; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:post_times; 107, list:[]; 108, for_statement; 108, 109; 108, 110; 108, 117; 109, identifier:i; 110, call; 110, 111; 110, 112; 111, identifier:range; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:len; 115, argument_list; 115, 116; 116, identifier:times; 117, block; 117, 118; 117, 141; 118, if_statement; 118, 119; 118, 122; 119, comparison_operator:>; 119, 120; 119, 121; 120, identifier:i; 121, integer:0; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, call; 124, 125; 124, 128; 125, attribute; 125, 126; 125, 127; 126, identifier:pre_times; 127, identifier:append; 128, argument_list; 128, 129; 129, binary_operator:/; 129, 130; 129, 140; 130, parenthesized_expression; 130, 131; 131, binary_operator:-; 131, 132; 131, 135; 132, subscript; 132, 133; 132, 134; 133, identifier:times; 134, identifier:i; 135, subscript; 135, 136; 135, 137; 136, identifier:times; 137, binary_operator:-; 137, 138; 137, 139; 138, identifier:i; 139, integer:1; 140, integer:60; 141, if_statement; 141, 142; 141, 150; 142, comparison_operator:<; 142, 143; 142, 144; 143, identifier:i; 144, binary_operator:-; 144, 145; 144, 149; 145, call; 145, 146; 145, 147; 146, identifier:len; 147, argument_list; 147, 148; 148, identifier:times; 149, integer:1; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:post_times; 155, identifier:append; 156, argument_list; 156, 157; 157, binary_operator:/; 157, 158; 157, 168; 158, parenthesized_expression; 158, 159; 159, binary_operator:-; 159, 160; 159, 165; 160, subscript; 160, 161; 160, 162; 161, identifier:times; 162, binary_operator:+; 162, 163; 162, 164; 163, identifier:i; 164, integer:1; 165, subscript; 165, 166; 165, 167; 166, identifier:times; 167, identifier:i; 168, integer:60; 169, expression_statement; 169, 170; 170, call; 170, 171; 170, 176; 171, attribute; 171, 172; 171, 175; 172, subscript; 172, 173; 172, 174; 173, identifier:axes; 174, integer:0; 175, identifier:scatter; 176, argument_list; 176, 177; 176, 178; 177, identifier:pre_times; 178, subscript; 178, 179; 178, 180; 179, identifier:mags; 180, slice; 180, 181; 180, 182; 181, integer:1; 182, colon; 183, expression_statement; 183, 184; 184, call; 184, 185; 184, 190; 185, attribute; 185, 186; 185, 189; 186, subscript; 186, 187; 186, 188; 187, identifier:axes; 188, integer:0; 189, identifier:set_title; 190, argument_list; 190, 191; 191, string:'Pre-event times'; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 199; 194, attribute; 194, 195; 194, 198; 195, subscript; 195, 196; 195, 197; 196, identifier:axes; 197, integer:0; 198, identifier:set_ylabel; 199, argument_list; 199, 200; 200, string:'Magnitude'; 201, expression_statement; 201, 202; 202, call; 202, 203; 202, 208; 203, attribute; 203, 204; 203, 207; 204, subscript; 204, 205; 204, 206; 205, identifier:axes; 206, integer:0; 207, identifier:set_xlabel; 208, argument_list; 208, 209; 209, string:'Time (Minutes)'; 210, expression_statement; 210, 211; 211, call; 211, 212; 211, 215; 212, attribute; 212, 213; 212, 214; 213, identifier:plt; 214, identifier:setp; 215, argument_list; 215, 216; 215, 225; 216, call; 216, 217; 216, 224; 217, attribute; 217, 218; 217, 223; 218, attribute; 218, 219; 218, 222; 219, subscript; 219, 220; 219, 221; 220, identifier:axes; 221, integer:0; 222, identifier:xaxis; 223, identifier:get_majorticklabels; 224, argument_list; 225, keyword_argument; 225, 226; 225, 227; 226, identifier:rotation; 227, integer:30; 228, expression_statement; 228, 229; 229, call; 229, 230; 229, 235; 230, attribute; 230, 231; 230, 234; 231, subscript; 231, 232; 231, 233; 232, identifier:axes; 233, integer:1; 234, identifier:scatter; 235, argument_list; 235, 236; 235, 237; 236, identifier:pre_times; 237, subscript; 237, 238; 237, 239; 238, identifier:mags; 239, slice; 239, 240; 239, 241; 240, colon; 241, unary_operator:-; 241, 242; 242, integer:1; 243, expression_statement; 243, 244; 244, call; 244, 245; 244, 250; 245, attribute; 245, 246; 245, 249; 246, subscript; 246, 247; 246, 248; 247, identifier:axes; 248, integer:1; 249, identifier:set_title; 250, argument_list; 250, 251; 251, string:'Post-event times'; 252, expression_statement; 252, 253; 253, call; 253, 254; 253, 259; 254, attribute; 254, 255; 254, 258; 255, subscript; 255, 256; 255, 257; 256, identifier:axes; 257, integer:1; 258, identifier:set_xlabel; 259, argument_list; 259, 260; 260, string:'Time (Minutes)'; 261, expression_statement; 261, 262; 262, call; 262, 263; 262, 268; 263, attribute; 263, 264; 263, 267; 264, subscript; 264, 265; 264, 266; 265, identifier:axes; 266, integer:0; 267, identifier:autoscale; 268, argument_list; 268, 269; 268, 272; 269, keyword_argument; 269, 270; 269, 271; 270, identifier:enable; 271, True; 272, keyword_argument; 272, 273; 272, 274; 273, identifier:tight; 274, True; 275, expression_statement; 275, 276; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, subscript; 278, 279; 278, 280; 279, identifier:axes; 280, integer:1; 281, identifier:autoscale; 282, argument_list; 282, 283; 282, 286; 283, keyword_argument; 283, 284; 283, 285; 284, identifier:enable; 285, True; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:tight; 288, True; 289, expression_statement; 289, 290; 290, call; 290, 291; 290, 294; 291, attribute; 291, 292; 291, 293; 292, identifier:plt; 293, identifier:setp; 294, argument_list; 294, 295; 294, 304; 295, call; 295, 296; 295, 303; 296, attribute; 296, 297; 296, 302; 297, attribute; 297, 298; 297, 301; 298, subscript; 298, 299; 298, 300; 299, identifier:axes; 300, integer:1; 301, identifier:xaxis; 302, identifier:get_majorticklabels; 303, argument_list; 304, keyword_argument; 304, 305; 304, 306; 305, identifier:rotation; 306, integer:30; 307, expression_statement; 307, 308; 308, assignment; 308, 309; 308, 310; 309, identifier:fig; 310, call; 310, 311; 310, 312; 311, identifier:_finalise_figure; 312, argument_list; 312, 313; 312, 316; 313, keyword_argument; 313, 314; 313, 315; 314, identifier:fig; 315, identifier:fig; 316, dictionary_splat; 316, 317; 317, identifier:kwargs; 318, return_statement; 318, 319; 319, identifier:fig
|
def interev_mag(times, mags, size=(10.5, 7.5), **kwargs):
import matplotlib.pyplot as plt
info = [(times[i], mags[i]) for i in range(len(times))]
info.sort(key=lambda tup: tup[0])
times = [x[0] for x in info]
mags = [x[1] for x in info]
fig, axes = plt.subplots(1, 2, sharey=True, figsize=size)
axes = axes.ravel()
pre_times = []
post_times = []
for i in range(len(times)):
if i > 0:
pre_times.append((times[i] - times[i - 1]) / 60)
if i < len(times) - 1:
post_times.append((times[i + 1] - times[i]) / 60)
axes[0].scatter(pre_times, mags[1:])
axes[0].set_title('Pre-event times')
axes[0].set_ylabel('Magnitude')
axes[0].set_xlabel('Time (Minutes)')
plt.setp(axes[0].xaxis.get_majorticklabels(), rotation=30)
axes[1].scatter(pre_times, mags[:-1])
axes[1].set_title('Post-event times')
axes[1].set_xlabel('Time (Minutes)')
axes[0].autoscale(enable=True, tight=True)
axes[1].autoscale(enable=True, tight=True)
plt.setp(axes[1].xaxis.get_majorticklabels(), rotation=30)
fig = _finalise_figure(fig=fig, **kwargs)
return fig
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:pprint_blockers; 3, parameters; 3, 4; 4, identifier:blockers; 5, block; 5, 6; 5, 10; 5, 86; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:pprinted; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 28; 11, identifier:blocker; 12, call; 12, 13; 12, 14; 13, identifier:sorted; 14, argument_list; 14, 15; 14, 16; 15, identifier:blockers; 16, keyword_argument; 16, 17; 16, 18; 17, identifier:key; 18, lambda; 18, 19; 18, 21; 19, lambda_parameters; 19, 20; 20, identifier:x; 21, call; 21, 22; 21, 23; 22, identifier:tuple; 23, argument_list; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:reversed; 26, argument_list; 26, 27; 27, identifier:x; 28, block; 28, 29; 28, 36; 28, 74; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:buf; 32, list:[blocker[0]]; 32, 33; 33, subscript; 33, 34; 33, 35; 34, identifier:blocker; 35, integer:0; 36, if_statement; 36, 37; 36, 43; 37, comparison_operator:>; 37, 38; 37, 42; 38, call; 38, 39; 38, 40; 39, identifier:len; 40, argument_list; 40, 41; 41, identifier:blocker; 42, integer:1; 43, block; 43, 44; 43, 51; 43, 67; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:buf; 48, identifier:append; 49, argument_list; 49, 50; 50, string:' (which is blocking '; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:buf; 55, identifier:append; 56, argument_list; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, string:', which is blocking '; 60, identifier:join; 61, argument_list; 61, 62; 62, subscript; 62, 63; 62, 64; 63, identifier:blocker; 64, slice; 64, 65; 64, 66; 65, integer:1; 66, colon; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:buf; 71, identifier:append; 72, argument_list; 72, 73; 73, string:')'; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:pprinted; 78, identifier:append; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, string:''; 83, identifier:join; 84, argument_list; 84, 85; 85, identifier:buf; 86, return_statement; 86, 87; 87, identifier:pprinted
|
def pprint_blockers(blockers):
pprinted = []
for blocker in sorted(blockers, key=lambda x: tuple(reversed(x))):
buf = [blocker[0]]
if len(blocker) > 1:
buf.append(' (which is blocking ')
buf.append(', which is blocking '.join(blocker[1:]))
buf.append(')')
pprinted.append(''.join(buf))
return pprinted
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_document_summary; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:N; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:cite_sort; 10, True; 11, default_parameter; 11, 12; 11, 13; 12, identifier:refresh; 13, True; 14, block; 14, 15; 14, 26; 14, 69; 14, 81; 14, 95; 14, 120; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:abstracts; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:get_abstracts; 22, argument_list; 22, 23; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:refresh; 25, identifier:refresh; 26, if_statement; 26, 27; 26, 28; 27, identifier:cite_sort; 28, block; 28, 29; 28, 44; 28, 59; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:counts; 32, list_comprehension; 32, 33; 32, 41; 33, tuple; 33, 34; 33, 35; 34, identifier:a; 35, call; 35, 36; 35, 37; 36, identifier:int; 37, argument_list; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:a; 40, identifier:citedby_count; 41, for_in_clause; 41, 42; 41, 43; 42, identifier:a; 43, identifier:abstracts; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:counts; 48, identifier:sort; 49, argument_list; 49, 50; 49, 53; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:reverse; 52, True; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:key; 55, call; 55, 56; 55, 57; 56, identifier:itemgetter; 57, argument_list; 57, 58; 58, integer:1; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:abstracts; 62, list_comprehension; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:a; 65, integer:0; 66, for_in_clause; 66, 67; 66, 68; 67, identifier:a; 68, identifier:counts; 69, if_statement; 69, 70; 69, 73; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:N; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:N; 77, call; 77, 78; 77, 79; 78, identifier:len; 79, argument_list; 79, 80; 80, identifier:abstracts; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:s; 84, list:[u'{0} of {1} documents'.format(N, len(abstracts))]; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, string:u'{0} of {1} documents'; 88, identifier:format; 89, argument_list; 89, 90; 89, 91; 90, identifier:N; 91, call; 91, 92; 91, 93; 92, identifier:len; 93, argument_list; 93, 94; 94, identifier:abstracts; 95, for_statement; 95, 96; 95, 97; 95, 101; 96, identifier:i; 97, call; 97, 98; 97, 99; 98, identifier:range; 99, argument_list; 99, 100; 100, identifier:N; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, augmented_assignment:+=; 103, 104; 103, 105; 104, identifier:s; 105, list:['{0:2d}. {1}\n'.format(i + 1, str(abstracts[i]))]; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, string:'{0:2d}. {1}\n'; 109, identifier:format; 110, argument_list; 110, 111; 110, 114; 111, binary_operator:+; 111, 112; 111, 113; 112, identifier:i; 113, integer:1; 114, call; 114, 115; 114, 116; 115, identifier:str; 116, argument_list; 116, 117; 117, subscript; 117, 118; 117, 119; 118, identifier:abstracts; 119, identifier:i; 120, return_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, string:'\n'; 124, identifier:join; 125, argument_list; 125, 126; 126, identifier:s
|
def get_document_summary(self, N=None, cite_sort=True, refresh=True):
abstracts = self.get_abstracts(refresh=refresh)
if cite_sort:
counts = [(a, int(a.citedby_count)) for a in abstracts]
counts.sort(reverse=True, key=itemgetter(1))
abstracts = [a[0] for a in counts]
if N is None:
N = len(abstracts)
s = [u'{0} of {1} documents'.format(N, len(abstracts))]
for i in range(N):
s += ['{0:2d}. {1}\n'.format(i + 1, str(abstracts[i]))]
return '\n'.join(s)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_match_version_string; 3, parameters; 3, 4; 4, identifier:version; 5, block; 5, 6; 5, 15; 5, 23; 5, 39; 5, 74; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:matched; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:_VERSION_STRING_REGEX; 12, identifier:match; 13, argument_list; 13, 14; 14, identifier:version; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:g; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:matched; 21, identifier:groups; 22, argument_list; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 29; 25, pattern_list; 25, 26; 25, 27; 25, 28; 26, identifier:major; 27, identifier:minor; 28, identifier:micro; 29, expression_list; 29, 30; 29, 33; 29, 36; 30, subscript; 30, 31; 30, 32; 31, identifier:g; 32, integer:0; 33, subscript; 33, 34; 33, 35; 34, identifier:g; 35, integer:2; 36, subscript; 36, 37; 36, 38; 37, identifier:g; 38, integer:4; 39, if_statement; 39, 40; 39, 45; 39, 65; 40, boolean_operator:and; 40, 41; 40, 44; 41, boolean_operator:and; 41, 42; 41, 43; 42, identifier:major; 43, identifier:minor; 44, identifier:micro; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 52; 48, pattern_list; 48, 49; 48, 50; 48, 51; 49, identifier:major; 50, identifier:minor; 51, identifier:micro; 52, expression_list; 52, 53; 52, 57; 52, 61; 53, call; 53, 54; 53, 55; 54, identifier:int; 55, argument_list; 55, 56; 56, identifier:major; 57, call; 57, 58; 57, 59; 58, identifier:int; 59, argument_list; 59, 60; 60, identifier:minor; 61, call; 61, 62; 61, 63; 62, identifier:int; 63, argument_list; 63, 64; 64, identifier:micro; 65, else_clause; 65, 66; 66, block; 66, 67; 67, raise_statement; 67, 68; 68, call; 68, 69; 68, 70; 69, identifier:GnuPGVersionError; 70, argument_list; 70, 71; 71, binary_operator:%; 71, 72; 71, 73; 72, string:"Could not parse GnuPG version from: %r"; 73, identifier:version; 74, return_statement; 74, 75; 75, tuple; 75, 76; 75, 77; 75, 78; 76, identifier:major; 77, identifier:minor; 78, identifier:micro
|
def _match_version_string(version):
matched = _VERSION_STRING_REGEX.match(version)
g = matched.groups()
major, minor, micro = g[0], g[2], g[4]
if major and minor and micro:
major, minor, micro = int(major), int(minor), int(micro)
else:
raise GnuPGVersionError("Could not parse GnuPG version from: %r" %
version)
return (major, minor, micro)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:generate_help; 3, parameters; 4, block; 4, 5; 4, 9; 4, 19; 4, 57; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:help_text; 8, string:'\nAvailable recipes:\n\n'; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:recipes; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:config; 16, identifier:Config; 17, identifier:get_registered_recipes; 18, argument_list; 19, for_statement; 19, 20; 19, 24; 19, 38; 20, pattern_list; 20, 21; 20, 22; 20, 23; 21, identifier:contents; 22, identifier:_; 23, identifier:_; 24, call; 24, 25; 24, 26; 25, identifier:sorted; 26, argument_list; 26, 27; 26, 28; 27, identifier:recipes; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:key; 30, lambda; 30, 31; 30, 33; 31, lambda_parameters; 31, 32; 32, identifier:k; 33, subscript; 33, 34; 33, 37; 34, subscript; 34, 35; 34, 36; 35, identifier:k; 36, integer:0; 37, string:'name'; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, augmented_assignment:+=; 40, 41; 40, 42; 41, identifier:help_text; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, string:' {0:<35s}{1:s}\n'; 45, identifier:format; 46, argument_list; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:contents; 49, string:'name'; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:contents; 53, identifier:get; 54, argument_list; 54, 55; 54, 56; 55, string:'short_description'; 56, string:'No description'; 57, return_statement; 57, 58; 58, identifier:help_text
|
def generate_help():
help_text = '\nAvailable recipes:\n\n'
recipes = config.Config.get_registered_recipes()
for contents, _, _ in sorted(recipes, key=lambda k: k[0]['name']):
help_text += ' {0:<35s}{1:s}\n'.format(
contents['name'], contents.get('short_description', 'No description'))
return help_text
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 22; 2, function_name:write_to_csv; 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:filename; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:extension; 10, string:'.dat'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:overwrite; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:stride; 16, integer:1; 17, default_parameter; 17, 18; 17, 19; 18, identifier:chunksize; 19, None; 20, dictionary_splat_pattern; 20, 21; 21, identifier:kw; 22, block; 22, 23; 22, 26; 22, 119; 22, 130; 22, 133; 22, 185; 22, 189; 22, 196; 22, 202; 22, 217; 22, 227; 22, 322; 23, import_statement; 23, 24; 24, dotted_name; 24, 25; 25, identifier:os; 26, if_statement; 26, 27; 26, 29; 26, 68; 26, 112; 27, not_operator; 27, 28; 28, identifier:filename; 29, block; 29, 30; 29, 36; 29, 40; 30, assert_statement; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:hasattr; 33, argument_list; 33, 34; 33, 35; 34, identifier:self; 35, string:'filenames'; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:filenames; 39, list:[]; 40, for_statement; 40, 41; 40, 42; 40, 45; 41, identifier:f; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:filenames; 45, block; 45, 46; 45, 59; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 51; 48, pattern_list; 48, 49; 48, 50; 49, identifier:base; 50, identifier:_; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:os; 55, identifier:path; 56, identifier:splitext; 57, argument_list; 57, 58; 58, identifier:f; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:filenames; 63, identifier:append; 64, argument_list; 64, 65; 65, binary_operator:+; 65, 66; 65, 67; 66, identifier:base; 67, identifier:extension; 68, elif_clause; 68, 69; 68, 74; 69, call; 69, 70; 69, 71; 70, identifier:isinstance; 71, argument_list; 71, 72; 71, 73; 72, identifier:filename; 73, identifier:str; 74, block; 74, 75; 74, 88; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:filename; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:filename; 81, identifier:replace; 82, argument_list; 82, 83; 82, 84; 83, string:'{stride}'; 84, call; 84, 85; 84, 86; 85, identifier:str; 86, argument_list; 86, 87; 87, identifier:stride; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:filenames; 91, list_comprehension; 91, 92; 91, 102; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:filename; 95, identifier:replace; 96, argument_list; 96, 97; 96, 98; 97, string:'{itraj}'; 98, call; 98, 99; 98, 100; 99, identifier:str; 100, argument_list; 100, 101; 101, identifier:itraj; 102, for_in_clause; 102, 103; 102, 104; 103, identifier:itraj; 104, call; 104, 105; 104, 106; 105, identifier:range; 106, argument_list; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:number_of_trajectories; 111, argument_list; 112, else_clause; 112, 113; 113, block; 113, 114; 114, raise_statement; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:TypeError; 117, argument_list; 117, 118; 118, string:"filename should be str or None"; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 126; 121, attribute; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:self; 124, identifier:logger; 125, identifier:debug; 126, argument_list; 126, 127; 127, binary_operator:%; 127, 128; 127, 129; 128, string:"write_to_csv, filenames=%s"; 129, identifier:filenames; 130, import_statement; 130, 131; 131, dotted_name; 131, 132; 132, identifier:errno; 133, for_statement; 133, 134; 133, 135; 133, 136; 134, identifier:f; 135, identifier:filenames; 136, block; 136, 137; 137, try_statement; 137, 138; 137, 155; 138, block; 138, 139; 138, 148; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 142; 141, identifier:st; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:os; 145, identifier:stat; 146, argument_list; 146, 147; 147, identifier:f; 148, raise_statement; 148, 149; 149, call; 149, 150; 149, 151; 150, identifier:OSError; 151, argument_list; 151, 152; 152, attribute; 152, 153; 152, 154; 153, identifier:errno; 154, identifier:EEXIST; 155, except_clause; 155, 156; 155, 160; 156, as_pattern; 156, 157; 156, 158; 157, identifier:OSError; 158, as_pattern_target; 158, 159; 159, identifier:e; 160, block; 160, 161; 160, 184; 161, if_statement; 161, 162; 161, 169; 161, 174; 162, comparison_operator:==; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:e; 165, identifier:errno; 166, attribute; 166, 167; 166, 168; 167, identifier:errno; 168, identifier:EEXIST; 169, block; 169, 170; 170, if_statement; 170, 171; 170, 172; 171, identifier:overwrite; 172, block; 172, 173; 173, continue_statement; 174, elif_clause; 174, 175; 174, 182; 175, comparison_operator:==; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:e; 178, identifier:errno; 179, attribute; 179, 180; 179, 181; 180, identifier:errno; 181, identifier:ENOENT; 182, block; 182, 183; 183, continue_statement; 184, raise_statement; 185, expression_statement; 185, 186; 186, assignment; 186, 187; 186, 188; 187, identifier:f; 188, None; 189, import_from_statement; 189, 190; 189, 194; 190, dotted_name; 190, 191; 190, 192; 190, 193; 191, identifier:pyemma; 192, identifier:_base; 193, identifier:progress; 194, dotted_name; 194, 195; 195, identifier:ProgressReporter; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:pg; 199, call; 199, 200; 199, 201; 200, identifier:ProgressReporter; 201, argument_list; 202, expression_statement; 202, 203; 203, assignment; 203, 204; 203, 205; 204, identifier:it; 205, call; 205, 206; 205, 209; 206, attribute; 206, 207; 206, 208; 207, identifier:self; 208, identifier:iterator; 209, argument_list; 209, 210; 209, 211; 209, 214; 210, identifier:stride; 211, keyword_argument; 211, 212; 211, 213; 212, identifier:chunk; 213, identifier:chunksize; 214, keyword_argument; 214, 215; 214, 216; 215, identifier:return_trajindex; 216, False; 217, expression_statement; 217, 218; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:pg; 221, identifier:register; 222, argument_list; 222, 223; 222, 226; 223, attribute; 223, 224; 223, 225; 224, identifier:it; 225, identifier:n_chunks; 226, string:"saving to csv"; 227, with_statement; 227, 228; 227, 237; 228, with_clause; 228, 229; 228, 231; 229, with_item; 229, 230; 230, identifier:it; 231, with_item; 231, 232; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:pg; 235, identifier:context; 236, argument_list; 237, block; 237, 238; 237, 243; 238, expression_statement; 238, 239; 239, assignment; 239, 240; 239, 241; 240, identifier:oldtraj; 241, unary_operator:-; 241, 242; 242, integer:1; 243, for_statement; 243, 244; 243, 245; 243, 246; 244, identifier:X; 245, identifier:it; 246, block; 246, 247; 246, 298; 246, 308; 246, 314; 247, if_statement; 247, 248; 247, 253; 248, comparison_operator:!=; 248, 249; 248, 250; 249, identifier:oldtraj; 250, attribute; 250, 251; 250, 252; 251, identifier:it; 252, identifier:current_trajindex; 253, block; 253, 254; 253, 265; 253, 273; 253, 284; 253, 292; 254, if_statement; 254, 255; 254, 258; 255, comparison_operator:is; 255, 256; 255, 257; 256, identifier:f; 257, None; 258, block; 258, 259; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:f; 263, identifier:close; 264, argument_list; 265, expression_statement; 265, 266; 266, assignment; 266, 267; 266, 268; 267, identifier:fn; 268, subscript; 268, 269; 268, 270; 269, identifier:filenames; 270, attribute; 270, 271; 270, 272; 271, identifier:it; 272, identifier:current_trajindex; 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:logger; 279, identifier:debug; 280, argument_list; 280, 281; 281, binary_operator:%; 281, 282; 281, 283; 282, string:"opening file %s for writing csv."; 283, identifier:fn; 284, expression_statement; 284, 285; 285, assignment; 285, 286; 285, 287; 286, identifier:f; 287, call; 287, 288; 287, 289; 288, identifier:open; 289, argument_list; 289, 290; 289, 291; 290, identifier:fn; 291, string:'wb'; 292, expression_statement; 292, 293; 293, assignment; 293, 294; 293, 295; 294, identifier:oldtraj; 295, attribute; 295, 296; 295, 297; 296, identifier:it; 297, identifier:current_trajindex; 298, expression_statement; 298, 299; 299, call; 299, 300; 299, 303; 300, attribute; 300, 301; 300, 302; 301, identifier:np; 302, identifier:savetxt; 303, argument_list; 303, 304; 303, 305; 303, 306; 304, identifier:f; 305, identifier:X; 306, dictionary_splat; 306, 307; 307, identifier:kw; 308, expression_statement; 308, 309; 309, call; 309, 310; 309, 313; 310, attribute; 310, 311; 310, 312; 311, identifier:f; 312, identifier:flush; 313, argument_list; 314, expression_statement; 314, 315; 315, call; 315, 316; 315, 319; 316, attribute; 316, 317; 316, 318; 317, identifier:pg; 318, identifier:update; 319, argument_list; 319, 320; 319, 321; 320, integer:1; 321, integer:0; 322, if_statement; 322, 323; 322, 326; 323, comparison_operator:is; 323, 324; 323, 325; 324, identifier:f; 325, None; 326, block; 326, 327; 327, expression_statement; 327, 328; 328, call; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:f; 331, identifier:close; 332, argument_list
|
def write_to_csv(self, filename=None, extension='.dat', overwrite=False,
stride=1, chunksize=None, **kw):
import os
if not filename:
assert hasattr(self, 'filenames')
filenames = []
for f in self.filenames:
base, _ = os.path.splitext(f)
filenames.append(base + extension)
elif isinstance(filename, str):
filename = filename.replace('{stride}', str(stride))
filenames = [filename.replace('{itraj}', str(itraj)) for itraj
in range(self.number_of_trajectories())]
else:
raise TypeError("filename should be str or None")
self.logger.debug("write_to_csv, filenames=%s" % filenames)
import errno
for f in filenames:
try:
st = os.stat(f)
raise OSError(errno.EEXIST)
except OSError as e:
if e.errno == errno.EEXIST:
if overwrite:
continue
elif e.errno == errno.ENOENT:
continue
raise
f = None
from pyemma._base.progress import ProgressReporter
pg = ProgressReporter()
it = self.iterator(stride, chunk=chunksize, return_trajindex=False)
pg.register(it.n_chunks, "saving to csv")
with it, pg.context():
oldtraj = -1
for X in it:
if oldtraj != it.current_trajindex:
if f is not None:
f.close()
fn = filenames[it.current_trajindex]
self.logger.debug("opening file %s for writing csv." % fn)
f = open(fn, 'wb')
oldtraj = it.current_trajindex
np.savetxt(f, X, **kw)
f.flush()
pg.update(1, 0)
if f is not None:
f.close()
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add_distances; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:indices; 6, default_parameter; 6, 7; 6, 8; 7, identifier:periodic; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:indices2; 11, None; 12, block; 12, 13; 12, 15; 12, 22; 12, 36; 12, 45; 12, 58; 13, expression_statement; 13, 14; 14, identifier:r; 15, import_from_statement; 15, 16; 15, 20; 16, relative_import; 16, 17; 16, 18; 17, import_prefix; 18, dotted_name; 18, 19; 19, identifier:distances; 20, dotted_name; 20, 21; 21, identifier:DistanceFeature; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:atom_pairs; 25, call; 25, 26; 25, 27; 26, identifier:_parse_pairwise_input; 27, argument_list; 27, 28; 27, 29; 27, 30; 27, 33; 28, identifier:indices; 29, identifier:indices2; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:logger; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:fname; 35, string:'add_distances()'; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:atom_pairs; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_check_indices; 43, argument_list; 43, 44; 44, identifier:atom_pairs; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:f; 48, call; 48, 49; 48, 50; 49, identifier:DistanceFeature; 50, argument_list; 50, 51; 50, 54; 50, 55; 51, attribute; 51, 52; 51, 53; 52, identifier:self; 53, identifier:topology; 54, identifier:atom_pairs; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:periodic; 57, identifier:periodic; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:__add_feature; 63, argument_list; 63, 64; 64, identifier:f
|
def add_distances(self, indices, periodic=True, indices2=None):
r
from .distances import DistanceFeature
atom_pairs = _parse_pairwise_input(
indices, indices2, self.logger, fname='add_distances()')
atom_pairs = self._check_indices(atom_pairs)
f = DistanceFeature(self.topology, atom_pairs, periodic=periodic)
self.__add_feature(f)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:add_inverse_distances; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:indices; 6, default_parameter; 6, 7; 6, 8; 7, identifier:periodic; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:indices2; 11, None; 12, block; 12, 13; 12, 20; 12, 34; 12, 43; 12, 56; 13, import_from_statement; 13, 14; 13, 18; 14, relative_import; 14, 15; 14, 16; 15, import_prefix; 16, dotted_name; 16, 17; 17, identifier:distances; 18, dotted_name; 18, 19; 19, identifier:InverseDistanceFeature; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:atom_pairs; 23, call; 23, 24; 23, 25; 24, identifier:_parse_pairwise_input; 25, argument_list; 25, 26; 25, 27; 25, 28; 25, 31; 26, identifier:indices; 27, identifier:indices2; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:logger; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:fname; 33, string:'add_inverse_distances()'; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:atom_pairs; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_check_indices; 41, argument_list; 41, 42; 42, identifier:atom_pairs; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:f; 46, call; 46, 47; 46, 48; 47, identifier:InverseDistanceFeature; 48, argument_list; 48, 49; 48, 52; 48, 53; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:topology; 52, identifier:atom_pairs; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:periodic; 55, identifier:periodic; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:__add_feature; 61, argument_list; 61, 62; 62, identifier:f
|
def add_inverse_distances(self, indices, periodic=True, indices2=None):
from .distances import InverseDistanceFeature
atom_pairs = _parse_pairwise_input(
indices, indices2, self.logger, fname='add_inverse_distances()')
atom_pairs = self._check_indices(atom_pairs)
f = InverseDistanceFeature(self.topology, atom_pairs, periodic=periodic)
self.__add_feature(f)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 18; 2, function_name:add_contacts; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:self; 5, identifier:indices; 6, default_parameter; 6, 7; 6, 8; 7, identifier:indices2; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:threshold; 11, float:0.3; 12, default_parameter; 12, 13; 12, 14; 13, identifier:periodic; 14, True; 15, default_parameter; 15, 16; 15, 17; 16, identifier:count_contacts; 17, False; 18, block; 18, 19; 18, 21; 18, 28; 18, 42; 18, 51; 18, 64; 19, expression_statement; 19, 20; 20, identifier:r; 21, import_from_statement; 21, 22; 21, 26; 22, relative_import; 22, 23; 22, 24; 23, import_prefix; 24, dotted_name; 24, 25; 25, identifier:distances; 26, dotted_name; 26, 27; 27, identifier:ContactFeature; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:atom_pairs; 31, call; 31, 32; 31, 33; 32, identifier:_parse_pairwise_input; 33, argument_list; 33, 34; 33, 35; 33, 36; 33, 39; 34, identifier:indices; 35, identifier:indices2; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:logger; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:fname; 41, string:'add_contacts()'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:atom_pairs; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:self; 48, identifier:_check_indices; 49, argument_list; 49, 50; 50, identifier:atom_pairs; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:f; 54, call; 54, 55; 54, 56; 55, identifier:ContactFeature; 56, argument_list; 56, 57; 56, 60; 56, 61; 56, 62; 56, 63; 57, attribute; 57, 58; 57, 59; 58, identifier:self; 59, identifier:topology; 60, identifier:atom_pairs; 61, identifier:threshold; 62, identifier:periodic; 63, identifier:count_contacts; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:__add_feature; 69, argument_list; 69, 70; 70, identifier:f
|
def add_contacts(self, indices, indices2=None, threshold=0.3, periodic=True, count_contacts=False):
r
from .distances import ContactFeature
atom_pairs = _parse_pairwise_input(
indices, indices2, self.logger, fname='add_contacts()')
atom_pairs = self._check_indices(atom_pairs)
f = ContactFeature(self.topology, atom_pairs, threshold, periodic, count_contacts)
self.__add_feature(f)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:spd_eig; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:W; 5, default_parameter; 5, 6; 5, 7; 6, identifier:epsilon; 7, float:1e-10; 8, default_parameter; 8, 9; 8, 10; 9, identifier:method; 10, string:'QR'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:canonical_signs; 13, False; 14, block; 14, 15; 14, 26; 14, 94; 14, 104; 14, 113; 14, 129; 14, 138; 14, 149; 14, 167; 14, 179; 14, 190; 14, 199; 14, 243; 15, assert_statement; 15, 16; 15, 25; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:_np; 19, identifier:allclose; 20, argument_list; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:W; 23, identifier:T; 24, identifier:W; 25, string:'W is not a symmetric matrix'; 26, if_statement; 26, 27; 26, 34; 26, 52; 26, 85; 27, comparison_operator:==; 27, 28; 27, 33; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:method; 31, identifier:lower; 32, argument_list; 33, string:'qr'; 34, block; 34, 35; 34, 43; 35, import_from_statement; 35, 36; 35, 41; 36, relative_import; 36, 37; 36, 38; 37, import_prefix; 38, dotted_name; 38, 39; 38, 40; 39, identifier:eig_qr; 40, identifier:eig_qr; 41, dotted_name; 41, 42; 42, identifier:eig_qr; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 48; 45, pattern_list; 45, 46; 45, 47; 46, identifier:s; 47, identifier:V; 48, call; 48, 49; 48, 50; 49, identifier:eig_qr; 50, argument_list; 50, 51; 51, identifier:W; 52, elif_clause; 52, 53; 52, 60; 53, comparison_operator:==; 53, 54; 53, 59; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:method; 57, identifier:lower; 58, argument_list; 59, string:'schur'; 60, block; 60, 61; 60, 67; 60, 76; 61, import_from_statement; 61, 62; 61, 65; 62, dotted_name; 62, 63; 62, 64; 63, identifier:scipy; 64, identifier:linalg; 65, dotted_name; 65, 66; 66, identifier:schur; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, pattern_list; 69, 70; 69, 71; 70, identifier:S; 71, identifier:V; 72, call; 72, 73; 72, 74; 73, identifier:schur; 74, argument_list; 74, 75; 75, identifier:W; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:s; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:_np; 82, identifier:diag; 83, argument_list; 83, 84; 84, identifier:S; 85, else_clause; 85, 86; 86, block; 86, 87; 87, raise_statement; 87, 88; 88, call; 88, 89; 88, 90; 89, identifier:ValueError; 90, argument_list; 90, 91; 91, binary_operator:+; 91, 92; 91, 93; 92, string:'method not implemented: '; 93, identifier:method; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 99; 96, pattern_list; 96, 97; 96, 98; 97, identifier:s; 98, identifier:V; 99, call; 99, 100; 99, 101; 100, identifier:sort_by_norm; 101, argument_list; 101, 102; 101, 103; 102, identifier:s; 103, identifier:V; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:evmin; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:_np; 110, identifier:min; 111, argument_list; 111, 112; 112, identifier:s; 113, if_statement; 113, 114; 113, 117; 114, comparison_operator:<; 114, 115; 114, 116; 115, identifier:evmin; 116, integer:0; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:epsilon; 121, call; 121, 122; 121, 123; 122, identifier:max; 123, argument_list; 123, 124; 123, 125; 124, identifier:epsilon; 125, binary_operator:+; 125, 126; 125, 128; 126, unary_operator:-; 126, 127; 127, identifier:evmin; 128, float:1e-16; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:evnorms; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:_np; 135, identifier:abs; 136, argument_list; 136, 137; 137, identifier:s; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:n; 141, subscript; 141, 142; 141, 148; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:_np; 145, identifier:shape; 146, argument_list; 146, 147; 147, identifier:evnorms; 148, integer:0; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 152; 151, identifier:m; 152, binary_operator:-; 152, 153; 152, 154; 153, identifier:n; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:_np; 157, identifier:searchsorted; 158, argument_list; 158, 159; 158, 166; 159, subscript; 159, 160; 159, 161; 160, identifier:evnorms; 161, slice; 161, 162; 161, 163; 161, 164; 162, colon; 163, colon; 164, unary_operator:-; 164, 165; 165, integer:1; 166, identifier:epsilon; 167, if_statement; 167, 168; 167, 171; 168, comparison_operator:==; 168, 169; 168, 170; 169, identifier:m; 170, integer:0; 171, block; 171, 172; 172, raise_statement; 172, 173; 173, call; 173, 174; 173, 175; 174, identifier:_ZeroRankError; 175, argument_list; 175, 176; 176, binary_operator:%; 176, 177; 176, 178; 177, string:'All eigenvalues are smaller than %g, rank reduction would discard all dimensions.'; 178, identifier:epsilon; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 182; 181, identifier:Vm; 182, subscript; 182, 183; 182, 184; 182, 186; 183, identifier:V; 184, slice; 184, 185; 185, colon; 186, slice; 186, 187; 186, 188; 186, 189; 187, integer:0; 188, colon; 189, identifier:m; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 193; 192, identifier:sm; 193, subscript; 193, 194; 193, 195; 194, identifier:s; 195, slice; 195, 196; 195, 197; 195, 198; 196, integer:0; 197, colon; 198, identifier:m; 199, if_statement; 199, 200; 199, 201; 200, identifier:canonical_signs; 201, block; 201, 202; 202, for_statement; 202, 203; 202, 204; 202, 208; 203, identifier:j; 204, call; 204, 205; 204, 206; 205, identifier:range; 206, argument_list; 206, 207; 207, identifier:m; 208, block; 208, 209; 208, 227; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:jj; 212, call; 212, 213; 212, 216; 213, attribute; 213, 214; 213, 215; 214, identifier:_np; 215, identifier:argmax; 216, argument_list; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:_np; 220, identifier:abs; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 224; 222, 226; 223, identifier:Vm; 224, slice; 224, 225; 225, colon; 226, identifier:j; 227, expression_statement; 227, 228; 228, augmented_assignment:*=; 228, 229; 228, 234; 229, subscript; 229, 230; 229, 231; 229, 233; 230, identifier:Vm; 231, slice; 231, 232; 232, colon; 233, identifier:j; 234, call; 234, 235; 234, 238; 235, attribute; 235, 236; 235, 237; 236, identifier:_np; 237, identifier:sign; 238, argument_list; 238, 239; 239, subscript; 239, 240; 239, 241; 239, 242; 240, identifier:Vm; 241, identifier:jj; 242, identifier:j; 243, return_statement; 243, 244; 244, expression_list; 244, 245; 244, 246; 245, identifier:sm; 246, identifier:Vm
|
def spd_eig(W, epsilon=1e-10, method='QR', canonical_signs=False):
assert _np.allclose(W.T, W), 'W is not a symmetric matrix'
if method.lower() == 'qr':
from .eig_qr.eig_qr import eig_qr
s, V = eig_qr(W)
elif method.lower() == 'schur':
from scipy.linalg import schur
S, V = schur(W)
s = _np.diag(S)
else:
raise ValueError('method not implemented: ' + method)
s, V = sort_by_norm(s, V)
evmin = _np.min(s)
if evmin < 0:
epsilon = max(epsilon, -evmin + 1e-16)
evnorms = _np.abs(s)
n = _np.shape(evnorms)[0]
m = n - _np.searchsorted(evnorms[::-1], epsilon)
if m == 0:
raise _ZeroRankError('All eigenvalues are smaller than %g, rank reduction would discard all dimensions.'%epsilon)
Vm = V[:, 0:m]
sm = s[0:m]
if canonical_signs:
for j in range(m):
jj = _np.argmax(_np.abs(Vm[:, j]))
Vm[:, j] *= _np.sign(Vm[jj, j])
return sm, Vm
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:eig_corr; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:C0; 5, identifier:Ct; 6, default_parameter; 6, 7; 6, 8; 7, identifier:epsilon; 8, float:1e-10; 9, default_parameter; 9, 10; 9, 11; 10, identifier:method; 11, string:'QR'; 12, default_parameter; 12, 13; 12, 14; 13, identifier:sign_maxelement; 14, False; 15, block; 15, 16; 15, 18; 15, 34; 15, 52; 15, 95; 15, 105; 15, 115; 15, 163; 16, expression_statement; 16, 17; 17, identifier:r; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:L; 21, call; 21, 22; 21, 23; 22, identifier:spd_inv_split; 23, argument_list; 23, 24; 23, 25; 23, 28; 23, 31; 24, identifier:C0; 25, keyword_argument; 25, 26; 25, 27; 26, identifier:epsilon; 27, identifier:epsilon; 28, keyword_argument; 28, 29; 28, 30; 29, identifier:method; 30, identifier:method; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:canonical_signs; 33, True; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:Ct_trans; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:_np; 40, identifier:dot; 41, argument_list; 41, 42; 41, 51; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:_np; 45, identifier:dot; 46, argument_list; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:L; 49, identifier:T; 50, identifier:Ct; 51, identifier:L; 52, if_statement; 52, 53; 52, 62; 52, 78; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:_np; 56, identifier:allclose; 57, argument_list; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:Ct; 60, identifier:T; 61, identifier:Ct; 62, block; 62, 63; 62, 69; 63, import_from_statement; 63, 64; 63, 67; 64, dotted_name; 64, 65; 64, 66; 65, identifier:scipy; 66, identifier:linalg; 67, dotted_name; 67, 68; 68, identifier:eigh; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 74; 71, pattern_list; 71, 72; 71, 73; 72, identifier:l; 73, identifier:R_trans; 74, call; 74, 75; 74, 76; 75, identifier:eigh; 76, argument_list; 76, 77; 77, identifier:Ct_trans; 78, else_clause; 78, 79; 79, block; 79, 80; 79, 86; 80, import_from_statement; 80, 81; 80, 84; 81, dotted_name; 81, 82; 81, 83; 82, identifier:scipy; 83, identifier:linalg; 84, dotted_name; 84, 85; 85, identifier:eig; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 91; 88, pattern_list; 88, 89; 88, 90; 89, identifier:l; 90, identifier:R_trans; 91, call; 91, 92; 91, 93; 92, identifier:eig; 93, argument_list; 93, 94; 94, identifier:Ct_trans; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 100; 97, pattern_list; 97, 98; 97, 99; 98, identifier:l; 99, identifier:R_trans; 100, call; 100, 101; 100, 102; 101, identifier:sort_by_norm; 102, argument_list; 102, 103; 102, 104; 103, identifier:l; 104, identifier:R_trans; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:R; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:_np; 111, identifier:dot; 112, argument_list; 112, 113; 112, 114; 113, identifier:L; 114, identifier:R_trans; 115, if_statement; 115, 116; 115, 117; 116, identifier:sign_maxelement; 117, block; 117, 118; 118, for_statement; 118, 119; 118, 120; 118, 128; 119, identifier:j; 120, call; 120, 121; 120, 122; 121, identifier:range; 122, argument_list; 122, 123; 123, subscript; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:R; 126, identifier:shape; 127, integer:1; 128, block; 128, 129; 128, 147; 129, expression_statement; 129, 130; 130, assignment; 130, 131; 130, 132; 131, identifier:imax; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:_np; 135, identifier:argmax; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:_np; 140, identifier:abs; 141, argument_list; 141, 142; 142, subscript; 142, 143; 142, 144; 142, 146; 143, identifier:R; 144, slice; 144, 145; 145, colon; 146, identifier:j; 147, expression_statement; 147, 148; 148, augmented_assignment:*=; 148, 149; 148, 154; 149, subscript; 149, 150; 149, 151; 149, 153; 150, identifier:R; 151, slice; 151, 152; 152, colon; 153, identifier:j; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:_np; 157, identifier:sign; 158, argument_list; 158, 159; 159, subscript; 159, 160; 159, 161; 159, 162; 160, identifier:R; 161, identifier:imax; 162, identifier:j; 163, return_statement; 163, 164; 164, expression_list; 164, 165; 164, 166; 165, identifier:l; 166, identifier:R
|
def eig_corr(C0, Ct, epsilon=1e-10, method='QR', sign_maxelement=False):
r
L = spd_inv_split(C0, epsilon=epsilon, method=method, canonical_signs=True)
Ct_trans = _np.dot(_np.dot(L.T, Ct), L)
if _np.allclose(Ct.T, Ct):
from scipy.linalg import eigh
l, R_trans = eigh(Ct_trans)
else:
from scipy.linalg import eig
l, R_trans = eig(Ct_trans)
l, R_trans = sort_by_norm(l, R_trans)
R = _np.dot(L, R_trans)
if sign_maxelement:
for j in range(R.shape[1]):
imax = _np.argmax(_np.abs(R[:, j]))
R[:, j] *= _np.sign(R[imax, j])
return l, R
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:sortino_ratio; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:threshold; 7, float:0.0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:ddof; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:freq; 13, None; 14, block; 14, 15; 14, 32; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:stdev; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:semi_stdev; 22, argument_list; 22, 23; 22, 26; 22, 29; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:threshold; 25, identifier:threshold; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:ddof; 28, identifier:ddof; 29, keyword_argument; 29, 30; 29, 31; 30, identifier:freq; 31, identifier:freq; 32, return_statement; 32, 33; 33, binary_operator:/; 33, 34; 33, 42; 34, parenthesized_expression; 34, 35; 35, binary_operator:-; 35, 36; 35, 41; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:anlzd_ret; 40, argument_list; 41, identifier:threshold; 42, identifier:stdev
|
def sortino_ratio(self, threshold=0.0, ddof=0, freq=None):
stdev = self.semi_stdev(threshold=threshold, ddof=ddof, freq=freq)
return (self.anlzd_ret() - threshold) / stdev
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:columnId; 6, default_parameter; 6, 7; 6, 8; 7, identifier:order; 8, attribute; 8, 9; 8, 10; 9, identifier:Qt; 10, identifier:AscendingOrder; 11, block; 11, 12; 11, 20; 11, 28; 11, 38; 11, 57; 11, 65; 12, expression_statement; 12, 13; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:layoutAboutToBeChanged; 18, identifier:emit; 19, argument_list; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 27; 22, attribute; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:sortingAboutToStart; 26, identifier:emit; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:column; 31, subscript; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:_dataFrame; 36, identifier:columns; 37, identifier:columnId; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_dataFrame; 44, identifier:sort_values; 45, argument_list; 45, 46; 45, 47; 45, 54; 46, identifier:column; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:ascending; 49, not_operator; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:bool; 52, argument_list; 52, 53; 53, identifier:order; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:inplace; 56, True; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 64; 59, attribute; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:self; 62, identifier:layoutChanged; 63, identifier:emit; 64, argument_list; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 72; 67, attribute; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:sortingFinished; 71, identifier:emit; 72, argument_list
|
def sort(self, columnId, order=Qt.AscendingOrder):
self.layoutAboutToBeChanged.emit()
self.sortingAboutToStart.emit()
column = self._dataFrame.columns[columnId]
self._dataFrame.sort_values(column, ascending=not bool(order), inplace=True)
self.layoutChanged.emit()
self.sortingFinished.emit()
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:run; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:clf; 6, block; 6, 7; 6, 17; 6, 29; 6, 44; 6, 60; 6, 72; 6, 83; 6, 91; 6, 95; 6, 151; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:rank; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:MPI; 14, identifier:COMM_WORLD; 15, identifier:Get_rank; 16, argument_list; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:==; 18, 19; 18, 20; 19, identifier:rank; 20, integer:0; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:logger; 26, identifier:info; 27, argument_list; 27, 28; 28, string:'running activity-based voxel selection via Searchlight'; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 36; 31, attribute; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:sl; 35, identifier:distribute; 36, argument_list; 36, 37; 36, 41; 37, list:[self.data]; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:data; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:mask; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 51; 46, attribute; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:sl; 50, identifier:broadcast; 51, argument_list; 51, 52; 52, tuple; 52, 53; 52, 56; 52, 59; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:labels; 56, attribute; 56, 57; 56, 58; 57, identifier:self; 58, identifier:num_folds; 59, identifier:clf; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:==; 61, 62; 61, 63; 62, identifier:rank; 63, integer:0; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:logger; 69, identifier:info; 70, argument_list; 70, 71; 71, string:'data preparation done'; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:result_volume; 75, call; 75, 76; 75, 81; 76, attribute; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:self; 79, identifier:sl; 80, identifier:run_searchlight; 81, argument_list; 81, 82; 82, identifier:_sfn; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:result_list; 86, subscript; 86, 87; 86, 88; 87, identifier:result_volume; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:mask; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:results; 94, list:[]; 95, if_statement; 95, 96; 95, 99; 96, comparison_operator:==; 96, 97; 96, 98; 97, identifier:rank; 98, integer:0; 99, block; 99, 100; 99, 127; 99, 144; 100, for_statement; 100, 101; 100, 104; 100, 108; 101, pattern_list; 101, 102; 101, 103; 102, identifier:idx; 103, identifier:value; 104, call; 104, 105; 104, 106; 105, identifier:enumerate; 106, argument_list; 106, 107; 107, identifier:result_list; 108, block; 108, 109; 108, 118; 109, if_statement; 109, 110; 109, 113; 110, comparison_operator:is; 110, 111; 110, 112; 111, identifier:value; 112, None; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:value; 117, integer:0; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:results; 122, identifier:append; 123, argument_list; 123, 124; 124, tuple; 124, 125; 124, 126; 125, identifier:idx; 126, identifier:value; 127, expression_statement; 127, 128; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:results; 131, identifier:sort; 132, argument_list; 132, 133; 132, 141; 133, keyword_argument; 133, 134; 133, 135; 134, identifier:key; 135, lambda; 135, 136; 135, 138; 136, lambda_parameters; 136, 137; 137, identifier:tup; 138, subscript; 138, 139; 138, 140; 139, identifier:tup; 140, integer:1; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:reverse; 143, True; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:logger; 148, identifier:info; 149, argument_list; 149, 150; 150, string:'activity-based voxel selection via Searchlight is done'; 151, return_statement; 151, 152; 152, expression_list; 152, 153; 152, 154; 153, identifier:result_volume; 154, identifier:results
|
def run(self, clf):
rank = MPI.COMM_WORLD.Get_rank()
if rank == 0:
logger.info(
'running activity-based voxel selection via Searchlight'
)
self.sl.distribute([self.data], self.mask)
self.sl.broadcast((self.labels, self.num_folds, clf))
if rank == 0:
logger.info(
'data preparation done'
)
result_volume = self.sl.run_searchlight(_sfn)
result_list = result_volume[self.mask]
results = []
if rank == 0:
for idx, value in enumerate(result_list):
if value is None:
value = 0
results.append((idx, value))
results.sort(key=lambda tup: tup[1], reverse=True)
logger.info(
'activity-based voxel selection via Searchlight is done'
)
return result_volume, results
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:run; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:clf; 6, block; 6, 7; 6, 17; 6, 62; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:rank; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:MPI; 14, identifier:COMM_WORLD; 15, identifier:Get_rank; 16, argument_list; 17, if_statement; 17, 18; 17, 23; 17, 49; 18, comparison_operator:==; 18, 19; 18, 20; 19, identifier:rank; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:master_rank; 23, block; 23, 24; 23, 32; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:results; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:_master; 31, argument_list; 32, expression_statement; 32, 33; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:results; 36, identifier:sort; 37, argument_list; 37, 38; 37, 46; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:key; 40, lambda; 40, 41; 40, 43; 41, lambda_parameters; 41, 42; 42, identifier:tup; 43, subscript; 43, 44; 43, 45; 44, identifier:tup; 45, integer:1; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:reverse; 48, True; 49, else_clause; 49, 50; 50, block; 50, 51; 50, 58; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_worker; 56, argument_list; 56, 57; 57, identifier:clf; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:results; 61, list:[]; 62, return_statement; 62, 63; 63, identifier:results
|
def run(self, clf):
rank = MPI.COMM_WORLD.Get_rank()
if rank == self.master_rank:
results = self._master()
results.sort(key=lambda tup: tup[1], reverse=True)
else:
self._worker(clf)
results = []
return results
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:column_or_label; 6, default_parameter; 6, 7; 6, 8; 7, identifier:descending; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:distinct; 11, False; 12, block; 12, 13; 12, 22; 12, 56; 12, 68; 12, 86; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:column; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_get_column; 20, argument_list; 20, 21; 21, identifier:column_or_label; 22, if_statement; 22, 23; 22, 24; 22, 39; 23, identifier:distinct; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 30; 27, pattern_list; 27, 28; 27, 29; 28, identifier:_; 29, identifier:row_numbers; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:np; 33, identifier:unique; 34, argument_list; 34, 35; 34, 36; 35, identifier:column; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:return_index; 38, True; 39, else_clause; 39, 40; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:row_numbers; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:np; 47, identifier:argsort; 48, argument_list; 48, 49; 48, 50; 48, 53; 49, identifier:column; 50, keyword_argument; 50, 51; 50, 52; 51, identifier:axis; 52, integer:0; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:kind; 55, string:'mergesort'; 56, assert_statement; 56, 57; 56, 67; 57, call; 57, 58; 57, 66; 58, attribute; 58, 59; 58, 65; 59, parenthesized_expression; 59, 60; 60, comparison_operator:<; 60, 61; 60, 62; 61, identifier:row_numbers; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:num_rows; 65, identifier:all; 66, argument_list; 67, identifier:row_numbers; 68, if_statement; 68, 69; 68, 70; 69, identifier:descending; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:row_numbers; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:np; 77, identifier:array; 78, argument_list; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:row_numbers; 81, slice; 81, 82; 81, 83; 81, 84; 82, colon; 83, colon; 84, unary_operator:-; 84, 85; 85, integer:1; 86, return_statement; 86, 87; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:self; 90, identifier:take; 91, argument_list; 91, 92; 92, identifier:row_numbers
|
def sort(self, column_or_label, descending=False, distinct=False):
column = self._get_column(column_or_label)
if distinct:
_, row_numbers = np.unique(column, return_index=True)
else:
row_numbers = np.argsort(column, axis=0, kind='mergesort')
assert (row_numbers < self.num_rows).all(), row_numbers
if descending:
row_numbers = np.array(row_numbers[::-1])
return self.take(row_numbers)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sub_expand; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:tags; 6, block; 6, 7; 6, 11; 6, 20; 6, 89; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:entities; 10, dictionary; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:graph; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:_build_graph; 18, argument_list; 18, 19; 19, identifier:tags; 20, for_statement; 20, 21; 20, 22; 20, 23; 21, identifier:tag; 22, identifier:tags; 23, block; 23, 24; 24, for_statement; 24, 25; 24, 26; 24, 38; 25, identifier:entity_index; 26, call; 26, 27; 26, 28; 27, identifier:xrange; 28, argument_list; 28, 29; 29, call; 29, 30; 29, 31; 30, identifier:len; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:tag; 35, identifier:get; 36, argument_list; 36, 37; 37, string:'entities'; 38, block; 38, 39; 38, 47; 38, 59; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:node_name; 42, call; 42, 43; 42, 44; 43, identifier:graph_key_from_tag; 44, argument_list; 44, 45; 44, 46; 45, identifier:tag; 46, identifier:entity_index; 47, if_statement; 47, 48; 47, 52; 48, not_operator; 48, 49; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:node_name; 51, identifier:entities; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 58; 55, subscript; 55, 56; 55, 57; 56, identifier:entities; 57, identifier:node_name; 58, list:[]; 59, expression_statement; 59, 60; 60, augmented_assignment:+=; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:entities; 63, identifier:node_name; 64, list:[
tag.get('entities', [])[entity_index],
tag.get('entities', [])[entity_index].get('confidence'),
tag
]; 64, 65; 64, 74; 64, 88; 65, subscript; 65, 66; 65, 73; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:tag; 69, identifier:get; 70, argument_list; 70, 71; 70, 72; 71, string:'entities'; 72, list:[]; 73, identifier:entity_index; 74, call; 74, 75; 74, 86; 75, attribute; 75, 76; 75, 85; 76, subscript; 76, 77; 76, 84; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:tag; 80, identifier:get; 81, argument_list; 81, 82; 81, 83; 82, string:'entities'; 83, list:[]; 84, identifier:entity_index; 85, identifier:get; 86, argument_list; 86, 87; 87, string:'confidence'; 88, identifier:tag; 89, for_statement; 89, 90; 89, 91; 89, 99; 90, identifier:clique; 91, call; 91, 92; 91, 93; 92, identifier:get_cliques; 93, argument_list; 93, 94; 93, 98; 94, call; 94, 95; 94, 96; 95, identifier:list; 96, argument_list; 96, 97; 97, identifier:entities; 98, identifier:graph; 99, block; 99, 100; 99, 104; 99, 220; 99, 238; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:result; 103, list:[]; 104, for_statement; 104, 105; 104, 106; 104, 107; 105, identifier:entity_name; 106, identifier:clique; 107, block; 107, 108; 107, 122; 107, 130; 107, 213; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:start_token; 111, call; 111, 112; 111, 113; 112, identifier:int; 113, argument_list; 113, 114; 114, subscript; 114, 115; 114, 121; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:entity_name; 118, identifier:split; 119, argument_list; 119, 120; 120, string:"-"; 121, integer:0; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:old_tag; 125, subscript; 125, 126; 125, 129; 126, subscript; 126, 127; 126, 128; 127, identifier:entities; 128, identifier:entity_name; 129, integer:2; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:tag; 133, dictionary; 133, 134; 133, 137; 133, 148; 133, 166; 133, 174; 133, 189; 133, 204; 134, pair; 134, 135; 134, 136; 135, string:'start_token'; 136, identifier:start_token; 137, pair; 137, 138; 137, 139; 138, string:'entities'; 139, list:[entities.get(entity_name)[0]]; 139, 140; 140, subscript; 140, 141; 140, 147; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:entities; 144, identifier:get; 145, argument_list; 145, 146; 146, identifier:entity_name; 147, integer:0; 148, pair; 148, 149; 148, 150; 149, string:'confidence'; 150, binary_operator:*; 150, 151; 150, 159; 151, subscript; 151, 152; 151, 158; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:entities; 155, identifier:get; 156, argument_list; 156, 157; 157, identifier:entity_name; 158, integer:1; 159, call; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:old_tag; 162, identifier:get; 163, argument_list; 163, 164; 163, 165; 164, string:'confidence'; 165, float:1.0; 166, pair; 166, 167; 166, 168; 167, string:'end_token'; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:old_tag; 171, identifier:get; 172, argument_list; 172, 173; 173, string:'end_token'; 174, pair; 174, 175; 174, 176; 175, string:'match'; 176, call; 176, 177; 176, 187; 177, attribute; 177, 178; 177, 186; 178, subscript; 178, 179; 178, 185; 179, call; 179, 180; 179, 183; 180, attribute; 180, 181; 180, 182; 181, identifier:old_tag; 182, identifier:get; 183, argument_list; 183, 184; 184, string:'entities'; 185, integer:0; 186, identifier:get; 187, argument_list; 187, 188; 188, string:'match'; 189, pair; 189, 190; 189, 191; 190, string:'key'; 191, call; 191, 192; 191, 202; 192, attribute; 192, 193; 192, 201; 193, subscript; 193, 194; 193, 200; 194, call; 194, 195; 194, 198; 195, attribute; 195, 196; 195, 197; 196, identifier:old_tag; 197, identifier:get; 198, argument_list; 198, 199; 199, string:'entities'; 200, integer:0; 201, identifier:get; 202, argument_list; 202, 203; 203, string:'key'; 204, pair; 204, 205; 204, 206; 205, string:'from_context'; 206, call; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:old_tag; 209, identifier:get; 210, argument_list; 210, 211; 210, 212; 211, string:'from_context'; 212, False; 213, expression_statement; 213, 214; 214, call; 214, 215; 214, 218; 215, attribute; 215, 216; 215, 217; 216, identifier:result; 217, identifier:append; 218, argument_list; 218, 219; 219, identifier:tag; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:result; 223, call; 223, 224; 223, 225; 224, identifier:sorted; 225, argument_list; 225, 226; 225, 227; 226, identifier:result; 227, keyword_argument; 227, 228; 227, 229; 228, identifier:key; 229, lambda; 229, 230; 229, 232; 230, lambda_parameters; 230, 231; 231, identifier:e; 232, call; 232, 233; 232, 236; 233, attribute; 233, 234; 233, 235; 234, identifier:e; 235, identifier:get; 236, argument_list; 236, 237; 237, string:'start_token'; 238, expression_statement; 238, 239; 239, yield; 239, 240; 240, identifier:result
|
def _sub_expand(self, tags):
entities = {}
graph = self._build_graph(tags)
for tag in tags:
for entity_index in xrange(len(tag.get('entities'))):
node_name = graph_key_from_tag(tag, entity_index)
if not node_name in entities:
entities[node_name] = []
entities[node_name] += [
tag.get('entities', [])[entity_index],
tag.get('entities', [])[entity_index].get('confidence'),
tag
]
for clique in get_cliques(list(entities), graph):
result = []
for entity_name in clique:
start_token = int(entity_name.split("-")[0])
old_tag = entities[entity_name][2]
tag = {
'start_token': start_token,
'entities': [entities.get(entity_name)[0]],
'confidence': entities.get(entity_name)[1] * old_tag.get('confidence', 1.0),
'end_token': old_tag.get('end_token'),
'match': old_tag.get('entities')[0].get('match'),
'key': old_tag.get('entities')[0].get('key'),
'from_context': old_tag.get('from_context', False)
}
result.append(tag)
result = sorted(result, key=lambda e: e.get('start_token'))
yield result
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 1, 22; 2, function_name:_rank_results; 3, parameters; 3, 4; 3, 12; 4, typed_parameter; 4, 5; 4, 6; 5, identifier:results; 6, type; 6, 7; 7, generic_type; 7, 8; 7, 9; 8, identifier:List; 9, type_parameter; 9, 10; 10, type; 10, 11; 11, identifier:Dict; 12, typed_parameter; 12, 13; 12, 14; 13, identifier:method; 14, type; 14, 15; 15, identifier:SimAlgorithm; 16, type; 16, 17; 17, generic_type; 17, 18; 17, 19; 18, identifier:List; 19, type_parameter; 19, 20; 20, type; 20, 21; 21, identifier:Dict; 22, block; 22, 23; 22, 45; 22, 104; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:sorted_results; 26, call; 26, 27; 26, 28; 27, identifier:sorted; 28, argument_list; 28, 29; 28, 30; 28, 33; 29, identifier:results; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:reverse; 32, True; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:key; 35, lambda; 35, 36; 35, 38; 36, lambda_parameters; 36, 37; 37, identifier:k; 38, subscript; 38, 39; 38, 40; 39, identifier:k; 40, subscript; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:OwlSim2Api; 43, identifier:method2key; 44, identifier:method; 45, if_statement; 45, 46; 45, 52; 46, comparison_operator:>; 46, 47; 46, 51; 47, call; 47, 48; 47, 49; 48, identifier:len; 49, argument_list; 49, 50; 50, identifier:sorted_results; 51, integer:0; 52, block; 52, 53; 52, 57; 52, 69; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:rank; 56, integer:1; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:previous_score; 60, subscript; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:sorted_results; 63, integer:0; 64, subscript; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:OwlSim2Api; 67, identifier:method2key; 68, identifier:method; 69, for_statement; 69, 70; 69, 71; 69, 72; 70, identifier:result; 71, identifier:sorted_results; 72, block; 72, 73; 72, 88; 72, 94; 73, if_statement; 73, 74; 73, 83; 74, comparison_operator:>; 74, 75; 74, 76; 75, identifier:previous_score; 76, subscript; 76, 77; 76, 78; 77, identifier:result; 78, subscript; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:OwlSim2Api; 81, identifier:method2key; 82, identifier:method; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, augmented_assignment:+=; 85, 86; 85, 87; 86, identifier:rank; 87, integer:1; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:result; 92, string:'rank'; 93, identifier:rank; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:previous_score; 97, subscript; 97, 98; 97, 99; 98, identifier:result; 99, subscript; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:OwlSim2Api; 102, identifier:method2key; 103, identifier:method; 104, return_statement; 104, 105; 105, identifier:sorted_results
|
def _rank_results(results: List[Dict], method: SimAlgorithm) -> List[Dict]:
sorted_results = sorted(
results, reverse=True, key=lambda k: k[OwlSim2Api.method2key[method]]
)
if len(sorted_results) > 0:
rank = 1
previous_score = sorted_results[0][OwlSim2Api.method2key[method]]
for result in sorted_results:
if previous_score > result[OwlSim2Api.method2key[method]]:
rank += 1
result['rank'] = rank
previous_score = result[OwlSim2Api.method2key[method]]
return sorted_results
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_source_files; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 11; 5, 15; 5, 52; 6, assert_statement; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:self; 9, identifier:final; 10, string:'Call build() before using the graph.'; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:out; 14, list:[]; 15, for_statement; 15, 16; 15, 17; 15, 25; 16, identifier:node; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:nx; 20, identifier:topological_sort; 21, argument_list; 21, 22; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:graph; 25, block; 25, 26; 26, if_statement; 26, 27; 26, 32; 26, 42; 27, call; 27, 28; 27, 29; 28, identifier:isinstance; 29, argument_list; 29, 30; 29, 31; 30, identifier:node; 31, identifier:NodeSet; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:out; 37, identifier:append; 38, argument_list; 38, 39; 39, attribute; 39, 40; 39, 41; 40, identifier:node; 41, identifier:nodes; 42, else_clause; 42, 43; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:out; 48, identifier:append; 49, argument_list; 49, 50; 50, list:[node]; 50, 51; 51, identifier:node; 52, return_statement; 52, 53; 53, call; 53, 54; 53, 55; 54, identifier:list; 55, argument_list; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:reversed; 58, argument_list; 58, 59; 59, identifier:out
|
def sorted_source_files(self):
assert self.final, 'Call build() before using the graph.'
out = []
for node in nx.topological_sort(self.graph):
if isinstance(node, NodeSet):
out.append(node.nodes)
else:
out.append([node])
return list(reversed(out))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:expand_source_files; 3, parameters; 3, 4; 3, 5; 4, identifier:filenames; 5, default_parameter; 5, 6; 5, 7; 6, identifier:cwd; 7, None; 8, block; 8, 9; 8, 13; 8, 56; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:out; 12, list:[]; 13, for_statement; 13, 14; 13, 15; 13, 20; 14, identifier:f; 15, call; 15, 16; 15, 17; 16, identifier:expand_paths; 17, argument_list; 17, 18; 17, 19; 18, identifier:filenames; 19, identifier:cwd; 20, block; 20, 21; 21, if_statement; 21, 22; 21, 30; 21, 39; 22, call; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:os; 26, identifier:path; 27, identifier:isdir; 28, argument_list; 28, 29; 29, identifier:f; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, augmented_assignment:+=; 32, 33; 32, 34; 33, identifier:out; 34, call; 34, 35; 34, 36; 35, identifier:collect_files; 36, argument_list; 36, 37; 36, 38; 37, identifier:f; 38, string:".py"; 39, else_clause; 39, 40; 40, block; 40, 41; 41, if_statement; 41, 42; 41, 48; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:f; 45, identifier:endswith; 46, argument_list; 46, 47; 47, string:".py"; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:out; 53, identifier:append; 54, argument_list; 54, 55; 55, identifier:f; 56, return_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:sorted; 59, argument_list; 59, 60; 60, call; 60, 61; 60, 62; 61, identifier:set; 62, argument_list; 62, 63; 63, identifier:out
|
def expand_source_files(filenames, cwd=None):
out = []
for f in expand_paths(filenames, cwd):
if os.path.isdir(f):
out += collect_files(f, ".py")
else:
if f.endswith(".py"):
out.append(f)
return sorted(set(out))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:run; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 12; 5, 33; 5, 39; 5, 45; 5, 51; 5, 58; 5, 78; 5, 99; 5, 119; 5, 133; 5, 162; 5, 181; 5, 199; 5, 224; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:query; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:query; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:cardinality; 17, call; 17, 18; 17, 32; 18, attribute; 18, 19; 18, 31; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:query; 22, identifier:add_columns; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 30; 25, subscript; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:columns; 29, integer:0; 30, identifier:sqla_expr; 31, identifier:count; 32, argument_list; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_set_column_filter_expressions; 38, argument_list; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_set_global_filter_expression; 44, argument_list; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_set_sort_expressions; 50, argument_list; 51, expression_statement; 51, 52; 52, call; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:_set_yadcf_data; 56, argument_list; 56, 57; 57, identifier:query; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:query; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:query; 64, identifier:filter; 65, argument_list; 65, 66; 66, list_splat; 66, 67; 67, list_comprehension; 67, 68; 67, 69; 67, 74; 68, identifier:e; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:e; 71, attribute; 71, 72; 71, 73; 72, identifier:self; 73, identifier:filter_expressions; 74, if_clause; 74, 75; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:e; 77, None; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:self; 82, identifier:cardinality_filtered; 83, call; 83, 84; 83, 98; 84, attribute; 84, 85; 84, 97; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:query; 88, identifier:add_columns; 89, argument_list; 89, 90; 90, attribute; 90, 91; 90, 96; 91, subscript; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:columns; 95, integer:0; 96, identifier:sqla_expr; 97, identifier:count; 98, argument_list; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:query; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:query; 105, identifier:order_by; 106, argument_list; 106, 107; 107, list_splat; 107, 108; 108, list_comprehension; 108, 109; 108, 110; 108, 115; 109, identifier:e; 110, for_in_clause; 110, 111; 110, 112; 111, identifier:e; 112, attribute; 112, 113; 112, 114; 113, identifier:self; 114, identifier:sort_expressions; 115, if_clause; 115, 116; 116, comparison_operator:is; 116, 117; 116, 118; 117, identifier:e; 118, None; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:length; 122, call; 122, 123; 122, 124; 123, identifier:int; 124, argument_list; 124, 125; 125, call; 125, 126; 125, 131; 126, attribute; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:params; 130, identifier:get; 131, argument_list; 131, 132; 132, string:'length'; 133, if_statement; 133, 134; 133, 137; 133, 147; 133, 154; 134, comparison_operator:>=; 134, 135; 134, 136; 135, identifier:length; 136, integer:0; 137, block; 137, 138; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:query; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:query; 144, identifier:limit; 145, argument_list; 145, 146; 146, identifier:length; 147, elif_clause; 147, 148; 147, 152; 148, comparison_operator:==; 148, 149; 148, 150; 149, identifier:length; 150, unary_operator:-; 150, 151; 151, integer:1; 152, block; 152, 153; 153, pass_statement; 154, else_clause; 154, 155; 155, block; 155, 156; 156, raise_statement; 156, 157; 157, parenthesized_expression; 157, 158; 158, call; 158, 159; 158, 160; 159, identifier:ValueError; 160, argument_list; 160, 161; 161, string:'Length should be a positive integer or -1 to disable'; 162, expression_statement; 162, 163; 163, assignment; 163, 164; 163, 165; 164, identifier:query; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:query; 168, identifier:offset; 169, argument_list; 169, 170; 170, call; 170, 171; 170, 172; 171, identifier:int; 172, argument_list; 172, 173; 173, call; 173, 174; 173, 179; 174, attribute; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:self; 177, identifier:params; 178, identifier:get; 179, argument_list; 179, 180; 180, string:'start'; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:query; 184, call; 184, 185; 184, 188; 185, attribute; 185, 186; 185, 187; 186, identifier:query; 187, identifier:add_columns; 188, argument_list; 188, 189; 189, list_splat; 189, 190; 190, list_comprehension; 190, 191; 190, 194; 191, attribute; 191, 192; 191, 193; 192, identifier:c; 193, identifier:sqla_expr; 194, for_in_clause; 194, 195; 194, 196; 195, identifier:c; 196, attribute; 196, 197; 196, 198; 197, identifier:self; 198, identifier:columns; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:column_names; 202, list_comprehension; 202, 203; 202, 214; 203, conditional_expression:if; 203, 204; 203, 207; 203, 210; 204, attribute; 204, 205; 204, 206; 205, identifier:col; 206, identifier:mData; 207, attribute; 207, 208; 207, 209; 208, identifier:col; 209, identifier:mData; 210, call; 210, 211; 210, 212; 211, identifier:str; 212, argument_list; 212, 213; 213, identifier:i; 214, for_in_clause; 214, 215; 214, 218; 215, pattern_list; 215, 216; 215, 217; 216, identifier:i; 217, identifier:col; 218, call; 218, 219; 218, 220; 219, identifier:enumerate; 220, argument_list; 220, 221; 221, attribute; 221, 222; 221, 223; 222, identifier:self; 223, identifier:columns; 224, expression_statement; 224, 225; 225, assignment; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:self; 228, identifier:results; 229, list_comprehension; 229, 230; 229, 243; 230, dictionary_comprehension; 230, 231; 230, 234; 231, pair; 231, 232; 231, 233; 232, identifier:k; 233, identifier:v; 234, for_in_clause; 234, 235; 234, 238; 235, pattern_list; 235, 236; 235, 237; 236, identifier:k; 237, identifier:v; 238, call; 238, 239; 238, 240; 239, identifier:zip; 240, argument_list; 240, 241; 240, 242; 241, identifier:column_names; 242, identifier:row; 243, for_in_clause; 243, 244; 243, 245; 244, identifier:row; 245, call; 245, 246; 245, 249; 246, attribute; 246, 247; 246, 248; 247, identifier:query; 248, identifier:all; 249, argument_list
|
def run(self):
query = self.query
self.cardinality = query.add_columns(self.columns[0].sqla_expr).count()
self._set_column_filter_expressions()
self._set_global_filter_expression()
self._set_sort_expressions()
self._set_yadcf_data(query)
query = query.filter(
*[e for e in self.filter_expressions if e is not None])
self.cardinality_filtered = query.add_columns(
self.columns[0].sqla_expr).count()
query = query.order_by(
*[e for e in self.sort_expressions if e is not None])
length = int(self.params.get('length'))
if length >= 0:
query = query.limit(length)
elif length == -1:
pass
else:
raise (ValueError(
'Length should be a positive integer or -1 to disable'))
query = query.offset(int(self.params.get('start')))
query = query.add_columns(*[c.sqla_expr for c in self.columns])
column_names = [
col.mData if col.mData else str(i)
for i, col in enumerate(self.columns)
]
self.results = [{k: v
for k, v in zip(column_names, row)}
for row in query.all()]
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:poll_events; 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:started; 10, block; 10, 11; 10, 15; 10, 19; 10, 54; 10, 83; 10, 98; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:event_obj; 14, None; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:event_name; 18, None; 19, try_statement; 19, 20; 19, 32; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:event_obj; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:_sl4a; 29, identifier:eventWait; 30, argument_list; 30, 31; 31, integer:50000; 32, except_clause; 32, 33; 33, block; 33, 34; 34, if_statement; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:started; 38, block; 38, 39; 38, 44; 38, 53; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:print; 42, argument_list; 42, 43; 43, string:"Exception happened during polling."; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 47; 46, identifier:print; 47, argument_list; 47, 48; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:traceback; 51, identifier:format_exc; 52, argument_list; 53, raise_statement; 54, if_statement; 54, 55; 54, 57; 54, 59; 54, 75; 55, not_operator; 55, 56; 56, identifier:event_obj; 57, block; 57, 58; 58, continue_statement; 59, elif_clause; 59, 60; 59, 63; 60, comparison_operator:not; 60, 61; 60, 62; 61, string:'name'; 62, identifier:event_obj; 63, block; 63, 64; 63, 74; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:print; 67, argument_list; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, string:"Received Malformed event {}"; 71, identifier:format; 72, argument_list; 72, 73; 73, identifier:event_obj; 74, continue_statement; 75, else_clause; 75, 76; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:event_name; 80, subscript; 80, 81; 80, 82; 81, identifier:event_obj; 82, string:'name'; 83, if_statement; 83, 84; 83, 89; 84, comparison_operator:in; 84, 85; 84, 86; 85, identifier:event_name; 86, attribute; 86, 87; 86, 88; 87, identifier:self; 88, identifier:handlers; 89, block; 89, 90; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:self; 94, identifier:handle_subscribed_event; 95, argument_list; 95, 96; 95, 97; 96, identifier:event_obj; 97, identifier:event_name; 98, if_statement; 98, 99; 98, 102; 98, 112; 99, comparison_operator:==; 99, 100; 99, 101; 100, identifier:event_name; 101, string:"EventDispatcherShutdown"; 102, block; 102, 103; 102, 111; 103, expression_statement; 103, 104; 104, call; 104, 105; 104, 110; 105, attribute; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:self; 108, identifier:_sl4a; 109, identifier:closeSl4aSession; 110, argument_list; 111, break_statement; 112, else_clause; 112, 113; 113, block; 113, 114; 113, 122; 113, 165; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 121; 116, attribute; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:self; 119, identifier:lock; 120, identifier:acquire; 121, argument_list; 122, if_statement; 122, 123; 122, 128; 122, 140; 123, comparison_operator:in; 123, 124; 123, 125; 124, identifier:event_name; 125, attribute; 125, 126; 125, 127; 126, identifier:self; 127, identifier:event_dict; 128, block; 128, 129; 129, expression_statement; 129, 130; 130, call; 130, 131; 130, 138; 131, attribute; 131, 132; 131, 137; 132, subscript; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:self; 135, identifier:event_dict; 136, identifier:event_name; 137, identifier:put; 138, argument_list; 138, 139; 139, identifier:event_obj; 140, else_clause; 140, 141; 141, block; 141, 142; 141, 150; 141, 157; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:q; 145, call; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:queue; 148, identifier:Queue; 149, argument_list; 150, expression_statement; 150, 151; 151, call; 151, 152; 151, 155; 152, attribute; 152, 153; 152, 154; 153, identifier:q; 154, identifier:put; 155, argument_list; 155, 156; 156, identifier:event_obj; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 164; 159, subscript; 159, 160; 159, 163; 160, attribute; 160, 161; 160, 162; 161, identifier:self; 162, identifier:event_dict; 163, identifier:event_name; 164, identifier:q; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 172; 167, attribute; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:self; 170, identifier:lock; 171, identifier:release; 172, argument_list
|
def poll_events(self):
while self.started:
event_obj = None
event_name = None
try:
event_obj = self._sl4a.eventWait(50000)
except:
if self.started:
print("Exception happened during polling.")
print(traceback.format_exc())
raise
if not event_obj:
continue
elif 'name' not in event_obj:
print("Received Malformed event {}".format(event_obj))
continue
else:
event_name = event_obj['name']
if event_name in self.handlers:
self.handle_subscribed_event(event_obj, event_name)
if event_name == "EventDispatcherShutdown":
self._sl4a.closeSl4aSession()
break
else:
self.lock.acquire()
if event_name in self.event_dict:
self.event_dict[event_name].put(event_obj)
else:
q = queue.Queue()
q.put(event_obj)
self.event_dict[event_name] = q
self.lock.release()
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:pop_events; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:regex_pattern; 6, identifier:timeout; 7, block; 7, 8; 7, 19; 7, 29; 7, 65; 7, 86; 8, if_statement; 8, 9; 8, 13; 9, not_operator; 9, 10; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:started; 13, block; 13, 14; 14, raise_statement; 14, 15; 15, call; 15, 16; 15, 17; 16, identifier:IllegalStateError; 17, argument_list; 17, 18; 18, string:"Dispatcher needs to be started before popping."; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:deadline; 22, binary_operator:+; 22, 23; 22, 28; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:time; 26, identifier:time; 27, argument_list; 28, identifier:timeout; 29, while_statement; 29, 30; 29, 31; 30, True; 31, block; 31, 32; 31, 41; 31, 58; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:results; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:self; 38, identifier:_match_and_pop; 39, argument_list; 39, 40; 40, identifier:regex_pattern; 41, if_statement; 41, 42; 41, 56; 42, boolean_operator:or; 42, 43; 42, 49; 43, comparison_operator:!=; 43, 44; 43, 48; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:results; 48, integer:0; 49, comparison_operator:>; 49, 50; 49, 55; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:time; 53, identifier:time; 54, argument_list; 55, identifier:deadline; 56, block; 56, 57; 57, break_statement; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:time; 62, identifier:sleep; 63, argument_list; 63, 64; 64, integer:1; 65, if_statement; 65, 66; 65, 72; 66, comparison_operator:==; 66, 67; 66, 71; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, identifier:results; 71, integer:0; 72, block; 72, 73; 73, raise_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:queue; 77, identifier:Empty; 78, argument_list; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, string:'Timeout after {}s waiting for event: {}'; 82, identifier:format; 83, argument_list; 83, 84; 83, 85; 84, identifier:timeout; 85, identifier:regex_pattern; 86, return_statement; 86, 87; 87, call; 87, 88; 87, 89; 88, identifier:sorted; 89, argument_list; 89, 90; 89, 91; 90, identifier:results; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:key; 93, lambda; 93, 94; 93, 96; 94, lambda_parameters; 94, 95; 95, identifier:event; 96, subscript; 96, 97; 96, 98; 97, identifier:event; 98, string:'time'
|
def pop_events(self, regex_pattern, timeout):
if not self.started:
raise IllegalStateError(
"Dispatcher needs to be started before popping.")
deadline = time.time() + timeout
while True:
results = self._match_and_pop(regex_pattern)
if len(results) != 0 or time.time() > deadline:
break
time.sleep(1)
if len(results) == 0:
raise queue.Empty('Timeout after {}s waiting for event: {}'.format(
timeout, regex_pattern))
return sorted(results, key=lambda event: event['time'])
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:children; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:pvector; 9, argument_list; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 12, 20; 13, call; 13, 14; 13, 19; 14, attribute; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:self; 17, identifier:_children; 18, identifier:values; 19, argument_list; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:key; 22, lambda; 22, 23; 22, 25; 23, lambda_parameters; 23, 24; 24, identifier:m; 25, attribute; 25, 26; 25, 27; 26, identifier:m; 27, identifier:task_level
|
def children(self):
return pvector(
sorted(self._children.values(), key=lambda m: m.task_level))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_last_child_with_lineno; 3, parameters; 3, 4; 4, identifier:node; 5, block; 5, 6; 5, 17; 5, 23; 5, 41; 5, 93; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ignored_fields; 9, call; 9, 10; 9, 11; 10, identifier:set; 11, argument_list; 11, 12; 12, list:['ctx', 'decorator_list', 'names', 'returns']; 12, 13; 12, 14; 12, 15; 12, 16; 13, string:'ctx'; 14, string:'decorator_list'; 15, string:'names'; 16, string:'returns'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:fields; 20, attribute; 20, 21; 20, 22; 21, identifier:node; 22, identifier:_fields; 23, if_statement; 23, 24; 23, 31; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:node; 28, attribute; 28, 29; 28, 30; 29, identifier:ast; 30, identifier:Call; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:fields; 35, tuple; 35, 36; 35, 37; 35, 38; 35, 39; 35, 40; 36, string:'func'; 37, string:'args'; 38, string:'starargs'; 39, string:'keywords'; 40, string:'kwargs'; 41, for_statement; 41, 42; 41, 43; 41, 47; 42, identifier:name; 43, call; 43, 44; 43, 45; 44, identifier:reversed; 45, argument_list; 45, 46; 46, identifier:fields; 47, block; 47, 48; 47, 54; 47, 68; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:in; 49, 50; 49, 51; 50, identifier:name; 51, identifier:ignored_fields; 52, block; 52, 53; 53, continue_statement; 54, try_statement; 54, 55; 54, 64; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:last_field; 59, call; 59, 60; 59, 61; 60, identifier:getattr; 61, argument_list; 61, 62; 61, 63; 62, identifier:node; 63, identifier:name; 64, except_clause; 64, 65; 64, 66; 65, identifier:AttributeError; 66, block; 66, 67; 67, continue_statement; 68, if_statement; 68, 69; 68, 76; 68, 79; 69, call; 69, 70; 69, 71; 70, identifier:isinstance; 71, argument_list; 71, 72; 71, 73; 72, identifier:last_field; 73, attribute; 73, 74; 73, 75; 74, identifier:ast; 75, identifier:AST; 76, block; 76, 77; 77, return_statement; 77, 78; 78, identifier:last_field; 79, elif_clause; 79, 80; 79, 87; 80, boolean_operator:and; 80, 81; 80, 86; 81, call; 81, 82; 81, 83; 82, identifier:isinstance; 83, argument_list; 83, 84; 83, 85; 84, identifier:last_field; 85, identifier:list; 86, identifier:last_field; 87, block; 87, 88; 88, return_statement; 88, 89; 89, subscript; 89, 90; 89, 91; 90, identifier:last_field; 91, unary_operator:-; 91, 92; 92, integer:1; 93, return_statement; 93, 94; 94, None
|
def _get_last_child_with_lineno(node):
ignored_fields = set(['ctx', 'decorator_list', 'names', 'returns'])
fields = node._fields
if isinstance(node, ast.Call):
fields = ('func', 'args', 'starargs', 'keywords', 'kwargs')
for name in reversed(fields):
if name in ignored_fields:
continue
try:
last_field = getattr(node, name)
except AttributeError:
continue
if isinstance(last_field, ast.AST):
return last_field
elif isinstance(last_field, list) and last_field:
return last_field[-1]
return None
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_patched_ast; 3, parameters; 3, 4; 3, 5; 4, identifier:source; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sorted_children; 7, False; 8, block; 8, 9; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:patch_ast; 12, argument_list; 12, 13; 12, 19; 12, 20; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:ast; 16, identifier:parse; 17, argument_list; 17, 18; 18, identifier:source; 19, identifier:source; 20, identifier:sorted_children
|
def get_patched_ast(source, sorted_children=False):
return patch_ast(ast.parse(source), source, sorted_children)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:patch_ast; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:node; 5, identifier:source; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sorted_children; 8, False; 9, block; 9, 10; 9, 19; 9, 29; 9, 37; 10, if_statement; 10, 11; 10, 16; 11, call; 11, 12; 11, 13; 12, identifier:hasattr; 13, argument_list; 13, 14; 13, 15; 14, identifier:node; 15, string:'region'; 16, block; 16, 17; 17, return_statement; 17, 18; 18, identifier:node; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:walker; 22, call; 22, 23; 22, 24; 23, identifier:_PatchingASTWalker; 24, argument_list; 24, 25; 24, 26; 25, identifier:source; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:children; 28, identifier:sorted_children; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:ast; 33, identifier:call_for_nodes; 34, argument_list; 34, 35; 34, 36; 35, identifier:node; 36, identifier:walker; 37, return_statement; 37, 38; 38, identifier:node
|
def patch_ast(node, source, sorted_children=False):
if hasattr(node, 'region'):
return node
walker = _PatchingASTWalker(source, children=sorted_children)
ast.call_for_nodes(node, walker)
return node
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:write_ast; 3, parameters; 3, 4; 4, identifier:patched_ast_node; 5, block; 5, 6; 5, 10; 5, 44; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:result; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 15; 11, identifier:child; 12, attribute; 12, 13; 12, 14; 13, identifier:patched_ast_node; 14, identifier:sorted_children; 15, block; 15, 16; 16, if_statement; 16, 17; 16, 24; 16, 35; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:child; 21, attribute; 21, 22; 21, 23; 22, identifier:ast; 23, identifier:AST; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:result; 29, identifier:append; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 33; 32, identifier:write_ast; 33, argument_list; 33, 34; 34, identifier:child; 35, else_clause; 35, 36; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:result; 41, identifier:append; 42, argument_list; 42, 43; 43, identifier:child; 44, return_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, string:''; 48, identifier:join; 49, argument_list; 49, 50; 50, identifier:result
|
def write_ast(patched_ast_node):
result = []
for child in patched_ast_node.sorted_children:
if isinstance(child, ast.AST):
result.append(write_ast(child))
else:
result.append(child)
return ''.join(result)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sorted_proposals; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:proposals; 5, default_parameter; 5, 6; 5, 7; 6, identifier:scopepref; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:typepref; 10, None; 11, block; 11, 12; 11, 21; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:sorter; 15, call; 15, 16; 15, 17; 16, identifier:_ProposalSorter; 17, argument_list; 17, 18; 17, 19; 17, 20; 18, identifier:proposals; 19, identifier:scopepref; 20, identifier:typepref; 21, return_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:sorter; 25, identifier:get_sorted_proposal_list; 26, argument_list
|
def sorted_proposals(proposals, scopepref=None, typepref=None):
sorter = _ProposalSorter(proposals, scopepref, typepref)
return sorter.get_sorted_proposal_list()
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_sorted_proposal_list; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 31; 5, 35; 5, 85; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:proposals; 9, dictionary; 10, for_statement; 10, 11; 10, 12; 10, 15; 11, identifier:proposal; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:proposals; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, call; 17, 18; 17, 29; 18, attribute; 18, 19; 18, 28; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:proposals; 22, identifier:setdefault; 23, argument_list; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:proposal; 26, identifier:scope; 27, list:[]; 28, identifier:append; 29, argument_list; 29, 30; 30, identifier:proposal; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:result; 34, list:[]; 35, for_statement; 35, 36; 35, 37; 35, 40; 36, identifier:scope; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:scopepref; 40, block; 40, 41; 40, 51; 40, 67; 40, 78; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:scope_proposals; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:proposals; 47, identifier:get; 48, argument_list; 48, 49; 48, 50; 49, identifier:scope; 50, list:[]; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:scope_proposals; 54, list_comprehension; 54, 55; 54, 56; 54, 59; 55, identifier:proposal; 56, for_in_clause; 56, 57; 56, 58; 57, identifier:proposal; 58, identifier:scope_proposals; 59, if_clause; 59, 60; 60, comparison_operator:in; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:proposal; 63, identifier:type; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:typerank; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:scope_proposals; 71, identifier:sort; 72, argument_list; 72, 73; 73, keyword_argument; 73, 74; 73, 75; 74, identifier:key; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:_proposal_key; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:result; 82, identifier:extend; 83, argument_list; 83, 84; 84, identifier:scope_proposals; 85, return_statement; 85, 86; 86, identifier:result
|
def get_sorted_proposal_list(self):
proposals = {}
for proposal in self.proposals:
proposals.setdefault(proposal.scope, []).append(proposal)
result = []
for scope in self.scopepref:
scope_proposals = proposals.get(scope, [])
scope_proposals = [proposal for proposal in scope_proposals
if proposal.type in self.typerank]
scope_proposals.sort(key=self._proposal_key)
result.extend(scope_proposals)
return result
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_rank; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:entity; 6, identifier:criteria; 7, default_parameter; 7, 8; 7, 9; 8, identifier:condition; 9, True; 10, block; 10, 11; 10, 25; 10, 31; 10, 42; 10, 55; 10, 61; 10, 92; 10, 106; 10, 113; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:entity; 14, conditional_expression:if; 14, 15; 14, 16; 14, 22; 15, identifier:entity; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:entity; 21, identifier:Projector; 22, attribute; 22, 23; 22, 24; 23, identifier:entity; 24, identifier:reference_entity; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:positions; 28, attribute; 28, 29; 28, 30; 29, identifier:entity; 30, identifier:members_position; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:biggest_entity_size; 34, binary_operator:+; 34, 35; 34, 41; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:np; 38, identifier:max; 39, argument_list; 39, 40; 40, identifier:positions; 41, integer:1; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:filtered_criteria; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:np; 48, identifier:where; 49, argument_list; 49, 50; 49, 51; 49, 52; 50, identifier:condition; 51, identifier:criteria; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:inf; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:ids; 58, attribute; 58, 59; 58, 60; 59, identifier:entity; 60, identifier:members_entity_id; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:matrix; 64, call; 64, 65; 64, 91; 65, attribute; 65, 66; 65, 90; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:np; 69, identifier:asarray; 70, argument_list; 70, 71; 71, list_comprehension; 71, 72; 71, 84; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:entity; 75, identifier:value_nth_person; 76, argument_list; 76, 77; 76, 78; 76, 79; 77, identifier:k; 78, identifier:filtered_criteria; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:default; 81, attribute; 81, 82; 81, 83; 82, identifier:np; 83, identifier:inf; 84, for_in_clause; 84, 85; 84, 86; 85, identifier:k; 86, call; 86, 87; 86, 88; 87, identifier:range; 88, argument_list; 88, 89; 89, identifier:biggest_entity_size; 90, identifier:transpose; 91, argument_list; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:sorted_matrix; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:np; 98, identifier:argsort; 99, argument_list; 99, 100; 100, call; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:np; 103, identifier:argsort; 104, argument_list; 104, 105; 105, identifier:matrix; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:result; 109, subscript; 109, 110; 109, 111; 109, 112; 110, identifier:sorted_matrix; 111, identifier:ids; 112, identifier:positions; 113, return_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:np; 117, identifier:where; 118, argument_list; 118, 119; 118, 120; 118, 121; 119, identifier:condition; 120, identifier:result; 121, unary_operator:-; 121, 122; 122, integer:1
|
def get_rank(self, entity, criteria, condition = True):
entity = entity if not isinstance(entity, Projector) else entity.reference_entity
positions = entity.members_position
biggest_entity_size = np.max(positions) + 1
filtered_criteria = np.where(condition, criteria, np.inf)
ids = entity.members_entity_id
matrix = np.asarray([
entity.value_nth_person(k, filtered_criteria, default = np.inf)
for k in range(biggest_entity_size)
]).transpose()
sorted_matrix = np.argsort(np.argsort(matrix))
result = sorted_matrix[ids, positions]
return np.where(condition, result, -1)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:value_nth_person; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:n; 6, identifier:array; 7, default_parameter; 7, 8; 7, 9; 8, identifier:default; 9, integer:0; 10, block; 10, 11; 10, 20; 10, 26; 10, 34; 10, 40; 10, 54; 10, 70; 11, expression_statement; 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:members; 17, identifier:check_array_compatible_with_entity; 18, argument_list; 18, 19; 19, identifier:array; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:positions; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:members_position; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:nb_persons_per_entity; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:nb_persons; 33, argument_list; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:members_map; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:ordered_members_map; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:result; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:self; 46, identifier:filled_array; 47, argument_list; 47, 48; 47, 49; 48, identifier:default; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:dtype; 51, attribute; 51, 52; 51, 53; 52, identifier:array; 53, identifier:dtype; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 61; 56, subscript; 56, 57; 56, 58; 57, identifier:result; 58, comparison_operator:>; 58, 59; 58, 60; 59, identifier:nb_persons_per_entity; 60, identifier:n; 61, subscript; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:array; 64, identifier:members_map; 65, comparison_operator:==; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:positions; 68, identifier:members_map; 69, identifier:n; 70, return_statement; 70, 71; 71, identifier:result
|
def value_nth_person(self, n, array, default = 0):
self.members.check_array_compatible_with_entity(array)
positions = self.members_position
nb_persons_per_entity = self.nb_persons()
members_map = self.ordered_members_map
result = self.filled_array(default, dtype = array.dtype)
result[nb_persons_per_entity > n] = array[members_map][positions[members_map] == n]
return result
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:create_query_index; 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:design_document_id; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:index_name; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:index_type; 13, string:'json'; 14, default_parameter; 14, 15; 14, 16; 15, identifier:partitioned; 16, False; 17, dictionary_splat_pattern; 17, 18; 18, identifier:kwargs; 19, block; 19, 20; 19, 66; 19, 72; 20, if_statement; 20, 21; 20, 24; 20, 39; 20, 58; 21, comparison_operator:==; 21, 22; 21, 23; 22, identifier:index_type; 23, identifier:JSON_INDEX_TYPE; 24, block; 24, 25; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:index; 28, call; 28, 29; 28, 30; 29, identifier:Index; 30, argument_list; 30, 31; 30, 32; 30, 33; 30, 34; 30, 37; 31, identifier:self; 32, identifier:design_document_id; 33, identifier:index_name; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:partitioned; 36, identifier:partitioned; 37, dictionary_splat; 37, 38; 38, identifier:kwargs; 39, elif_clause; 39, 40; 39, 43; 40, comparison_operator:==; 40, 41; 40, 42; 41, identifier:index_type; 42, identifier:TEXT_INDEX_TYPE; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:index; 47, call; 47, 48; 47, 49; 48, identifier:TextIndex; 49, argument_list; 49, 50; 49, 51; 49, 52; 49, 53; 49, 56; 50, identifier:self; 51, identifier:design_document_id; 52, identifier:index_name; 53, keyword_argument; 53, 54; 53, 55; 54, identifier:partitioned; 55, identifier:partitioned; 56, dictionary_splat; 56, 57; 57, identifier:kwargs; 58, else_clause; 58, 59; 59, block; 59, 60; 60, raise_statement; 60, 61; 61, call; 61, 62; 61, 63; 62, identifier:CloudantArgumentError; 63, argument_list; 63, 64; 63, 65; 64, integer:103; 65, identifier:index_type; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:index; 70, identifier:create; 71, argument_list; 72, return_statement; 72, 73; 73, identifier:index
|
def create_query_index(
self,
design_document_id=None,
index_name=None,
index_type='json',
partitioned=False,
**kwargs
):
if index_type == JSON_INDEX_TYPE:
index = Index(self, design_document_id, index_name,
partitioned=partitioned, **kwargs)
elif index_type == TEXT_INDEX_TYPE:
index = TextIndex(self, design_document_id, index_name,
partitioned=partitioned, **kwargs)
else:
raise CloudantArgumentError(103, index_type)
index.create()
return index
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_search_result; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:ddoc_id; 6, identifier:index_name; 7, dictionary_splat_pattern; 7, 8; 8, identifier:query_params; 9, block; 9, 10; 9, 18; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:ddoc; 13, call; 13, 14; 13, 15; 14, identifier:DesignDocument; 15, argument_list; 15, 16; 15, 17; 16, identifier:self; 17, identifier:ddoc_id; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_get_search_result; 23, argument_list; 23, 24; 23, 35; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, string:'/'; 27, identifier:join; 28, argument_list; 28, 29; 29, tuple; 29, 30; 29, 33; 29, 34; 30, attribute; 30, 31; 30, 32; 31, identifier:ddoc; 32, identifier:document_url; 33, string:'_search'; 34, identifier:index_name; 35, dictionary_splat; 35, 36; 36, identifier:query_params
|
def get_search_result(self, ddoc_id, index_name, **query_params):
ddoc = DesignDocument(self, ddoc_id)
return self._get_search_result(
'/'.join((ddoc.document_url, '_search', index_name)),
**query_params
)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:predict_log_proba; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:X; 6, block; 6, 7; 6, 16; 6, 26; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:jll; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_joint_log_likelihood; 14, argument_list; 14, 15; 15, identifier:X; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:log_prob_x; 19, call; 19, 20; 19, 21; 20, identifier:logsumexp; 21, argument_list; 21, 22; 21, 23; 22, identifier:jll; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:axis; 25, integer:1; 26, return_statement; 26, 27; 27, binary_operator:-; 27, 28; 27, 29; 28, identifier:jll; 29, attribute; 29, 30; 29, 36; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:np; 33, identifier:atleast_2d; 34, argument_list; 34, 35; 35, identifier:log_prob_x; 36, identifier:T
|
def predict_log_proba(self, X):
jll = self._joint_log_likelihood(X)
log_prob_x = logsumexp(jll, axis=1)
return jll - np.atleast_2d(log_prob_x).T
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_get_sorting_key_values; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:array1; 6, identifier:array2; 7, block; 7, 8; 7, 19; 7, 28; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:concat_arrays; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:numpy; 14, identifier:concatenate; 15, argument_list; 15, 16; 16, list:[array1, array2]; 16, 17; 16, 18; 17, identifier:array1; 18, identifier:array2; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:unique_values; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:numpy; 25, identifier:unique; 26, argument_list; 26, 27; 27, identifier:concat_arrays; 28, return_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:numpy; 32, identifier:sort; 33, argument_list; 33, 34; 34, identifier:unique_values
|
def _get_sorting_key_values(self, array1, array2):
concat_arrays = numpy.concatenate([array1, array2])
unique_values = numpy.unique(concat_arrays)
return numpy.sort(unique_values)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sortedneighbourhood; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 20; 9, 27; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:indexer; 13, call; 13, 14; 13, 15; 14, identifier:SortedNeighbourhood; 15, argument_list; 15, 16; 15, 18; 16, list_splat; 16, 17; 17, identifier:args; 18, dictionary_splat; 18, 19; 19, identifier:kwargs; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:add; 25, argument_list; 25, 26; 26, identifier:indexer; 27, return_statement; 27, 28; 28, identifier:self
|
def sortedneighbourhood(self, *args, **kwargs):
indexer = SortedNeighbourhood(*args, **kwargs)
self.add(indexer)
return self
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_build_bst_from_sorted_values; 3, parameters; 3, 4; 4, identifier:sorted_values; 5, block; 5, 6; 5, 16; 5, 25; 5, 34; 5, 47; 5, 62; 6, if_statement; 6, 7; 6, 13; 7, comparison_operator:==; 7, 8; 7, 12; 8, call; 8, 9; 8, 10; 9, identifier:len; 10, argument_list; 10, 11; 11, identifier:sorted_values; 12, integer:0; 13, block; 13, 14; 14, return_statement; 14, 15; 15, None; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:mid_index; 19, binary_operator://; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, identifier:sorted_values; 24, integer:2; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:root; 28, call; 28, 29; 28, 30; 29, identifier:Node; 30, argument_list; 30, 31; 31, subscript; 31, 32; 31, 33; 32, identifier:sorted_values; 33, identifier:mid_index; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:root; 38, identifier:left; 39, call; 39, 40; 39, 41; 40, identifier:_build_bst_from_sorted_values; 41, argument_list; 41, 42; 42, subscript; 42, 43; 42, 44; 43, identifier:sorted_values; 44, slice; 44, 45; 44, 46; 45, colon; 46, identifier:mid_index; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:root; 51, identifier:right; 52, call; 52, 53; 52, 54; 53, identifier:_build_bst_from_sorted_values; 54, argument_list; 54, 55; 55, subscript; 55, 56; 55, 57; 56, identifier:sorted_values; 57, slice; 57, 58; 57, 61; 58, binary_operator:+; 58, 59; 58, 60; 59, identifier:mid_index; 60, integer:1; 61, colon; 62, return_statement; 62, 63; 63, identifier:root
|
def _build_bst_from_sorted_values(sorted_values):
if len(sorted_values) == 0:
return None
mid_index = len(sorted_values) // 2
root = Node(sorted_values[mid_index])
root.left = _build_bst_from_sorted_values(sorted_values[:mid_index])
root.right = _build_bst_from_sorted_values(sorted_values[mid_index + 1:])
return root
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:holm; 3, parameters; 3, 4; 3, 5; 4, identifier:pvals; 5, default_parameter; 5, 6; 5, 7; 6, identifier:alpha; 7, float:.05; 8, block; 8, 9; 8, 18; 8, 24; 8, 32; 8, 45; 8, 54; 8, 60; 8, 68; 8, 76; 8, 98; 8, 109; 8, 120; 8, 138; 8, 149; 8, 171; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:pvals; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:np; 15, identifier:asarray; 16, argument_list; 16, 17; 17, identifier:pvals; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:shape_init; 21, attribute; 21, 22; 21, 23; 22, identifier:pvals; 23, identifier:shape; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:pvals; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:pvals; 30, identifier:ravel; 31, argument_list; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:num_nan; 35, call; 35, 36; 35, 44; 36, attribute; 36, 37; 36, 43; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:np; 40, identifier:isnan; 41, argument_list; 41, 42; 42, identifier:pvals; 43, identifier:sum; 44, argument_list; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:pvals_sortind; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:np; 51, identifier:argsort; 52, argument_list; 52, 53; 53, identifier:pvals; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:pvals_sorted; 57, subscript; 57, 58; 57, 59; 58, identifier:pvals; 59, identifier:pvals_sortind; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:sortrevind; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:pvals_sortind; 66, identifier:argsort; 67, argument_list; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:ntests; 71, binary_operator:-; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:pvals; 74, identifier:size; 75, identifier:num_nan; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:pvals_corr; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:diag; 83, argument_list; 83, 84; 84, binary_operator:*; 84, 85; 84, 86; 85, identifier:pvals_sorted; 86, subscript; 86, 87; 86, 96; 86, 97; 87, call; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:np; 90, identifier:arange; 91, argument_list; 91, 92; 91, 93; 91, 94; 92, identifier:ntests; 93, integer:0; 94, unary_operator:-; 94, 95; 95, integer:1; 96, ellipsis:...; 97, None; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:pvals_corr; 101, call; 101, 102; 101, 107; 102, attribute; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:np; 105, identifier:maximum; 106, identifier:accumulate; 107, argument_list; 107, 108; 108, identifier:pvals_corr; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:pvals_corr; 112, call; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:np; 115, identifier:clip; 116, argument_list; 116, 117; 116, 118; 116, 119; 117, identifier:pvals_corr; 118, None; 119, integer:1; 120, expression_statement; 120, 121; 121, assignment; 121, 122; 121, 123; 122, identifier:pvals_corr; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:np; 126, identifier:append; 127, argument_list; 127, 128; 127, 129; 128, identifier:pvals_corr; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:np; 132, identifier:full; 133, argument_list; 133, 134; 133, 135; 134, identifier:num_nan; 135, attribute; 135, 136; 135, 137; 136, identifier:np; 137, identifier:nan; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:pvals_corrected; 141, call; 141, 142; 141, 147; 142, attribute; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:pvals_corr; 145, identifier:sortrevind; 146, identifier:reshape; 147, argument_list; 147, 148; 148, identifier:shape_init; 149, with_statement; 149, 150; 149, 160; 150, with_clause; 150, 151; 151, with_item; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:np; 155, identifier:errstate; 156, argument_list; 156, 157; 157, keyword_argument; 157, 158; 157, 159; 158, identifier:invalid; 159, string:'ignore'; 160, block; 160, 161; 161, expression_statement; 161, 162; 162, assignment; 162, 163; 162, 164; 163, identifier:reject; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:np; 167, identifier:less; 168, argument_list; 168, 169; 168, 170; 169, identifier:pvals_corrected; 170, identifier:alpha; 171, return_statement; 171, 172; 172, expression_list; 172, 173; 172, 174; 173, identifier:reject; 174, identifier:pvals_corrected
|
def holm(pvals, alpha=.05):
pvals = np.asarray(pvals)
shape_init = pvals.shape
pvals = pvals.ravel()
num_nan = np.isnan(pvals).sum()
pvals_sortind = np.argsort(pvals)
pvals_sorted = pvals[pvals_sortind]
sortrevind = pvals_sortind.argsort()
ntests = pvals.size - num_nan
pvals_corr = np.diag(pvals_sorted * np.arange(ntests, 0, -1)[..., None])
pvals_corr = np.maximum.accumulate(pvals_corr)
pvals_corr = np.clip(pvals_corr, None, 1)
pvals_corr = np.append(pvals_corr, np.full(num_nan, np.nan))
pvals_corrected = pvals_corr[sortrevind].reshape(shape_init)
with np.errstate(invalid='ignore'):
reject = np.less(pvals_corrected, alpha)
return reject, pvals_corrected
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_reverse_chronologically; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 13; 8, attribute; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:measurements; 12, identifier:sort; 13, argument_list; 13, 14; 13, 22; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:key; 16, lambda; 16, 17; 16, 19; 17, lambda_parameters; 17, 18; 18, identifier:m; 19, attribute; 19, 20; 19, 21; 20, identifier:m; 21, identifier:timestamp; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:reverse; 24, True
|
def sort_reverse_chronologically(self):
self.measurements.sort(key=lambda m: m.timestamp, reverse=True)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:sorted_dependencies; 3, parameters; 3, 4; 3, 5; 4, identifier:dist; 5, default_parameter; 5, 6; 5, 7; 6, identifier:reverse; 7, False; 8, block; 8, 9; 8, 14; 8, 19; 8, 24; 8, 28; 8, 33; 8, 107; 8, 113; 8, 119; 8, 191; 8, 205; 8, 219; 9, import_from_statement; 9, 10; 9, 12; 10, relative_import; 10, 11; 11, import_prefix; 12, dotted_name; 12, 13; 13, identifier:baseclass; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:collection; 17, list:[dist]; 17, 18; 18, identifier:dist; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:nodes; 22, list:[dist]; 22, 23; 23, identifier:dist; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:edges; 27, list:[]; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:pool; 31, list:[dist]; 31, 32; 32, identifier:dist; 33, while_statement; 33, 34; 33, 35; 34, identifier:pool; 35, block; 35, 36; 35, 44; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:dist; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:pool; 42, identifier:pop; 43, argument_list; 44, for_statement; 44, 45; 44, 46; 44, 52; 45, identifier:key; 46, call; 46, 47; 46, 48; 47, identifier:sorted; 48, argument_list; 48, 49; 49, attribute; 49, 50; 49, 51; 50, identifier:dist; 51, identifier:prm; 52, block; 52, 53; 52, 61; 52, 72; 52, 88; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:value; 56, subscript; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:dist; 59, identifier:prm; 60, identifier:key; 61, if_statement; 61, 62; 61, 70; 62, not_operator; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:isinstance; 65, argument_list; 65, 66; 65, 67; 66, identifier:value; 67, attribute; 67, 68; 67, 69; 68, identifier:baseclass; 69, identifier:Dist; 70, block; 70, 71; 71, continue_statement; 72, if_statement; 72, 73; 72, 78; 73, comparison_operator:not; 73, 74; 73, 77; 74, tuple; 74, 75; 74, 76; 75, identifier:dist; 76, identifier:value; 77, identifier:edges; 78, block; 78, 79; 79, expression_statement; 79, 80; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:edges; 83, identifier:append; 84, argument_list; 84, 85; 85, tuple; 85, 86; 85, 87; 86, identifier:dist; 87, identifier:value; 88, if_statement; 88, 89; 88, 92; 89, comparison_operator:not; 89, 90; 89, 91; 90, identifier:value; 91, identifier:nodes; 92, block; 92, 93; 92, 100; 93, expression_statement; 93, 94; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:nodes; 97, identifier:append; 98, argument_list; 98, 99; 99, identifier:value; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:pool; 104, identifier:append; 105, argument_list; 105, 106; 106, identifier:value; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:permanent_marks; 110, call; 110, 111; 110, 112; 111, identifier:set; 112, argument_list; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:temporary_marks; 116, call; 116, 117; 116, 118; 117, identifier:set; 118, argument_list; 119, function_definition; 119, 120; 119, 121; 119, 123; 120, function_name:visit; 121, parameters; 121, 122; 122, identifier:node; 123, block; 123, 124; 123, 130; 123, 140; 123, 147; 123, 154; 123, 170; 123, 177; 123, 184; 124, if_statement; 124, 125; 124, 128; 125, comparison_operator:in; 125, 126; 125, 127; 126, identifier:node; 127, identifier:permanent_marks; 128, block; 128, 129; 129, return_statement; 130, if_statement; 130, 131; 130, 134; 131, comparison_operator:in; 131, 132; 131, 133; 132, identifier:node; 133, identifier:temporary_marks; 134, block; 134, 135; 135, raise_statement; 135, 136; 136, call; 136, 137; 136, 138; 137, identifier:DependencyError; 138, argument_list; 138, 139; 139, string:"cycles in dependency structure."; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:nodes; 144, identifier:remove; 145, argument_list; 145, 146; 146, identifier:node; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:temporary_marks; 151, identifier:add; 152, argument_list; 152, 153; 153, identifier:node; 154, for_statement; 154, 155; 154, 158; 154, 159; 155, pattern_list; 155, 156; 155, 157; 156, identifier:node1; 157, identifier:node2; 158, identifier:edges; 159, block; 159, 160; 160, if_statement; 160, 161; 160, 164; 161, comparison_operator:is; 161, 162; 161, 163; 162, identifier:node1; 163, identifier:node; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 168; 167, identifier:visit; 168, argument_list; 168, 169; 169, identifier:node2; 170, expression_statement; 170, 171; 171, call; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:temporary_marks; 174, identifier:remove; 175, argument_list; 175, 176; 176, identifier:node; 177, expression_statement; 177, 178; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:permanent_marks; 181, identifier:add; 182, argument_list; 182, 183; 183, identifier:node; 184, expression_statement; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:pool; 188, identifier:append; 189, argument_list; 189, 190; 190, identifier:node; 191, while_statement; 191, 192; 191, 193; 192, identifier:nodes; 193, block; 193, 194; 193, 200; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:node; 197, subscript; 197, 198; 197, 199; 198, identifier:nodes; 199, integer:0; 200, expression_statement; 200, 201; 201, call; 201, 202; 201, 203; 202, identifier:visit; 203, argument_list; 203, 204; 204, identifier:node; 205, if_statement; 205, 206; 205, 208; 206, not_operator; 206, 207; 207, identifier:reverse; 208, block; 208, 209; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:pool; 212, call; 212, 213; 212, 214; 213, identifier:list; 214, argument_list; 214, 215; 215, call; 215, 216; 215, 217; 216, identifier:reversed; 217, argument_list; 217, 218; 218, identifier:pool; 219, return_statement; 219, 220; 220, identifier:pool
|
def sorted_dependencies(dist, reverse=False):
from .. import baseclass
collection = [dist]
nodes = [dist]
edges = []
pool = [dist]
while pool:
dist = pool.pop()
for key in sorted(dist.prm):
value = dist.prm[key]
if not isinstance(value, baseclass.Dist):
continue
if (dist, value) not in edges:
edges.append((dist, value))
if value not in nodes:
nodes.append(value)
pool.append(value)
permanent_marks = set()
temporary_marks = set()
def visit(node):
if node in permanent_marks:
return
if node in temporary_marks:
raise DependencyError("cycles in dependency structure.")
nodes.remove(node)
temporary_marks.add(node)
for node1, node2 in edges:
if node1 is node:
visit(node2)
temporary_marks.remove(node)
permanent_marks.add(node)
pool.append(node)
while nodes:
node = nodes[0]
visit(node)
if not reverse:
pool = list(reversed(pool))
return pool
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:orth_ttr; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:order; 5, identifier:dist; 6, default_parameter; 6, 7; 6, 8; 7, identifier:normed; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, string:"GR"; 12, default_parameter; 12, 13; 12, 14; 13, identifier:retall; 14, False; 15, default_parameter; 15, 16; 15, 17; 16, identifier:cross_truncation; 17, float:1.; 18, dictionary_splat_pattern; 18, 19; 19, identifier:kws; 20, block; 20, 21; 20, 51; 20, 86; 20, 93; 20, 215; 20, 233; 20, 245; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 28; 23, pattern_list; 23, 24; 23, 25; 23, 26; 23, 27; 24, identifier:polynomials; 25, identifier:norms; 26, identifier:_; 27, identifier:_; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:chaospy; 32, identifier:quad; 33, identifier:generate_stieltjes; 34, argument_list; 34, 35; 34, 38; 34, 46; 34, 49; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:dist; 37, identifier:dist; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:order; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:numpy; 43, identifier:max; 44, argument_list; 44, 45; 45, identifier:order; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:retall; 48, True; 49, dictionary_splat; 49, 50; 50, identifier:kws; 51, if_statement; 51, 52; 51, 53; 52, identifier:normed; 53, block; 53, 54; 53, 80; 54, for_statement; 54, 55; 54, 58; 54, 62; 55, pattern_list; 55, 56; 55, 57; 56, identifier:idx; 57, identifier:poly; 58, call; 58, 59; 58, 60; 59, identifier:enumerate; 60, argument_list; 60, 61; 61, identifier:polynomials; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:polynomials; 67, identifier:idx; 68, binary_operator:/; 68, 69; 68, 70; 69, identifier:poly; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:numpy; 73, identifier:sqrt; 74, argument_list; 74, 75; 75, subscript; 75, 76; 75, 77; 75, 79; 76, identifier:norms; 77, slice; 77, 78; 78, colon; 79, identifier:idx; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:norms; 83, binary_operator:**; 83, 84; 83, 85; 84, identifier:norms; 85, integer:0; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:dim; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:dist; 93, if_statement; 93, 94; 93, 97; 93, 203; 94, comparison_operator:>; 94, 95; 94, 96; 95, identifier:dim; 96, integer:1; 97, block; 97, 98; 97, 102; 97, 106; 97, 131; 97, 172; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 101; 100, identifier:mv_polynomials; 101, list:[]; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:mv_norms; 105, list:[]; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:indices; 109, call; 109, 110; 109, 115; 110, attribute; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:chaospy; 113, identifier:bertran; 114, identifier:bindex; 115, argument_list; 115, 116; 115, 119; 115, 122; 115, 125; 115, 128; 116, keyword_argument; 116, 117; 116, 118; 117, identifier:start; 118, integer:0; 119, keyword_argument; 119, 120; 119, 121; 120, identifier:stop; 121, identifier:order; 122, keyword_argument; 122, 123; 122, 124; 123, identifier:dim; 124, identifier:dim; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:sort; 127, identifier:sort; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:cross_truncation; 130, identifier:cross_truncation; 131, for_statement; 131, 132; 131, 133; 131, 134; 132, identifier:index; 133, identifier:indices; 134, block; 134, 135; 134, 145; 134, 165; 135, expression_statement; 135, 136; 136, assignment; 136, 137; 136, 138; 137, identifier:poly; 138, subscript; 138, 139; 138, 144; 139, subscript; 139, 140; 139, 141; 140, identifier:polynomials; 141, subscript; 141, 142; 141, 143; 142, identifier:index; 143, integer:0; 144, integer:0; 145, for_statement; 145, 146; 145, 147; 145, 152; 146, identifier:idx; 147, call; 147, 148; 147, 149; 148, identifier:range; 149, argument_list; 149, 150; 149, 151; 150, integer:1; 151, identifier:dim; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:poly; 156, binary_operator:*; 156, 157; 156, 158; 157, identifier:poly; 158, subscript; 158, 159; 158, 164; 159, subscript; 159, 160; 159, 161; 160, identifier:polynomials; 161, subscript; 161, 162; 161, 163; 162, identifier:index; 163, identifier:idx; 164, identifier:idx; 165, expression_statement; 165, 166; 166, call; 166, 167; 166, 170; 167, attribute; 167, 168; 167, 169; 168, identifier:mv_polynomials; 169, identifier:append; 170, argument_list; 170, 171; 171, identifier:poly; 172, if_statement; 172, 173; 172, 174; 173, identifier:retall; 174, block; 174, 175; 175, for_statement; 175, 176; 175, 177; 175, 178; 176, identifier:index; 177, identifier:indices; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, call; 180, 181; 180, 184; 181, attribute; 181, 182; 181, 183; 182, identifier:mv_norms; 183, identifier:append; 184, argument_list; 184, 185; 185, call; 185, 186; 185, 189; 186, attribute; 186, 187; 186, 188; 187, identifier:numpy; 188, identifier:prod; 189, argument_list; 189, 190; 190, list_comprehension; 190, 191; 190, 197; 191, subscript; 191, 192; 191, 193; 191, 194; 192, identifier:norms; 193, identifier:idx; 194, subscript; 194, 195; 194, 196; 195, identifier:index; 196, identifier:idx; 197, for_in_clause; 197, 198; 197, 199; 198, identifier:idx; 199, call; 199, 200; 199, 201; 200, identifier:range; 201, argument_list; 201, 202; 202, identifier:dim; 203, else_clause; 203, 204; 204, block; 204, 205; 204, 211; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:mv_norms; 208, subscript; 208, 209; 208, 210; 209, identifier:norms; 210, integer:0; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:mv_polynomials; 214, identifier:polynomials; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:polynomials; 218, call; 218, 219; 218, 224; 219, attribute; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:chaospy; 222, identifier:poly; 223, identifier:flatten; 224, argument_list; 224, 225; 225, call; 225, 226; 225, 231; 226, attribute; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:chaospy; 229, identifier:poly; 230, identifier:Poly; 231, argument_list; 231, 232; 232, identifier:mv_polynomials; 233, if_statement; 233, 234; 233, 235; 234, identifier:retall; 235, block; 235, 236; 236, return_statement; 236, 237; 237, expression_list; 237, 238; 237, 239; 238, identifier:polynomials; 239, call; 239, 240; 239, 243; 240, attribute; 240, 241; 240, 242; 241, identifier:numpy; 242, identifier:array; 243, argument_list; 243, 244; 244, identifier:mv_norms; 245, return_statement; 245, 246; 246, identifier:polynomials
|
def orth_ttr(
order, dist, normed=False, sort="GR", retall=False,
cross_truncation=1., **kws):
polynomials, norms, _, _ = chaospy.quad.generate_stieltjes(
dist=dist, order=numpy.max(order), retall=True, **kws)
if normed:
for idx, poly in enumerate(polynomials):
polynomials[idx] = poly / numpy.sqrt(norms[:, idx])
norms = norms**0
dim = len(dist)
if dim > 1:
mv_polynomials = []
mv_norms = []
indices = chaospy.bertran.bindex(
start=0, stop=order, dim=dim, sort=sort,
cross_truncation=cross_truncation,
)
for index in indices:
poly = polynomials[index[0]][0]
for idx in range(1, dim):
poly = poly * polynomials[index[idx]][idx]
mv_polynomials.append(poly)
if retall:
for index in indices:
mv_norms.append(
numpy.prod([norms[idx, index[idx]] for idx in range(dim)]))
else:
mv_norms = norms[0]
mv_polynomials = polynomials
polynomials = chaospy.poly.flatten(chaospy.poly.Poly(mv_polynomials))
if retall:
return polynomials, numpy.array(mv_norms)
return polynomials
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:orth_chol; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:order; 5, identifier:dist; 6, default_parameter; 6, 7; 6, 8; 7, identifier:normed; 8, True; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, string:"GR"; 12, default_parameter; 12, 13; 12, 14; 13, identifier:cross_truncation; 14, float:1.; 15, dictionary_splat_pattern; 15, 16; 16, identifier:kws; 17, block; 17, 18; 17, 25; 17, 50; 17, 57; 17, 76; 17, 91; 17, 124; 17, 139; 17, 150; 17, 157; 17, 166; 17, 190; 17, 199; 17, 205; 17, 209; 17, 220; 17, 247; 17, 267; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:dim; 21, call; 21, 22; 21, 23; 22, identifier:len; 23, argument_list; 23, 24; 24, identifier:dist; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:basis; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:chaospy; 32, identifier:poly; 33, identifier:basis; 34, argument_list; 34, 35; 34, 38; 34, 41; 34, 44; 34, 47; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:start; 37, integer:1; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:stop; 40, identifier:order; 41, keyword_argument; 41, 42; 41, 43; 42, identifier:dim; 43, identifier:dim; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:sort; 46, identifier:sort; 47, keyword_argument; 47, 48; 47, 49; 48, identifier:cross_truncation; 49, identifier:cross_truncation; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:length; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:basis; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:cholmat; 60, call; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:chaospy; 64, identifier:chol; 65, identifier:gill_king; 66, argument_list; 66, 67; 67, call; 67, 68; 67, 73; 68, attribute; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:chaospy; 71, identifier:descriptives; 72, identifier:Cov; 73, argument_list; 73, 74; 73, 75; 74, identifier:basis; 75, identifier:dist; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:cholmat_inv; 79, attribute; 79, 80; 79, 90; 80, call; 80, 81; 80, 86; 81, attribute; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:numpy; 84, identifier:linalg; 85, identifier:inv; 86, argument_list; 86, 87; 87, attribute; 87, 88; 87, 89; 88, identifier:cholmat; 89, identifier:T; 90, identifier:T; 91, if_statement; 91, 92; 91, 94; 92, not_operator; 92, 93; 93, identifier:normed; 94, block; 94, 95; 94, 113; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:diag_mesh; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:numpy; 101, identifier:repeat; 102, argument_list; 102, 103; 102, 109; 103, call; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:numpy; 106, identifier:diag; 107, argument_list; 107, 108; 108, identifier:cholmat_inv; 109, call; 109, 110; 109, 111; 110, identifier:len; 111, argument_list; 111, 112; 112, identifier:cholmat_inv; 113, expression_statement; 113, 114; 114, augmented_assignment:/=; 114, 115; 114, 116; 115, identifier:cholmat_inv; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:diag_mesh; 119, identifier:reshape; 120, argument_list; 120, 121; 121, attribute; 121, 122; 121, 123; 122, identifier:cholmat_inv; 123, identifier:shape; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:coefs; 127, call; 127, 128; 127, 131; 128, attribute; 128, 129; 128, 130; 129, identifier:numpy; 130, identifier:empty; 131, argument_list; 131, 132; 132, tuple; 132, 133; 132, 136; 133, binary_operator:+; 133, 134; 133, 135; 134, identifier:length; 135, integer:1; 136, binary_operator:+; 136, 137; 136, 138; 137, identifier:length; 138, integer:1; 139, expression_statement; 139, 140; 140, assignment; 140, 141; 140, 149; 141, subscript; 141, 142; 141, 143; 141, 146; 142, identifier:coefs; 143, slice; 143, 144; 143, 145; 144, integer:1; 145, colon; 146, slice; 146, 147; 146, 148; 147, integer:1; 148, colon; 149, identifier:cholmat_inv; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 156; 152, subscript; 152, 153; 152, 154; 152, 155; 153, identifier:coefs; 154, integer:0; 155, integer:0; 156, integer:1; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 165; 159, subscript; 159, 160; 159, 161; 159, 162; 160, identifier:coefs; 161, integer:0; 162, slice; 162, 163; 162, 164; 163, integer:1; 164, colon; 165, integer:0; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:expected; 169, unary_operator:-; 169, 170; 170, call; 170, 171; 170, 174; 171, attribute; 171, 172; 171, 173; 172, identifier:numpy; 173, identifier:sum; 174, argument_list; 174, 175; 174, 188; 175, binary_operator:*; 175, 176; 175, 177; 176, identifier:cholmat_inv; 177, call; 177, 178; 177, 183; 178, attribute; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:chaospy; 181, identifier:descriptives; 182, identifier:E; 183, argument_list; 183, 184; 183, 185; 183, 186; 184, identifier:basis; 185, identifier:dist; 186, dictionary_splat; 186, 187; 187, identifier:kws; 188, unary_operator:-; 188, 189; 189, integer:1; 190, expression_statement; 190, 191; 191, assignment; 191, 192; 191, 198; 192, subscript; 192, 193; 192, 194; 192, 197; 193, identifier:coefs; 194, slice; 194, 195; 194, 196; 195, integer:1; 196, colon; 197, integer:0; 198, identifier:expected; 199, expression_statement; 199, 200; 200, assignment; 200, 201; 200, 202; 201, identifier:coefs; 202, attribute; 202, 203; 202, 204; 203, identifier:coefs; 204, identifier:T; 205, expression_statement; 205, 206; 206, assignment; 206, 207; 206, 208; 207, identifier:out; 208, dictionary; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 217; 211, subscript; 211, 212; 211, 213; 212, identifier:out; 213, binary_operator:*; 213, 214; 213, 216; 214, tuple; 214, 215; 215, integer:0; 216, identifier:dim; 217, subscript; 217, 218; 217, 219; 218, identifier:coefs; 219, integer:0; 220, for_statement; 220, 221; 220, 222; 220, 226; 221, identifier:idx; 222, call; 222, 223; 222, 224; 223, identifier:range; 224, argument_list; 224, 225; 225, identifier:length; 226, block; 226, 227; 226, 237; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:index; 230, subscript; 230, 231; 230, 236; 231, attribute; 231, 232; 231, 235; 232, subscript; 232, 233; 232, 234; 233, identifier:basis; 234, identifier:idx; 235, identifier:keys; 236, integer:0; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:out; 241, identifier:index; 242, subscript; 242, 243; 242, 244; 243, identifier:coefs; 244, binary_operator:+; 244, 245; 244, 246; 245, identifier:idx; 246, integer:1; 247, expression_statement; 247, 248; 248, assignment; 248, 249; 248, 250; 249, identifier:polynomials; 250, call; 250, 251; 250, 256; 251, attribute; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:chaospy; 254, identifier:poly; 255, identifier:Poly; 256, argument_list; 256, 257; 256, 258; 256, 259; 256, 266; 257, identifier:out; 258, identifier:dim; 259, subscript; 259, 260; 259, 263; 260, attribute; 260, 261; 260, 262; 261, identifier:coefs; 262, identifier:shape; 263, slice; 263, 264; 263, 265; 264, integer:1; 265, colon; 266, identifier:float; 267, return_statement; 267, 268; 268, identifier:polynomials
|
def orth_chol(order, dist, normed=True, sort="GR", cross_truncation=1., **kws):
dim = len(dist)
basis = chaospy.poly.basis(
start=1, stop=order, dim=dim, sort=sort,
cross_truncation=cross_truncation,
)
length = len(basis)
cholmat = chaospy.chol.gill_king(chaospy.descriptives.Cov(basis, dist))
cholmat_inv = numpy.linalg.inv(cholmat.T).T
if not normed:
diag_mesh = numpy.repeat(numpy.diag(cholmat_inv), len(cholmat_inv))
cholmat_inv /= diag_mesh.reshape(cholmat_inv.shape)
coefs = numpy.empty((length+1, length+1))
coefs[1:, 1:] = cholmat_inv
coefs[0, 0] = 1
coefs[0, 1:] = 0
expected = -numpy.sum(
cholmat_inv*chaospy.descriptives.E(basis, dist, **kws), -1)
coefs[1:, 0] = expected
coefs = coefs.T
out = {}
out[(0,)*dim] = coefs[0]
for idx in range(length):
index = basis[idx].keys[0]
out[index] = coefs[idx+1]
polynomials = chaospy.poly.Poly(out, dim, coefs.shape[1:], float)
return polynomials
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_key; 3, parameters; 3, 4; 4, identifier:val; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:numpy; 10, identifier:sum; 11, argument_list; 11, 12; 12, binary_operator:*; 12, 13; 12, 36; 13, binary_operator:**; 13, 14; 13, 21; 14, parenthesized_expression; 14, 15; 15, binary_operator:+; 15, 16; 15, 20; 16, call; 16, 17; 16, 18; 17, identifier:max; 18, argument_list; 18, 19; 19, identifier:val; 20, integer:1; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:numpy; 24, identifier:arange; 25, argument_list; 25, 26; 25, 32; 25, 34; 26, binary_operator:-; 26, 27; 26, 31; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, identifier:val; 31, integer:1; 32, unary_operator:-; 32, 33; 33, integer:1; 34, unary_operator:-; 34, 35; 35, integer:1; 36, identifier:val
|
def sort_key(val):
return numpy.sum((max(val)+1)**numpy.arange(len(val)-1, -1, -1)*val)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:orth_gs; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 4, identifier:order; 5, identifier:dist; 6, default_parameter; 6, 7; 6, 8; 7, identifier:normed; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort; 11, string:"GR"; 12, default_parameter; 12, 13; 12, 14; 13, identifier:cross_truncation; 14, float:1.; 15, dictionary_splat_pattern; 15, 16; 16, identifier:kws; 17, block; 17, 18; 17, 27; 17, 34; 17, 81; 17, 88; 17, 95; 17, 318; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:logger; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:logging; 24, identifier:getLogger; 25, argument_list; 25, 26; 26, identifier:__name__; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:dim; 30, call; 30, 31; 30, 32; 31, identifier:len; 32, argument_list; 32, 33; 33, identifier:dist; 34, if_statement; 34, 35; 34, 40; 34, 75; 35, call; 35, 36; 35, 37; 36, identifier:isinstance; 37, argument_list; 37, 38; 37, 39; 38, identifier:order; 39, identifier:int; 40, block; 40, 41; 40, 58; 41, if_statement; 41, 42; 41, 45; 42, comparison_operator:==; 42, 43; 42, 44; 43, identifier:order; 44, integer:0; 45, block; 45, 46; 46, return_statement; 46, 47; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:chaospy; 51, identifier:poly; 52, identifier:Poly; 53, argument_list; 53, 54; 53, 55; 54, integer:1; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:dim; 57, identifier:dim; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:basis; 61, call; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:chaospy; 65, identifier:poly; 66, identifier:basis; 67, argument_list; 67, 68; 67, 69; 67, 70; 67, 71; 67, 72; 68, integer:0; 69, identifier:order; 70, identifier:dim; 71, identifier:sort; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:cross_truncation; 74, identifier:cross_truncation; 75, else_clause; 75, 76; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:basis; 80, identifier:order; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:basis; 84, call; 84, 85; 84, 86; 85, identifier:list; 86, argument_list; 86, 87; 87, identifier:basis; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:polynomials; 91, list:[basis[0]]; 91, 92; 92, subscript; 92, 93; 92, 94; 93, identifier:basis; 94, integer:0; 95, if_statement; 95, 96; 95, 97; 95, 207; 96, identifier:normed; 97, block; 97, 98; 98, for_statement; 98, 99; 98, 100; 98, 108; 99, identifier:idx; 100, call; 100, 101; 100, 102; 101, identifier:range; 102, argument_list; 102, 103; 102, 104; 103, integer:1; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, identifier:basis; 108, block; 108, 109; 108, 150; 108, 169; 108, 183; 108, 198; 109, for_statement; 109, 110; 109, 111; 109, 115; 110, identifier:idy; 111, call; 111, 112; 111, 113; 112, identifier:range; 113, argument_list; 113, 114; 114, identifier:idx; 115, block; 115, 116; 115, 136; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:orth; 119, call; 119, 120; 119, 125; 120, attribute; 120, 121; 120, 124; 121, attribute; 121, 122; 121, 123; 122, identifier:chaospy; 123, identifier:descriptives; 124, identifier:E; 125, argument_list; 125, 126; 125, 133; 125, 134; 126, binary_operator:*; 126, 127; 126, 130; 127, subscript; 127, 128; 127, 129; 128, identifier:basis; 129, identifier:idx; 130, subscript; 130, 131; 130, 132; 131, identifier:polynomials; 132, identifier:idy; 133, identifier:dist; 134, dictionary_splat; 134, 135; 135, identifier:kws; 136, expression_statement; 136, 137; 137, assignment; 137, 138; 137, 141; 138, subscript; 138, 139; 138, 140; 139, identifier:basis; 140, identifier:idx; 141, binary_operator:-; 141, 142; 141, 145; 142, subscript; 142, 143; 142, 144; 143, identifier:basis; 144, identifier:idx; 145, binary_operator:*; 145, 146; 145, 149; 146, subscript; 146, 147; 146, 148; 147, identifier:polynomials; 148, identifier:idy; 149, identifier:orth; 150, expression_statement; 150, 151; 151, assignment; 151, 152; 151, 153; 152, identifier:norms; 153, call; 153, 154; 153, 159; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:chaospy; 157, identifier:descriptives; 158, identifier:E; 159, argument_list; 159, 160; 159, 166; 159, 167; 160, binary_operator:**; 160, 161; 160, 165; 161, subscript; 161, 162; 161, 163; 162, identifier:polynomials; 163, unary_operator:-; 163, 164; 164, integer:1; 165, integer:2; 166, identifier:dist; 167, dictionary_splat; 167, 168; 168, identifier:kws; 169, if_statement; 169, 170; 169, 173; 170, comparison_operator:<=; 170, 171; 170, 172; 171, identifier:norms; 172, integer:0; 173, block; 173, 174; 173, 182; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:logger; 178, identifier:warning; 179, argument_list; 179, 180; 179, 181; 180, string:"Warning: Polynomial cutoff at term %d"; 181, identifier:idx; 182, break_statement; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 188; 185, subscript; 185, 186; 185, 187; 186, identifier:basis; 187, identifier:idx; 188, binary_operator:/; 188, 189; 188, 192; 189, subscript; 189, 190; 189, 191; 190, identifier:basis; 191, identifier:idx; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:numpy; 195, identifier:sqrt; 196, argument_list; 196, 197; 197, identifier:norms; 198, expression_statement; 198, 199; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:polynomials; 202, identifier:append; 203, argument_list; 203, 204; 204, subscript; 204, 205; 204, 206; 205, identifier:basis; 206, identifier:idx; 207, else_clause; 207, 208; 208, block; 208, 209; 208, 214; 209, expression_statement; 209, 210; 210, assignment; 210, 211; 210, 212; 211, identifier:norms; 212, list:[1.]; 212, 213; 213, float:1.; 214, for_statement; 214, 215; 214, 216; 214, 224; 215, identifier:idx; 216, call; 216, 217; 216, 218; 217, identifier:range; 218, argument_list; 218, 219; 218, 220; 219, integer:1; 220, call; 220, 221; 220, 222; 221, identifier:len; 222, argument_list; 222, 223; 223, identifier:basis; 224, block; 224, 225; 224, 270; 224, 292; 224, 309; 225, for_statement; 225, 226; 225, 227; 225, 231; 226, identifier:idy; 227, call; 227, 228; 227, 229; 228, identifier:range; 229, argument_list; 229, 230; 230, identifier:idx; 231, block; 231, 232; 231, 252; 232, expression_statement; 232, 233; 233, assignment; 233, 234; 233, 235; 234, identifier:orth; 235, call; 235, 236; 235, 241; 236, attribute; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:chaospy; 239, identifier:descriptives; 240, identifier:E; 241, argument_list; 241, 242; 241, 249; 241, 250; 242, binary_operator:*; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:basis; 245, identifier:idx; 246, subscript; 246, 247; 246, 248; 247, identifier:polynomials; 248, identifier:idy; 249, identifier:dist; 250, dictionary_splat; 250, 251; 251, identifier:kws; 252, expression_statement; 252, 253; 253, assignment; 253, 254; 253, 257; 254, subscript; 254, 255; 254, 256; 255, identifier:basis; 256, identifier:idx; 257, binary_operator:-; 257, 258; 257, 261; 258, subscript; 258, 259; 258, 260; 259, identifier:basis; 260, identifier:idx; 261, binary_operator:/; 261, 262; 261, 267; 262, binary_operator:*; 262, 263; 262, 266; 263, subscript; 263, 264; 263, 265; 264, identifier:polynomials; 265, identifier:idy; 266, identifier:orth; 267, subscript; 267, 268; 267, 269; 268, identifier:norms; 269, identifier:idy; 270, expression_statement; 270, 271; 271, call; 271, 272; 271, 275; 272, attribute; 272, 273; 272, 274; 273, identifier:norms; 274, identifier:append; 275, argument_list; 275, 276; 276, call; 276, 277; 276, 282; 277, attribute; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:chaospy; 280, identifier:descriptives; 281, identifier:E; 282, argument_list; 282, 283; 282, 289; 282, 290; 283, binary_operator:**; 283, 284; 283, 288; 284, subscript; 284, 285; 284, 286; 285, identifier:polynomials; 286, unary_operator:-; 286, 287; 287, integer:1; 288, integer:2; 289, identifier:dist; 290, dictionary_splat; 290, 291; 291, identifier:kws; 292, if_statement; 292, 293; 292, 299; 293, comparison_operator:<=; 293, 294; 293, 298; 294, subscript; 294, 295; 294, 296; 295, identifier:norms; 296, unary_operator:-; 296, 297; 297, integer:1; 298, integer:0; 299, block; 299, 300; 299, 308; 300, expression_statement; 300, 301; 301, call; 301, 302; 301, 305; 302, attribute; 302, 303; 302, 304; 303, identifier:logger; 304, identifier:warning; 305, argument_list; 305, 306; 305, 307; 306, string:"Warning: Polynomial cutoff at term %d"; 307, identifier:idx; 308, break_statement; 309, expression_statement; 309, 310; 310, call; 310, 311; 310, 314; 311, attribute; 311, 312; 311, 313; 312, identifier:polynomials; 313, identifier:append; 314, argument_list; 314, 315; 315, subscript; 315, 316; 315, 317; 316, identifier:basis; 317, identifier:idx; 318, return_statement; 318, 319; 319, call; 319, 320; 319, 325; 320, attribute; 320, 321; 320, 324; 321, attribute; 321, 322; 321, 323; 322, identifier:chaospy; 323, identifier:poly; 324, identifier:Poly; 325, argument_list; 325, 326; 325, 327; 325, 330; 326, identifier:polynomials; 327, keyword_argument; 327, 328; 327, 329; 328, identifier:dim; 329, identifier:dim; 330, keyword_argument; 330, 331; 330, 332; 331, identifier:shape; 332, tuple; 332, 333; 333, call; 333, 334; 333, 335; 334, identifier:len; 335, argument_list; 335, 336; 336, identifier:polynomials
|
def orth_gs(order, dist, normed=False, sort="GR", cross_truncation=1., **kws):
logger = logging.getLogger(__name__)
dim = len(dist)
if isinstance(order, int):
if order == 0:
return chaospy.poly.Poly(1, dim=dim)
basis = chaospy.poly.basis(
0, order, dim, sort, cross_truncation=cross_truncation)
else:
basis = order
basis = list(basis)
polynomials = [basis[0]]
if normed:
for idx in range(1, len(basis)):
for idy in range(idx):
orth = chaospy.descriptives.E(
basis[idx]*polynomials[idy], dist, **kws)
basis[idx] = basis[idx] - polynomials[idy]*orth
norms = chaospy.descriptives.E(polynomials[-1]**2, dist, **kws)
if norms <= 0:
logger.warning("Warning: Polynomial cutoff at term %d", idx)
break
basis[idx] = basis[idx] / numpy.sqrt(norms)
polynomials.append(basis[idx])
else:
norms = [1.]
for idx in range(1, len(basis)):
for idy in range(idx):
orth = chaospy.descriptives.E(
basis[idx]*polynomials[idy], dist, **kws)
basis[idx] = basis[idx] - polynomials[idy] * orth / norms[idy]
norms.append(
chaospy.descriptives.E(polynomials[-1]**2, dist, **kws))
if norms[-1] <= 0:
logger.warning("Warning: Polynomial cutoff at term %d", idx)
break
polynomials.append(basis[idx])
return chaospy.poly.Poly(polynomials, dim=dim, shape=(len(polynomials),))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:basis; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:start; 5, default_parameter; 5, 6; 5, 7; 6, identifier:stop; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:dim; 10, integer:1; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sort; 13, string:"G"; 14, default_parameter; 14, 15; 14, 16; 15, identifier:cross_truncation; 16, float:1.; 17, block; 17, 18; 17, 36; 17, 48; 17, 60; 17, 73; 17, 105; 17, 156; 17, 211; 17, 222; 17, 237; 17, 243; 17, 247; 17, 274; 17, 289; 17, 295; 17, 299; 17, 326; 18, if_statement; 18, 19; 18, 22; 19, comparison_operator:is; 19, 20; 19, 21; 20, identifier:stop; 21, None; 22, block; 22, 23; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 28; 25, pattern_list; 25, 26; 25, 27; 26, identifier:start; 27, identifier:stop; 28, expression_list; 28, 29; 28, 35; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:numpy; 32, identifier:array; 33, argument_list; 33, 34; 34, integer:0; 35, identifier:start; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:start; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:numpy; 42, identifier:array; 43, argument_list; 43, 44; 43, 45; 44, identifier:start; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:dtype; 47, identifier:int; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:stop; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:numpy; 54, identifier:array; 55, argument_list; 55, 56; 55, 57; 56, identifier:stop; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:dtype; 59, identifier:int; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:dim; 63, call; 63, 64; 63, 65; 64, identifier:max; 65, argument_list; 65, 66; 65, 69; 65, 72; 66, attribute; 66, 67; 66, 68; 67, identifier:start; 68, identifier:size; 69, attribute; 69, 70; 69, 71; 70, identifier:stop; 71, identifier:size; 72, identifier:dim; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:indices; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:numpy; 79, identifier:array; 80, argument_list; 80, 81; 81, call; 81, 82; 81, 87; 82, attribute; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:chaospy; 85, identifier:bertran; 86, identifier:bindex; 87, argument_list; 87, 88; 87, 94; 87, 102; 87, 103; 87, 104; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:numpy; 91, identifier:min; 92, argument_list; 92, 93; 93, identifier:start; 94, binary_operator:*; 94, 95; 94, 96; 95, integer:2; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:numpy; 99, identifier:max; 100, argument_list; 100, 101; 101, identifier:stop; 102, identifier:dim; 103, identifier:sort; 104, identifier:cross_truncation; 105, if_statement; 105, 106; 105, 111; 105, 125; 106, comparison_operator:==; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:start; 109, identifier:size; 110, integer:1; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 115; 114, identifier:bellow; 115, comparison_operator:>=; 115, 116; 115, 124; 116, call; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:numpy; 119, identifier:sum; 120, argument_list; 120, 121; 120, 122; 121, identifier:indices; 122, unary_operator:-; 122, 123; 123, integer:1; 124, identifier:start; 125, else_clause; 125, 126; 126, block; 126, 127; 126, 141; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:start; 130, binary_operator:*; 130, 131; 130, 140; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:numpy; 134, identifier:ones; 135, argument_list; 135, 136; 135, 137; 136, identifier:dim; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:dtype; 139, identifier:int; 140, identifier:start; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:bellow; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:numpy; 147, identifier:all; 148, argument_list; 148, 149; 148, 154; 149, comparison_operator:>=; 149, 150; 149, 153; 150, binary_operator:-; 150, 151; 150, 152; 151, identifier:indices; 152, identifier:start; 153, integer:0; 154, unary_operator:-; 154, 155; 155, integer:1; 156, if_statement; 156, 157; 156, 162; 156, 180; 157, comparison_operator:==; 157, 158; 157, 161; 158, attribute; 158, 159; 158, 160; 159, identifier:stop; 160, identifier:size; 161, integer:1; 162, block; 162, 163; 163, expression_statement; 163, 164; 164, assignment; 164, 165; 164, 166; 165, identifier:above; 166, comparison_operator:<=; 166, 167; 166, 175; 167, call; 167, 168; 167, 171; 168, attribute; 168, 169; 168, 170; 169, identifier:numpy; 170, identifier:sum; 171, argument_list; 171, 172; 171, 173; 172, identifier:indices; 173, unary_operator:-; 173, 174; 174, integer:1; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:stop; 178, identifier:item; 179, argument_list; 180, else_clause; 180, 181; 181, block; 181, 182; 181, 196; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:stop; 185, binary_operator:*; 185, 186; 185, 195; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:numpy; 189, identifier:ones; 190, argument_list; 190, 191; 190, 192; 191, identifier:dim; 192, keyword_argument; 192, 193; 192, 194; 193, identifier:dtype; 194, identifier:int; 195, identifier:stop; 196, expression_statement; 196, 197; 197, assignment; 197, 198; 197, 199; 198, identifier:above; 199, call; 199, 200; 199, 203; 200, attribute; 200, 201; 200, 202; 201, identifier:numpy; 202, identifier:all; 203, argument_list; 203, 204; 203, 209; 204, comparison_operator:>=; 204, 205; 204, 208; 205, binary_operator:-; 205, 206; 205, 207; 206, identifier:stop; 207, identifier:indices; 208, integer:0; 209, unary_operator:-; 209, 210; 210, integer:1; 211, expression_statement; 211, 212; 212, assignment; 212, 213; 212, 214; 213, identifier:pool; 214, call; 214, 215; 214, 216; 215, identifier:list; 216, argument_list; 216, 217; 217, subscript; 217, 218; 217, 219; 218, identifier:indices; 219, binary_operator:*; 219, 220; 219, 221; 220, identifier:above; 221, identifier:bellow; 222, expression_statement; 222, 223; 223, assignment; 223, 224; 223, 225; 224, identifier:arg; 225, call; 225, 226; 225, 229; 226, attribute; 226, 227; 226, 228; 227, identifier:numpy; 228, identifier:zeros; 229, argument_list; 229, 230; 229, 234; 230, call; 230, 231; 230, 232; 231, identifier:len; 232, argument_list; 232, 233; 233, identifier:pool; 234, keyword_argument; 234, 235; 234, 236; 235, identifier:dtype; 236, identifier:int; 237, expression_statement; 237, 238; 238, assignment; 238, 239; 238, 242; 239, subscript; 239, 240; 239, 241; 240, identifier:arg; 241, integer:0; 242, integer:1; 243, expression_statement; 243, 244; 244, assignment; 244, 245; 244, 246; 245, identifier:poly; 246, dictionary; 247, for_statement; 247, 248; 247, 249; 247, 250; 248, identifier:idx; 249, identifier:pool; 250, block; 250, 251; 250, 258; 250, 264; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:idx; 254, call; 254, 255; 254, 256; 255, identifier:tuple; 256, argument_list; 256, 257; 257, identifier:idx; 258, expression_statement; 258, 259; 259, assignment; 259, 260; 259, 263; 260, subscript; 260, 261; 260, 262; 261, identifier:poly; 262, identifier:idx; 263, identifier:arg; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 267; 266, identifier:arg; 267, call; 267, 268; 267, 271; 268, attribute; 268, 269; 268, 270; 269, identifier:numpy; 270, identifier:roll; 271, argument_list; 271, 272; 271, 273; 272, identifier:arg; 273, integer:1; 274, expression_statement; 274, 275; 275, assignment; 275, 276; 275, 277; 276, identifier:x; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:numpy; 280, identifier:zeros; 281, argument_list; 281, 282; 281, 286; 282, call; 282, 283; 282, 284; 283, identifier:len; 284, argument_list; 284, 285; 285, identifier:pool; 286, keyword_argument; 286, 287; 286, 288; 287, identifier:dtype; 288, identifier:int; 289, expression_statement; 289, 290; 290, assignment; 290, 291; 290, 294; 291, subscript; 291, 292; 291, 293; 292, identifier:x; 293, integer:0; 294, integer:1; 295, expression_statement; 295, 296; 296, assignment; 296, 297; 296, 298; 297, identifier:A; 298, dictionary; 299, for_statement; 299, 300; 299, 301; 299, 302; 300, identifier:I; 301, identifier:pool; 302, block; 302, 303; 302, 310; 302, 316; 303, expression_statement; 303, 304; 304, assignment; 304, 305; 304, 306; 305, identifier:I; 306, call; 306, 307; 306, 308; 307, identifier:tuple; 308, argument_list; 308, 309; 309, identifier:I; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 315; 312, subscript; 312, 313; 312, 314; 313, identifier:A; 314, identifier:I; 315, identifier:x; 316, expression_statement; 316, 317; 317, assignment; 317, 318; 317, 319; 318, identifier:x; 319, call; 319, 320; 319, 323; 320, attribute; 320, 321; 320, 322; 321, identifier:numpy; 322, identifier:roll; 323, argument_list; 323, 324; 323, 325; 324, identifier:x; 325, integer:1; 326, return_statement; 326, 327; 327, call; 327, 328; 327, 329; 328, identifier:Poly; 329, argument_list; 329, 330; 329, 331; 330, identifier:A; 331, identifier:dim
|
def basis(start, stop=None, dim=1, sort="G", cross_truncation=1.):
if stop is None:
start, stop = numpy.array(0), start
start = numpy.array(start, dtype=int)
stop = numpy.array(stop, dtype=int)
dim = max(start.size, stop.size, dim)
indices = numpy.array(chaospy.bertran.bindex(
numpy.min(start), 2*numpy.max(stop), dim, sort, cross_truncation))
if start.size == 1:
bellow = numpy.sum(indices, -1) >= start
else:
start = numpy.ones(dim, dtype=int)*start
bellow = numpy.all(indices-start >= 0, -1)
if stop.size == 1:
above = numpy.sum(indices, -1) <= stop.item()
else:
stop = numpy.ones(dim, dtype=int)*stop
above = numpy.all(stop-indices >= 0, -1)
pool = list(indices[above*bellow])
arg = numpy.zeros(len(pool), dtype=int)
arg[0] = 1
poly = {}
for idx in pool:
idx = tuple(idx)
poly[idx] = arg
arg = numpy.roll(arg, 1)
x = numpy.zeros(len(pool), dtype=int)
x[0] = 1
A = {}
for I in pool:
I = tuple(I)
A[I] = x
x = numpy.roll(x,1)
return Poly(A, dim)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:sorted; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 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, block; 11, 12; 12, return_statement; 12, 13; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:_transform; 17, argument_list; 17, 18; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:transformations; 21, identifier:sorted_t; 22, argument_list; 22, 23; 22, 26; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:key; 25, identifier:key; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:reverse; 28, identifier:reverse
|
def sorted(self, key=None, reverse=False):
return self._transform(transformations.sorted_t(key=key, reverse=reverse))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:GetCredentials; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 4, identifier:package_name; 5, identifier:scopes; 6, identifier:client_id; 7, identifier:client_secret; 8, identifier:user_agent; 9, default_parameter; 9, 10; 9, 11; 10, identifier:credentials_filename; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:api_key; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:client; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:oauth2client_args; 20, None; 21, dictionary_splat_pattern; 21, 22; 22, identifier:kwds; 23, block; 23, 24; 23, 33; 23, 61; 23, 81; 23, 94; 23, 105; 23, 112; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:scopes; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:util; 30, identifier:NormalizeScopes; 31, argument_list; 31, 32; 32, identifier:scopes; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:client_info; 36, dictionary; 36, 37; 36, 40; 36, 43; 36, 54; 37, pair; 37, 38; 37, 39; 38, string:'client_id'; 39, identifier:client_id; 40, pair; 40, 41; 40, 42; 41, string:'client_secret'; 42, identifier:client_secret; 43, pair; 43, 44; 43, 45; 44, string:'scope'; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, string:' '; 48, identifier:join; 49, argument_list; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:sorted; 52, argument_list; 52, 53; 53, identifier:scopes; 54, pair; 54, 55; 54, 56; 55, string:'user_agent'; 56, boolean_operator:or; 56, 57; 56, 58; 57, identifier:user_agent; 58, binary_operator:%; 58, 59; 58, 60; 59, string:'%s-generated/0.1'; 60, identifier:package_name; 61, for_statement; 61, 62; 61, 63; 61, 64; 62, identifier:method; 63, identifier:_CREDENTIALS_METHODS; 64, block; 64, 65; 64, 74; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:credentials; 68, call; 68, 69; 68, 70; 69, identifier:method; 70, argument_list; 70, 71; 70, 72; 71, identifier:client_info; 72, dictionary_splat; 72, 73; 73, identifier:kwds; 74, if_statement; 74, 75; 74, 78; 75, comparison_operator:is; 75, 76; 75, 77; 76, identifier:credentials; 77, None; 78, block; 78, 79; 79, return_statement; 79, 80; 80, identifier:credentials; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:credentials_filename; 84, boolean_operator:or; 84, 85; 84, 86; 85, identifier:credentials_filename; 86, call; 86, 87; 86, 92; 87, attribute; 87, 88; 87, 91; 88, attribute; 88, 89; 88, 90; 89, identifier:os; 90, identifier:path; 91, identifier:expanduser; 92, argument_list; 92, 93; 93, string:'~/.apitools.token'; 94, expression_statement; 94, 95; 95, assignment; 95, 96; 95, 97; 96, identifier:credentials; 97, call; 97, 98; 97, 99; 98, identifier:CredentialsFromFile; 99, argument_list; 99, 100; 99, 101; 99, 102; 100, identifier:credentials_filename; 101, identifier:client_info; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:oauth2client_args; 104, identifier:oauth2client_args; 105, if_statement; 105, 106; 105, 109; 106, comparison_operator:is; 106, 107; 106, 108; 107, identifier:credentials; 108, None; 109, block; 109, 110; 110, return_statement; 110, 111; 111, identifier:credentials; 112, raise_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:exceptions; 116, identifier:CredentialsError; 117, argument_list; 117, 118; 118, string:'Could not create valid credentials'
|
def GetCredentials(package_name, scopes, client_id, client_secret, user_agent,
credentials_filename=None,
api_key=None,
client=None,
oauth2client_args=None,
**kwds):
scopes = util.NormalizeScopes(scopes)
client_info = {
'client_id': client_id,
'client_secret': client_secret,
'scope': ' '.join(sorted(scopes)),
'user_agent': user_agent or '%s-generated/0.1' % package_name,
}
for method in _CREDENTIALS_METHODS:
credentials = method(client_info, **kwds)
if credentials is not None:
return credentials
credentials_filename = credentials_filename or os.path.expanduser(
'~/.apitools.token')
credentials = CredentialsFromFile(credentials_filename, client_info,
oauth2client_args=oauth2client_args)
if credentials is not None:
return credentials
raise exceptions.CredentialsError('Could not create valid credentials')
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 20; 2, function_name:get_sorted_graph; 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:start; 7, integer:0; 8, default_parameter; 8, 9; 8, 10; 9, identifier:stop; 10, integer:100; 11, default_parameter; 11, 12; 11, 13; 12, identifier:slices; 13, integer:100; 14, default_parameter; 14, 15; 14, 16; 15, identifier:include_inf; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:exact; 19, False; 20, block; 20, 21; 20, 32; 20, 133; 20, 150; 21, if_statement; 21, 22; 21, 26; 22, not_operator; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:is_sorted; 26, block; 26, 27; 27, raise_statement; 27, 28; 28, call; 28, 29; 28, 30; 29, identifier:Exception; 30, argument_list; 30, 31; 31, string:"Not a sorted queue"; 32, with_statement; 32, 33; 32, 50; 33, with_clause; 33, 34; 34, with_item; 34, 35; 35, as_pattern; 35, 36; 35, 48; 36, call; 36, 37; 36, 44; 37, attribute; 37, 38; 37, 43; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:context; 41, identifier:connections; 42, identifier:redis; 43, identifier:pipeline; 44, argument_list; 44, 45; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:transaction; 47, identifier:exact; 48, as_pattern_target; 48, 49; 49, identifier:pipe; 50, block; 50, 51; 50, 64; 50, 98; 50, 125; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 54; 53, identifier:interval; 54, call; 54, 55; 54, 56; 55, identifier:old_div; 56, argument_list; 56, 57; 56, 63; 57, call; 57, 58; 57, 59; 58, identifier:float; 59, argument_list; 59, 60; 60, binary_operator:-; 60, 61; 60, 62; 61, identifier:stop; 62, identifier:start; 63, identifier:slices; 64, for_statement; 64, 65; 64, 66; 64, 71; 65, identifier:i; 66, call; 66, 67; 66, 68; 67, identifier:range; 68, argument_list; 68, 69; 68, 70; 69, integer:0; 70, identifier:slices; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:pipe; 76, identifier:zcount; 77, argument_list; 77, 78; 77, 81; 77, 87; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:redis_key; 81, parenthesized_expression; 81, 82; 82, binary_operator:+; 82, 83; 82, 84; 83, identifier:start; 84, binary_operator:*; 84, 85; 84, 86; 85, identifier:i; 86, identifier:interval; 87, binary_operator:%; 87, 88; 87, 89; 88, string:"(%s"; 89, parenthesized_expression; 89, 90; 90, binary_operator:+; 90, 91; 90, 92; 91, identifier:start; 92, binary_operator:*; 92, 93; 92, 97; 93, parenthesized_expression; 93, 94; 94, binary_operator:+; 94, 95; 94, 96; 95, identifier:i; 96, integer:1; 97, identifier:interval; 98, if_statement; 98, 99; 98, 100; 99, identifier:include_inf; 100, block; 100, 101; 100, 112; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 106; 103, attribute; 103, 104; 103, 105; 104, identifier:pipe; 105, identifier:zcount; 106, argument_list; 106, 107; 106, 110; 106, 111; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:redis_key; 110, identifier:stop; 111, string:"+inf"; 112, expression_statement; 112, 113; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:pipe; 116, identifier:zcount; 117, argument_list; 117, 118; 117, 121; 117, 122; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:redis_key; 121, string:"-inf"; 122, binary_operator:%; 122, 123; 122, 124; 123, string:"(%s"; 124, identifier:start; 125, expression_statement; 125, 126; 126, assignment; 126, 127; 126, 128; 127, identifier:data; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:pipe; 131, identifier:execute; 132, argument_list; 133, if_statement; 133, 134; 133, 135; 134, identifier:include_inf; 135, block; 135, 136; 136, return_statement; 136, 137; 137, binary_operator:+; 137, 138; 137, 144; 138, subscript; 138, 139; 138, 140; 139, identifier:data; 140, slice; 140, 141; 140, 143; 141, unary_operator:-; 141, 142; 142, integer:1; 143, colon; 144, subscript; 144, 145; 144, 146; 145, identifier:data; 146, slice; 146, 147; 146, 148; 147, colon; 148, unary_operator:-; 148, 149; 149, integer:1; 150, return_statement; 150, 151; 151, identifier:data
|
def get_sorted_graph(
self,
start=0,
stop=100,
slices=100,
include_inf=False,
exact=False):
if not self.is_sorted:
raise Exception("Not a sorted queue")
with context.connections.redis.pipeline(transaction=exact) as pipe:
interval = old_div(float(stop - start), slices)
for i in range(0, slices):
pipe.zcount(self.redis_key,
(start + i * interval),
"(%s" % (start + (i + 1) * interval))
if include_inf:
pipe.zcount(self.redis_key, stop, "+inf")
pipe.zcount(self.redis_key, "-inf", "(%s" % start)
data = pipe.execute()
if include_inf:
return data[-1:] + data[:-1]
return data
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:get_threads; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, identifier:querystring; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, string:'newest_first'; 9, default_parameter; 9, 10; 9, 11; 10, identifier:exclude_tags; 11, None; 12, block; 12, 13; 12, 19; 12, 28; 12, 39; 12, 53; 13, assert_statement; 13, 14; 14, comparison_operator:in; 14, 15; 14, 16; 15, identifier:sort; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:_sort_orders; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:q; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:query; 26, argument_list; 26, 27; 27, identifier:querystring; 28, expression_statement; 28, 29; 29, call; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:q; 32, identifier:set_sort; 33, argument_list; 33, 34; 34, subscript; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_sort_orders; 38, identifier:sort; 39, if_statement; 39, 40; 39, 41; 40, identifier:exclude_tags; 41, block; 41, 42; 42, for_statement; 42, 43; 42, 44; 42, 45; 43, identifier:tag; 44, identifier:exclude_tags; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:q; 50, identifier:exclude_tag; 51, argument_list; 51, 52; 52, identifier:tag; 53, return_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:self; 57, identifier:async_; 58, argument_list; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:q; 61, identifier:search_threads; 62, parenthesized_expression; 62, 63; 63, lambda; 63, 64; 63, 66; 64, lambda_parameters; 64, 65; 65, identifier:a; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:a; 69, identifier:get_thread_id; 70, argument_list
|
def get_threads(self, querystring, sort='newest_first', exclude_tags=None):
assert sort in self._sort_orders
q = self.query(querystring)
q.set_sort(self._sort_orders[sort])
if exclude_tags:
for tag in exclude_tags:
q.exclude_tag(tag)
return self.async_(q.search_threads, (lambda a: a.get_thread_id()))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:nd_sort_samples; 3, parameters; 3, 4; 4, identifier:samples; 5, block; 5, 6; 5, 15; 5, 22; 5, 41; 6, assert_statement; 6, 7; 7, comparison_operator:==; 7, 8; 7, 14; 8, call; 8, 9; 8, 10; 9, identifier:len; 10, argument_list; 10, 11; 11, attribute; 11, 12; 11, 13; 12, identifier:samples; 13, identifier:shape; 14, integer:2; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:tree; 18, call; 18, 19; 18, 20; 19, identifier:cKDTree; 20, argument_list; 20, 21; 21, identifier:samples; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 27; 24, pattern_list; 24, 25; 24, 26; 25, identifier:d; 26, identifier:i; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:tree; 30, identifier:query; 31, argument_list; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:samples; 34, integer:0; 35, keyword_argument; 35, 36; 35, 37; 36, identifier:k; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:samples; 41, return_statement; 41, 42; 42, identifier:i
|
def nd_sort_samples(samples):
assert len(samples.shape) == 2
tree = cKDTree(samples)
d, i = tree.query(samples[0], k=len(samples))
return i
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:GetVolumeIdentifiers; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:volume_system; 6, block; 6, 7; 6, 11; 6, 36; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:volume_identifiers; 10, list:[]; 11, for_statement; 11, 12; 11, 13; 11, 16; 12, identifier:volume; 13, attribute; 13, 14; 13, 15; 14, identifier:volume_system; 15, identifier:volumes; 16, block; 16, 17; 16, 26; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:volume_identifier; 20, call; 20, 21; 20, 22; 21, identifier:getattr; 22, argument_list; 22, 23; 22, 24; 22, 25; 23, identifier:volume; 24, string:'identifier'; 25, None; 26, if_statement; 26, 27; 26, 28; 27, identifier:volume_identifier; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:volume_identifiers; 33, identifier:append; 34, argument_list; 34, 35; 35, identifier:volume_identifier; 36, return_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:sorted; 39, argument_list; 39, 40; 40, identifier:volume_identifiers
|
def GetVolumeIdentifiers(self, volume_system):
volume_identifiers = []
for volume in volume_system.volumes:
volume_identifier = getattr(volume, 'identifier', None)
if volume_identifier:
volume_identifiers.append(volume_identifier)
return sorted(volume_identifiers)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:topological_order_dfs; 3, parameters; 3, 4; 4, identifier:graph; 5, block; 5, 6; 5, 13; 5, 17; 5, 25; 5, 127; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:n; 9, call; 9, 10; 9, 11; 10, identifier:len; 11, argument_list; 11, 12; 12, identifier:graph; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:order; 16, list:[]; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:times_seen; 20, binary_operator:*; 20, 21; 20, 24; 21, list:[-1]; 21, 22; 22, unary_operator:-; 22, 23; 23, integer:1; 24, identifier:n; 25, for_statement; 25, 26; 25, 27; 25, 31; 26, identifier:start; 27, call; 27, 28; 27, 29; 28, identifier:range; 29, argument_list; 29, 30; 30, identifier:n; 31, block; 31, 32; 32, if_statement; 32, 33; 32, 39; 33, comparison_operator:==; 33, 34; 33, 37; 34, subscript; 34, 35; 34, 36; 35, identifier:times_seen; 36, identifier:start; 37, unary_operator:-; 37, 38; 38, integer:1; 39, block; 39, 40; 39, 46; 39, 51; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:times_seen; 44, identifier:start; 45, integer:0; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:to_visit; 49, list:[start]; 49, 50; 50, identifier:start; 51, while_statement; 51, 52; 51, 53; 52, identifier:to_visit; 53, block; 53, 54; 53, 61; 53, 67; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:node; 57, subscript; 57, 58; 57, 59; 58, identifier:to_visit; 59, unary_operator:-; 59, 60; 60, integer:1; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:children; 64, subscript; 64, 65; 64, 66; 65, identifier:graph; 66, identifier:node; 67, if_statement; 67, 68; 67, 76; 67, 90; 68, comparison_operator:==; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:times_seen; 71, identifier:node; 72, call; 72, 73; 72, 74; 73, identifier:len; 74, argument_list; 74, 75; 75, identifier:children; 76, block; 76, 77; 76, 83; 77, expression_statement; 77, 78; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:to_visit; 81, identifier:pop; 82, argument_list; 83, expression_statement; 83, 84; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:order; 87, identifier:append; 88, argument_list; 88, 89; 89, identifier:node; 90, else_clause; 90, 91; 91, block; 91, 92; 91, 100; 91, 106; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:child; 95, subscript; 95, 96; 95, 97; 96, identifier:children; 97, subscript; 97, 98; 97, 99; 98, identifier:times_seen; 99, identifier:node; 100, expression_statement; 100, 101; 101, augmented_assignment:+=; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:times_seen; 104, identifier:node; 105, integer:1; 106, if_statement; 106, 107; 106, 113; 107, comparison_operator:==; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:times_seen; 110, identifier:child; 111, unary_operator:-; 111, 112; 112, integer:1; 113, block; 113, 114; 113, 120; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:times_seen; 118, identifier:child; 119, integer:0; 120, expression_statement; 120, 121; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, identifier:to_visit; 124, identifier:append; 125, argument_list; 125, 126; 126, identifier:child; 127, return_statement; 127, 128; 128, subscript; 128, 129; 128, 130; 129, identifier:order; 130, slice; 130, 131; 130, 132; 130, 133; 131, colon; 132, colon; 133, unary_operator:-; 133, 134; 134, integer:1
|
def topological_order_dfs(graph):
n = len(graph)
order = []
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1:
times_seen[start] = 0
to_visit = [start]
while to_visit:
node = to_visit[-1]
children = graph[node]
if times_seen[node] == len(children):
to_visit.pop()
order.append(node)
else:
child = children[times_seen[node]]
times_seen[node] += 1
if times_seen[child] == -1:
times_seen[child] = 0
to_visit.append(child)
return order[::-1]
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:topological_order; 3, parameters; 3, 4; 4, identifier:graph; 5, block; 5, 6; 5, 16; 5, 24; 5, 40; 5, 54; 5, 58; 5, 102; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:V; 9, call; 9, 10; 9, 11; 10, identifier:range; 11, argument_list; 11, 12; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, identifier:graph; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:indeg; 19, list_comprehension; 19, 20; 19, 21; 20, integer:0; 21, for_in_clause; 21, 22; 21, 23; 22, identifier:_; 23, identifier:V; 24, for_statement; 24, 25; 24, 26; 24, 27; 25, identifier:node; 26, identifier:V; 27, block; 27, 28; 28, for_statement; 28, 29; 28, 30; 28, 33; 29, identifier:neighbor; 30, subscript; 30, 31; 30, 32; 31, identifier:graph; 32, identifier:node; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, augmented_assignment:+=; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:indeg; 38, identifier:neighbor; 39, integer:1; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:Q; 43, list_comprehension; 43, 44; 43, 45; 43, 48; 44, identifier:node; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:node; 47, identifier:V; 48, if_clause; 48, 49; 49, comparison_operator:==; 49, 50; 49, 53; 50, subscript; 50, 51; 50, 52; 51, identifier:indeg; 52, identifier:node; 53, integer:0; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:order; 57, list:[]; 58, while_statement; 58, 59; 58, 60; 59, identifier:Q; 60, block; 60, 61; 60, 69; 60, 76; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 64; 63, identifier:node; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:Q; 67, identifier:pop; 68, argument_list; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:order; 73, identifier:append; 74, argument_list; 74, 75; 75, identifier:node; 76, for_statement; 76, 77; 76, 78; 76, 81; 77, identifier:neighbor; 78, subscript; 78, 79; 78, 80; 79, identifier:graph; 80, identifier:node; 81, block; 81, 82; 81, 88; 82, expression_statement; 82, 83; 83, augmented_assignment:-=; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:indeg; 86, identifier:neighbor; 87, integer:1; 88, if_statement; 88, 89; 88, 94; 89, comparison_operator:==; 89, 90; 89, 93; 90, subscript; 90, 91; 90, 92; 91, identifier:indeg; 92, identifier:neighbor; 93, integer:0; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:Q; 99, identifier:append; 100, argument_list; 100, 101; 101, identifier:neighbor; 102, return_statement; 102, 103; 103, identifier:order
|
def topological_order(graph):
V = range(len(graph))
indeg = [0 for _ in V]
for node in V:
for neighbor in graph[node]:
indeg[neighbor] += 1
Q = [node for node in V if indeg[node] == 0]
order = []
while Q:
node = Q.pop()
order.append(node)
for neighbor in graph[node]:
indeg[neighbor] -= 1
if indeg[neighbor] == 0:
Q.append(neighbor)
return order
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:interval_tree; 3, parameters; 3, 4; 4, identifier:intervals; 5, block; 5, 6; 5, 13; 5, 26; 5, 30; 5, 34; 5, 38; 5, 79; 5, 93; 5, 107; 5, 114; 5, 121; 6, if_statement; 6, 7; 6, 10; 7, comparison_operator:==; 7, 8; 7, 9; 8, identifier:intervals; 9, list:[]; 10, block; 10, 11; 11, return_statement; 11, 12; 12, None; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:center; 16, subscript; 16, 17; 16, 25; 17, subscript; 17, 18; 17, 19; 18, identifier:intervals; 19, binary_operator://; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, identifier:intervals; 24, integer:2; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:L; 29, list:[]; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:R; 33, list:[]; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:C; 37, list:[]; 38, for_statement; 38, 39; 38, 40; 38, 41; 39, identifier:I; 40, identifier:intervals; 41, block; 41, 42; 42, if_statement; 42, 43; 42, 48; 42, 56; 42, 70; 43, comparison_operator:<=; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:I; 46, integer:1; 47, identifier:center; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:L; 53, identifier:append; 54, argument_list; 54, 55; 55, identifier:I; 56, elif_clause; 56, 57; 56, 62; 57, comparison_operator:<; 57, 58; 57, 59; 58, identifier:center; 59, subscript; 59, 60; 59, 61; 60, identifier:I; 61, integer:0; 62, block; 62, 63; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:R; 67, identifier:append; 68, argument_list; 68, 69; 69, identifier:I; 70, else_clause; 70, 71; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, call; 73, 74; 73, 77; 74, attribute; 74, 75; 74, 76; 75, identifier:C; 76, identifier:append; 77, argument_list; 77, 78; 78, identifier:I; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 82; 81, identifier:by_low; 82, call; 82, 83; 82, 84; 83, identifier:sorted; 84, generator_expression; 84, 85; 84, 90; 85, tuple; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:I; 88, integer:0; 89, identifier:I; 90, for_in_clause; 90, 91; 90, 92; 91, identifier:I; 92, identifier:C; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:by_high; 96, call; 96, 97; 96, 98; 97, identifier:sorted; 98, generator_expression; 98, 99; 98, 104; 99, tuple; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:I; 102, integer:1; 103, identifier:I; 104, for_in_clause; 104, 105; 104, 106; 105, identifier:I; 106, identifier:C; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:IL; 110, call; 110, 111; 110, 112; 111, identifier:interval_tree; 112, argument_list; 112, 113; 113, identifier:L; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:IR; 117, call; 117, 118; 117, 119; 118, identifier:interval_tree; 119, argument_list; 119, 120; 120, identifier:R; 121, return_statement; 121, 122; 122, call; 122, 123; 122, 124; 123, identifier:_Node; 124, argument_list; 124, 125; 124, 126; 124, 127; 124, 128; 124, 129; 125, identifier:center; 126, identifier:by_low; 127, identifier:by_high; 128, identifier:IL; 129, identifier:IR
|
def interval_tree(intervals):
if intervals == []:
return None
center = intervals[len(intervals) // 2][0]
L = []
R = []
C = []
for I in intervals:
if I[1] <= center:
L.append(I)
elif center < I[0]:
R.append(I)
else:
C.append(I)
by_low = sorted((I[0], I) for I in C)
by_high = sorted((I[1], I) for I in C)
IL = interval_tree(L)
IR = interval_tree(R)
return _Node(center, by_low, by_high, IL, IR)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_type; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:name; 6, block; 6, 7; 6, 18; 7, if_statement; 7, 8; 7, 15; 8, comparison_operator:==; 8, 9; 8, 14; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:name; 12, identifier:lower; 13, argument_list; 14, string:'hiddenservices'; 15, block; 15, 16; 16, return_statement; 16, 17; 17, identifier:FilesystemOnionService; 18, return_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:type; 21, argument_list; 21, 22; 22, subscript; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:parsers; 26, identifier:name
|
def get_type(self, name):
if name.lower() == 'hiddenservices':
return FilesystemOnionService
return type(self.parsers[name])
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 25; 2, function_name:schwarz; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 4, identifier:A; 5, identifier:x; 6, identifier:b; 7, default_parameter; 7, 8; 7, 9; 8, identifier:iterations; 9, integer:1; 10, default_parameter; 10, 11; 10, 12; 11, identifier:subdomain; 12, None; 13, default_parameter; 13, 14; 13, 15; 14, identifier:subdomain_ptr; 15, None; 16, default_parameter; 16, 17; 16, 18; 17, identifier:inv_subblock; 18, None; 19, default_parameter; 19, 20; 19, 21; 20, identifier:inv_subblock_ptr; 21, None; 22, default_parameter; 22, 23; 22, 24; 23, identifier:sweep; 24, string:'forward'; 25, block; 25, 26; 25, 42; 25, 48; 25, 62; 25, 78; 25, 192; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 32; 28, pattern_list; 28, 29; 28, 30; 28, 31; 29, identifier:A; 30, identifier:x; 31, identifier:b; 32, call; 32, 33; 32, 34; 33, identifier:make_system; 34, argument_list; 34, 35; 34, 36; 34, 37; 34, 38; 35, identifier:A; 36, identifier:x; 37, identifier:b; 38, keyword_argument; 38, 39; 38, 40; 39, identifier:formats; 40, list:['csr']; 40, 41; 41, string:'csr'; 42, expression_statement; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:A; 46, identifier:sort_indices; 47, argument_list; 48, if_statement; 48, 49; 48, 56; 49, boolean_operator:and; 49, 50; 49, 53; 50, comparison_operator:is; 50, 51; 50, 52; 51, identifier:subdomain; 52, None; 53, comparison_operator:is; 53, 54; 53, 55; 54, identifier:inv_subblock; 55, None; 56, block; 56, 57; 57, raise_statement; 57, 58; 58, call; 58, 59; 58, 60; 59, identifier:ValueError; 60, argument_list; 60, 61; 61, string:"inv_subblock must be None if subdomain is None"; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 69; 63, 70; 64, tuple_pattern; 64, 65; 64, 66; 64, 67; 64, 68; 65, identifier:subdomain; 66, identifier:subdomain_ptr; 67, identifier:inv_subblock; 68, identifier:inv_subblock_ptr; 69, line_continuation:\; 70, call; 70, 71; 70, 72; 71, identifier:schwarz_parameters; 72, argument_list; 72, 73; 72, 74; 72, 75; 72, 76; 72, 77; 73, identifier:A; 74, identifier:subdomain; 75, identifier:subdomain_ptr; 76, identifier:inv_subblock; 77, identifier:inv_subblock_ptr; 78, if_statement; 78, 79; 78, 82; 78, 99; 78, 122; 78, 185; 79, comparison_operator:==; 79, 80; 79, 81; 80, identifier:sweep; 81, string:'forward'; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 89; 85, pattern_list; 85, 86; 85, 87; 85, 88; 86, identifier:row_start; 87, identifier:row_stop; 88, identifier:row_step; 89, expression_list; 89, 90; 89, 91; 89, 98; 90, integer:0; 91, binary_operator:-; 91, 92; 91, 97; 92, subscript; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:subdomain_ptr; 95, identifier:shape; 96, integer:0; 97, integer:1; 98, integer:1; 99, elif_clause; 99, 100; 99, 103; 100, comparison_operator:==; 100, 101; 100, 102; 101, identifier:sweep; 102, string:'backward'; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 110; 106, pattern_list; 106, 107; 106, 108; 106, 109; 107, identifier:row_start; 108, identifier:row_stop; 109, identifier:row_step; 110, expression_list; 110, 111; 110, 118; 110, 120; 111, binary_operator:-; 111, 112; 111, 117; 112, subscript; 112, 113; 112, 116; 113, attribute; 113, 114; 113, 115; 114, identifier:subdomain_ptr; 115, identifier:shape; 116, integer:0; 117, integer:2; 118, unary_operator:-; 118, 119; 119, integer:1; 120, unary_operator:-; 120, 121; 121, integer:1; 122, elif_clause; 122, 123; 122, 126; 123, comparison_operator:==; 123, 124; 123, 125; 124, identifier:sweep; 125, string:'symmetric'; 126, block; 126, 127; 126, 184; 127, for_statement; 127, 128; 127, 129; 127, 133; 128, identifier:iter; 129, call; 129, 130; 129, 131; 130, identifier:range; 131, argument_list; 131, 132; 132, identifier:iterations; 133, block; 133, 134; 133, 159; 134, expression_statement; 134, 135; 135, call; 135, 136; 135, 137; 136, identifier:schwarz; 137, argument_list; 137, 138; 137, 139; 137, 140; 137, 141; 137, 144; 137, 147; 137, 150; 137, 153; 137, 156; 138, identifier:A; 139, identifier:x; 140, identifier:b; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:iterations; 143, integer:1; 144, keyword_argument; 144, 145; 144, 146; 145, identifier:subdomain; 146, identifier:subdomain; 147, keyword_argument; 147, 148; 147, 149; 148, identifier:subdomain_ptr; 149, identifier:subdomain_ptr; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:inv_subblock; 152, identifier:inv_subblock; 153, keyword_argument; 153, 154; 153, 155; 154, identifier:inv_subblock_ptr; 155, identifier:inv_subblock_ptr; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:sweep; 158, string:'forward'; 159, expression_statement; 159, 160; 160, call; 160, 161; 160, 162; 161, identifier:schwarz; 162, argument_list; 162, 163; 162, 164; 162, 165; 162, 166; 162, 169; 162, 172; 162, 175; 162, 178; 162, 181; 163, identifier:A; 164, identifier:x; 165, identifier:b; 166, keyword_argument; 166, 167; 166, 168; 167, identifier:iterations; 168, integer:1; 169, keyword_argument; 169, 170; 169, 171; 170, identifier:subdomain; 171, identifier:subdomain; 172, keyword_argument; 172, 173; 172, 174; 173, identifier:subdomain_ptr; 174, identifier:subdomain_ptr; 175, keyword_argument; 175, 176; 175, 177; 176, identifier:inv_subblock; 177, identifier:inv_subblock; 178, keyword_argument; 178, 179; 178, 180; 179, identifier:inv_subblock_ptr; 180, identifier:inv_subblock_ptr; 181, keyword_argument; 181, 182; 181, 183; 182, identifier:sweep; 183, string:'backward'; 184, return_statement; 185, else_clause; 185, 186; 186, block; 186, 187; 187, raise_statement; 187, 188; 188, call; 188, 189; 188, 190; 189, identifier:ValueError; 190, argument_list; 190, 191; 191, string:"valid sweep directions are 'forward',\
'backward', and 'symmetric'"; 192, for_statement; 192, 193; 192, 194; 192, 198; 193, identifier:iter; 194, call; 194, 195; 194, 196; 195, identifier:range; 196, argument_list; 196, 197; 197, identifier:iterations; 198, block; 198, 199; 199, expression_statement; 199, 200; 200, call; 200, 201; 200, 204; 201, attribute; 201, 202; 201, 203; 202, identifier:amg_core; 203, identifier:overlapping_schwarz_csr; 204, argument_list; 204, 205; 204, 208; 204, 211; 204, 214; 204, 215; 204, 216; 204, 217; 204, 218; 204, 219; 204, 220; 204, 227; 204, 232; 204, 233; 204, 234; 205, attribute; 205, 206; 205, 207; 206, identifier:A; 207, identifier:indptr; 208, attribute; 208, 209; 208, 210; 209, identifier:A; 210, identifier:indices; 211, attribute; 211, 212; 211, 213; 212, identifier:A; 213, identifier:data; 214, identifier:x; 215, identifier:b; 216, identifier:inv_subblock; 217, identifier:inv_subblock_ptr; 218, identifier:subdomain; 219, identifier:subdomain_ptr; 220, binary_operator:-; 220, 221; 220, 226; 221, subscript; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:subdomain_ptr; 224, identifier:shape; 225, integer:0; 226, integer:1; 227, subscript; 227, 228; 227, 231; 228, attribute; 228, 229; 228, 230; 229, identifier:A; 230, identifier:shape; 231, integer:0; 232, identifier:row_start; 233, identifier:row_stop; 234, identifier:row_step
|
def schwarz(A, x, b, iterations=1, subdomain=None, subdomain_ptr=None,
inv_subblock=None, inv_subblock_ptr=None, sweep='forward'):
A, x, b = make_system(A, x, b, formats=['csr'])
A.sort_indices()
if subdomain is None and inv_subblock is not None:
raise ValueError("inv_subblock must be None if subdomain is None")
(subdomain, subdomain_ptr, inv_subblock, inv_subblock_ptr) = \
schwarz_parameters(A, subdomain, subdomain_ptr,
inv_subblock, inv_subblock_ptr)
if sweep == 'forward':
row_start, row_stop, row_step = 0, subdomain_ptr.shape[0]-1, 1
elif sweep == 'backward':
row_start, row_stop, row_step = subdomain_ptr.shape[0]-2, -1, -1
elif sweep == 'symmetric':
for iter in range(iterations):
schwarz(A, x, b, iterations=1, subdomain=subdomain,
subdomain_ptr=subdomain_ptr, inv_subblock=inv_subblock,
inv_subblock_ptr=inv_subblock_ptr, sweep='forward')
schwarz(A, x, b, iterations=1, subdomain=subdomain,
subdomain_ptr=subdomain_ptr, inv_subblock=inv_subblock,
inv_subblock_ptr=inv_subblock_ptr, sweep='backward')
return
else:
raise ValueError("valid sweep directions are 'forward',\
'backward', and 'symmetric'")
for iter in range(iterations):
amg_core.overlapping_schwarz_csr(A.indptr, A.indices, A.data,
x, b, inv_subblock, inv_subblock_ptr,
subdomain, subdomain_ptr,
subdomain_ptr.shape[0]-1, A.shape[0],
row_start, row_stop, row_step)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:get_stdlib_path; 3, parameters; 4, block; 4, 5; 5, if_statement; 5, 6; 5, 13; 5, 25; 6, comparison_operator:>=; 6, 7; 6, 10; 7, attribute; 7, 8; 7, 9; 8, identifier:sys; 9, identifier:version_info; 10, tuple; 10, 11; 10, 12; 11, integer:2; 12, integer:7; 13, block; 13, 14; 13, 17; 14, import_statement; 14, 15; 15, dotted_name; 15, 16; 16, identifier:sysconfig; 17, return_statement; 17, 18; 18, subscript; 18, 19; 18, 24; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:sysconfig; 22, identifier:get_paths; 23, argument_list; 24, string:'stdlib'; 25, else_clause; 25, 26; 26, block; 26, 27; 27, return_statement; 27, 28; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, attribute; 30, 31; 30, 32; 31, identifier:os; 32, identifier:path; 33, identifier:join; 34, argument_list; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:sys; 37, identifier:prefix; 38, string:'lib'
|
def get_stdlib_path():
if sys.version_info >= (2, 7):
import sysconfig
return sysconfig.get_paths()['stdlib']
else:
return os.path.join(sys.prefix, 'lib')
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:exists_case_sensitive; 3, parameters; 3, 4; 4, identifier:path; 5, block; 5, 6; 5, 17; 5, 53; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:result; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:os; 13, identifier:path; 14, identifier:exists; 15, argument_list; 15, 16; 16, identifier:path; 17, if_statement; 17, 18; 17, 28; 18, boolean_operator:and; 18, 19; 18, 27; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:sys; 23, identifier:platform; 24, identifier:startswith; 25, argument_list; 25, 26; 26, string:'win'; 27, identifier:result; 28, block; 28, 29; 28, 42; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 34; 31, pattern_list; 31, 32; 31, 33; 32, identifier:directory; 33, identifier:basename; 34, call; 34, 35; 34, 40; 35, attribute; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:os; 38, identifier:path; 39, identifier:split; 40, argument_list; 40, 41; 41, identifier:path; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:result; 45, comparison_operator:in; 45, 46; 45, 47; 46, identifier:basename; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:os; 50, identifier:listdir; 51, argument_list; 51, 52; 52, identifier:directory; 53, return_statement; 53, 54; 54, identifier:result
|
def exists_case_sensitive(path):
result = os.path.exists(path)
if sys.platform.startswith('win') and result:
directory, basename = os.path.split(path)
result = basename in os.listdir(directory)
return result
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 1, 14; 2, function_name:_add_comments; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:comments; 6, default_parameter; 6, 7; 6, 8; 7, identifier:original_string; 8, string:""; 9, ERROR; 9, 10; 10, return_statement; 10, 11; 11, boolean_operator:and; 11, 12; 11, 13; 12, identifier:comments; 13, string:"{0}
"; 14, block; 14, 15; 15, expression_statement; 15, 16; 16, boolean_operator:or; 16, 17; 16, 21; 16, 22; 17, call; 17, 18; 17, 19; 18, identifier:join; 19, argument_list; 19, 20; 20, identifier:comments; 21, ERROR; 22, identifier:original_string
|
def _add_comments(self, comments, original_string=""):
return comments and "{0}
"; ".join(comments)) or original_string
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_priority_key; 3, parameters; 3, 4; 4, identifier:pep8_result; 5, block; 5, 6; 5, 16; 5, 20; 5, 25; 5, 35; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:priority; 9, list:[
'e701',
'e702',
'e225', 'e231',
'e201',
'e262'
]; 9, 10; 9, 11; 9, 12; 9, 13; 9, 14; 9, 15; 10, string:'e701'; 11, string:'e702'; 12, string:'e225'; 13, string:'e231'; 14, string:'e201'; 15, string:'e262'; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:middle_index; 19, integer:10000; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:lowest_priority; 23, list:[
'e501'
]; 23, 24; 24, string:'e501'; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:key; 28, call; 28, 29; 28, 34; 29, attribute; 29, 30; 29, 33; 30, subscript; 30, 31; 30, 32; 31, identifier:pep8_result; 32, string:'id'; 33, identifier:lower; 34, argument_list; 35, try_statement; 35, 36; 35, 44; 36, block; 36, 37; 37, return_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:priority; 41, identifier:index; 42, argument_list; 42, 43; 43, identifier:key; 44, except_clause; 44, 45; 44, 46; 45, identifier:ValueError; 46, block; 46, 47; 47, try_statement; 47, 48; 47, 60; 48, block; 48, 49; 49, return_statement; 49, 50; 50, binary_operator:+; 50, 51; 50, 59; 51, binary_operator:+; 51, 52; 51, 53; 52, identifier:middle_index; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:lowest_priority; 56, identifier:index; 57, argument_list; 57, 58; 58, identifier:key; 59, integer:1; 60, except_clause; 60, 61; 60, 62; 61, identifier:ValueError; 62, block; 62, 63; 63, return_statement; 63, 64; 64, identifier:middle_index
|
def _priority_key(pep8_result):
priority = [
'e701',
'e702',
'e225', 'e231',
'e201',
'e262'
]
middle_index = 10000
lowest_priority = [
'e501'
]
key = pep8_result['id'].lower()
try:
return priority.index(key)
except ValueError:
try:
return middle_index + lowest_priority.index(key) + 1
except ValueError:
return middle_index
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:git_hook; 3, parameters; 3, 4; 4, default_parameter; 4, 5; 4, 6; 5, identifier:strict; 6, False; 7, block; 7, 8; 7, 12; 7, 19; 7, 23; 7, 76; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:diff_cmd; 11, string:"git diff-index --cached --name-only --diff-filter=ACMRTUXB HEAD"; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:files_modified; 15, call; 15, 16; 15, 17; 16, identifier:get_lines; 17, argument_list; 17, 18; 18, identifier:diff_cmd; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:errors; 22, integer:0; 23, for_statement; 23, 24; 23, 25; 23, 26; 24, identifier:filename; 25, identifier:files_modified; 26, block; 26, 27; 27, if_statement; 27, 28; 27, 34; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:filename; 31, identifier:endswith; 32, argument_list; 32, 33; 33, string:'.py'; 34, block; 34, 35; 34, 41; 34, 48; 34, 67; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:staged_cmd; 38, binary_operator:%; 38, 39; 38, 40; 39, string:"git show :%s"; 40, identifier:filename; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:staged_contents; 44, call; 44, 45; 44, 46; 45, identifier:get_output; 46, argument_list; 46, 47; 47, identifier:staged_cmd; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:sort; 51, call; 51, 52; 51, 53; 52, identifier:SortImports; 53, argument_list; 53, 54; 53, 57; 53, 64; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:file_path; 56, identifier:filename; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:file_contents; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:staged_contents; 62, identifier:decode; 63, argument_list; 64, keyword_argument; 64, 65; 64, 66; 65, identifier:check; 66, True; 67, if_statement; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:sort; 70, identifier:incorrectly_sorted; 71, block; 71, 72; 72, expression_statement; 72, 73; 73, augmented_assignment:+=; 73, 74; 73, 75; 74, identifier:errors; 75, integer:1; 76, return_statement; 76, 77; 77, conditional_expression:if; 77, 78; 77, 79; 77, 80; 78, identifier:errors; 79, identifier:strict; 80, integer:0
|
def git_hook(strict=False):
diff_cmd = "git diff-index --cached --name-only --diff-filter=ACMRTUXB HEAD"
files_modified = get_lines(diff_cmd)
errors = 0
for filename in files_modified:
if filename.endswith('.py'):
staged_cmd = "git show :%s" % filename
staged_contents = get_output(staged_cmd)
sort = SortImports(
file_path=filename,
file_contents=staged_contents.decode(),
check=True
)
if sort.incorrectly_sorted:
errors += 1
return errors if strict else 0
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_all_fix_names; 3, parameters; 3, 4; 3, 5; 4, identifier:fixer_pkg; 5, default_parameter; 5, 6; 5, 7; 6, identifier:remove_prefix; 7, True; 8, block; 8, 9; 8, 20; 8, 33; 8, 37; 8, 87; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:pkg; 12, call; 12, 13; 12, 14; 13, identifier:__import__; 14, argument_list; 14, 15; 14, 16; 14, 17; 14, 18; 15, identifier:fixer_pkg; 16, list:[]; 17, list:[]; 18, list:["*"]; 18, 19; 19, string:"*"; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:fixer_dir; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:os; 27, identifier:path; 28, identifier:dirname; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:pkg; 32, identifier:__file__; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:fix_names; 36, list:[]; 37, for_statement; 37, 38; 37, 39; 37, 48; 38, identifier:name; 39, call; 39, 40; 39, 41; 40, identifier:sorted; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:os; 45, identifier:listdir; 46, argument_list; 46, 47; 47, identifier:fixer_dir; 48, block; 48, 49; 49, if_statement; 49, 50; 49, 63; 50, boolean_operator:and; 50, 51; 50, 57; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:name; 54, identifier:startswith; 55, argument_list; 55, 56; 56, string:"fix_"; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:name; 60, identifier:endswith; 61, argument_list; 61, 62; 62, string:".py"; 63, block; 63, 64; 63, 75; 64, if_statement; 64, 65; 64, 66; 65, identifier:remove_prefix; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:name; 70, subscript; 70, 71; 70, 72; 71, identifier:name; 72, slice; 72, 73; 72, 74; 73, integer:4; 74, colon; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:fix_names; 79, identifier:append; 80, argument_list; 80, 81; 81, subscript; 81, 82; 81, 83; 82, identifier:name; 83, slice; 83, 84; 83, 85; 84, colon; 85, unary_operator:-; 85, 86; 86, integer:3; 87, return_statement; 87, 88; 88, identifier:fix_names
|
def get_all_fix_names(fixer_pkg, remove_prefix=True):
pkg = __import__(fixer_pkg, [], [], ["*"])
fixer_dir = os.path.dirname(pkg.__file__)
fix_names = []
for name in sorted(os.listdir(fixer_dir)):
if name.startswith("fix_") and name.endswith(".py"):
if remove_prefix:
name = name[4:]
fix_names.append(name[:-3])
return fix_names
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:check; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 8; 6, 40; 7, identifier:unsorted; 8, call; 8, 9; 8, 10; 9, identifier:iter; 10, generator_expression; 10, 11; 10, 14; 10, 25; 11, subscript; 11, 12; 11, 13; 12, identifier:self; 13, identifier:i; 14, for_in_clause; 14, 15; 14, 16; 15, identifier:i; 16, call; 16, 17; 16, 18; 17, identifier:range; 18, argument_list; 18, 19; 19, binary_operator:-; 19, 20; 19, 24; 20, call; 20, 21; 20, 22; 21, identifier:len; 22, argument_list; 22, 23; 23, identifier:self; 24, integer:2; 25, if_clause; 25, 26; 26, not_operator; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:operator; 30, identifier:le; 31, argument_list; 31, 32; 31, 35; 32, subscript; 32, 33; 32, 34; 33, identifier:self; 34, identifier:i; 35, subscript; 35, 36; 35, 37; 36, identifier:self; 37, binary_operator:+; 37, 38; 37, 39; 38, identifier:i; 39, integer:1; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:resort; 46, argument_list; 46, 47; 47, identifier:unsorted
|
def check(self):
for unsorted in iter(self[i] for i in range(len(self) - 2) if not operator.le(self[i], self[i + 1])):
self.resort(unsorted)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:sort_by_list_order; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:sortlist; 5, identifier:reflist; 6, default_parameter; 6, 7; 6, 8; 7, identifier:reverse; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:fltr; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:slemap; 14, None; 15, block; 15, 16; 15, 59; 15, 96; 16, function_definition; 16, 17; 16, 18; 16, 20; 17, function_name:keyfunc; 18, parameters; 18, 19; 19, identifier:entry; 20, block; 20, 21; 20, 33; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:is; 22, 23; 22, 24; 23, identifier:slemap; 24, None; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:rle; 29, call; 29, 30; 29, 31; 30, identifier:slemap; 31, argument_list; 31, 32; 32, identifier:entry; 33, if_statement; 33, 34; 33, 37; 33, 45; 34, comparison_operator:in; 34, 35; 34, 36; 35, identifier:rle; 36, identifier:reflist; 37, block; 37, 38; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:reflist; 42, identifier:index; 43, argument_list; 43, 44; 44, identifier:rle; 45, else_clause; 45, 46; 46, block; 46, 47; 47, return_statement; 47, 48; 48, binary_operator:+; 48, 49; 48, 55; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:sortlist; 52, identifier:index; 53, argument_list; 53, 54; 54, identifier:entry; 55, call; 55, 56; 55, 57; 56, identifier:len; 57, argument_list; 57, 58; 58, identifier:reflist; 59, if_statement; 59, 60; 59, 61; 60, identifier:fltr; 61, block; 61, 62; 62, if_statement; 62, 63; 62, 64; 62, 81; 63, identifier:slemap; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:sortlist; 68, call; 68, 69; 68, 70; 69, identifier:filter; 70, argument_list; 70, 71; 70, 80; 71, lambda; 71, 72; 71, 74; 72, lambda_parameters; 72, 73; 73, identifier:x; 74, comparison_operator:in; 74, 75; 74, 79; 75, call; 75, 76; 75, 77; 76, identifier:slemap; 77, argument_list; 77, 78; 78, identifier:x; 79, identifier:reflist; 80, identifier:sortlist; 81, else_clause; 81, 82; 82, block; 82, 83; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:sortlist; 86, call; 86, 87; 86, 88; 87, identifier:filter; 88, argument_list; 88, 89; 88, 95; 89, lambda; 89, 90; 89, 92; 90, lambda_parameters; 90, 91; 91, identifier:x; 92, comparison_operator:in; 92, 93; 92, 94; 93, identifier:x; 94, identifier:reflist; 95, identifier:sortlist; 96, return_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:sorted; 99, argument_list; 99, 100; 99, 101; 99, 104; 100, identifier:sortlist; 101, keyword_argument; 101, 102; 101, 103; 102, identifier:key; 103, identifier:keyfunc; 104, keyword_argument; 104, 105; 104, 106; 105, identifier:reverse; 106, identifier:reverse
|
def sort_by_list_order(sortlist, reflist, reverse=False, fltr=False,
slemap=None):
def keyfunc(entry):
if slemap is not None:
rle = slemap(entry)
if rle in reflist:
return reflist.index(rle)
else:
return sortlist.index(entry) + len(reflist)
if fltr:
if slemap:
sortlist = filter(lambda x: slemap(x) in reflist, sortlist)
else:
sortlist = filter(lambda x: x in reflist, sortlist)
return sorted(sortlist, key=keyfunc, reverse=reverse)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:strategy; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:names; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 71; 10, function_definition; 10, 11; 10, 12; 10, 14; 11, function_name:decorator; 12, parameters; 12, 13; 13, identifier:func; 14, block; 14, 15; 14, 25; 14, 48; 14, 63; 14, 69; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:keep_name; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:kwargs; 21, identifier:pop; 22, argument_list; 22, 23; 22, 24; 23, string:"keep_name"; 24, False; 25, if_statement; 25, 26; 25, 27; 26, identifier:kwargs; 27, block; 27, 28; 27, 38; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:key; 31, call; 31, 32; 31, 33; 32, identifier:next; 33, argument_list; 33, 34; 34, call; 34, 35; 34, 36; 35, identifier:iter; 36, argument_list; 36, 37; 37, identifier:kwargs; 38, raise_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:TypeError; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, string:"Unknown keyword argument '{}'"; 45, identifier:format; 46, argument_list; 46, 47; 47, identifier:key; 48, if_statement; 48, 49; 48, 51; 49, not_operator; 49, 50; 50, identifier:keep_name; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:func; 56, identifier:__name__; 57, call; 57, 58; 57, 59; 58, identifier:str; 59, argument_list; 59, 60; 60, subscript; 60, 61; 60, 62; 61, identifier:names; 62, integer:0; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, subscript; 65, 66; 65, 67; 66, identifier:self; 67, identifier:names; 68, identifier:func; 69, return_statement; 69, 70; 70, identifier:self; 71, return_statement; 71, 72; 72, identifier:decorator
|
def strategy(self, *names, **kwargs):
def decorator(func):
keep_name = kwargs.pop("keep_name", False)
if kwargs:
key = next(iter(kwargs))
raise TypeError("Unknown keyword argument '{}'".format(key))
if not keep_name:
func.__name__ = str(names[0])
self[names] = func
return self
return decorator
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:humansort; 3, parameters; 3, 4; 4, identifier:l; 5, block; 5, 6; 5, 9; 5, 48; 5, 57; 6, import_statement; 6, 7; 7, dotted_name; 7, 8; 8, identifier:re; 9, function_definition; 9, 10; 9, 11; 9, 13; 10, function_name:alphanum_key; 11, parameters; 11, 12; 12, identifier:s; 13, block; 13, 14; 13, 33; 14, function_definition; 14, 15; 14, 16; 14, 18; 15, function_name:tryint; 16, parameters; 16, 17; 17, identifier:s; 18, block; 18, 19; 18, 31; 19, if_statement; 19, 20; 19, 25; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:s; 23, identifier:isdigit; 24, argument_list; 25, block; 25, 26; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 29; 28, identifier:int; 29, argument_list; 29, 30; 30, identifier:s; 31, return_statement; 31, 32; 32, identifier:s; 33, return_statement; 33, 34; 34, list_comprehension; 34, 35; 34, 39; 35, call; 35, 36; 35, 37; 36, identifier:tryint; 37, argument_list; 37, 38; 38, identifier:c; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:c; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:re; 44, identifier:split; 45, argument_list; 45, 46; 45, 47; 46, string:"([0-9]+)"; 47, identifier:s; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:l; 52, identifier:sort; 53, argument_list; 53, 54; 54, keyword_argument; 54, 55; 54, 56; 55, identifier:key; 56, identifier:alphanum_key; 57, return_statement; 57, 58; 58, None
|
def humansort(l):
import re
def alphanum_key(s):
def tryint(s):
if s.isdigit():
return int(s)
return s
return [tryint(c) for c in re.split("([0-9]+)", s)]
l.sort(key=alphanum_key)
return None
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 25; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:name; 7, string:''; 8, default_parameter; 8, 9; 8, 10; 9, identifier:type; 10, string:''; 11, default_parameter; 11, 12; 11, 13; 12, identifier:agent; 13, string:''; 14, default_parameter; 14, 15; 14, 16; 15, identifier:scanner; 16, string:''; 17, default_parameter; 17, 18; 17, 19; 18, identifier:location; 19, string:''; 20, default_parameter; 20, 21; 20, 22; 21, identifier:language; 22, string:'en'; 23, list_splat_pattern; 23, 24; 24, identifier:args; 25, dictionary_splat_pattern; 25, 26; 26, identifier:kwargs; 27, block; 27, 28; 27, 49; 27, 59; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:part; 31, binary_operator:%; 31, 32; 31, 33; 32, string:'/library/sections?name=%s&type=%s&agent=%s&scanner=%s&language=%s&location=%s'; 33, tuple; 33, 34; 33, 38; 33, 39; 33, 40; 33, 44; 33, 45; 34, call; 34, 35; 34, 36; 35, identifier:quote_plus; 36, argument_list; 36, 37; 37, identifier:name; 38, identifier:type; 39, identifier:agent; 40, call; 40, 41; 40, 42; 41, identifier:quote_plus; 42, argument_list; 42, 43; 43, identifier:scanner; 44, identifier:language; 45, call; 45, 46; 45, 47; 46, identifier:quote_plus; 47, argument_list; 47, 48; 48, identifier:location; 49, if_statement; 49, 50; 49, 51; 50, identifier:kwargs; 51, block; 51, 52; 52, expression_statement; 52, 53; 53, augmented_assignment:+=; 53, 54; 53, 55; 54, identifier:part; 55, call; 55, 56; 55, 57; 56, identifier:urlencode; 57, argument_list; 57, 58; 58, identifier:kwargs; 59, return_statement; 59, 60; 60, call; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:self; 64, identifier:_server; 65, identifier:query; 66, argument_list; 66, 67; 66, 68; 67, identifier:part; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:method; 70, attribute; 70, 71; 70, 76; 71, attribute; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_server; 75, identifier:_session; 76, identifier:post
|
def add(self, name='', type='', agent='', scanner='', location='', language='en', *args, **kwargs):
part = '/library/sections?name=%s&type=%s&agent=%s&scanner=%s&language=%s&location=%s' % (
quote_plus(name), type, agent, quote_plus(scanner), language, quote_plus(location))
if kwargs:
part += urlencode(kwargs)
return self._server.query(part, method=self._server._session.post)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:all; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, None; 8, dictionary_splat_pattern; 8, 9; 9, identifier:kwargs; 10, block; 10, 11; 10, 15; 10, 26; 10, 36; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:sortStr; 14, string:''; 15, if_statement; 15, 16; 15, 19; 16, comparison_operator:is; 16, 17; 16, 18; 17, identifier:sort; 18, None; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:sortStr; 23, binary_operator:+; 23, 24; 23, 25; 24, string:'?sort='; 25, identifier:sort; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:key; 29, binary_operator:%; 29, 30; 29, 31; 30, string:'/library/sections/%s/all%s'; 31, tuple; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:key; 35, identifier:sortStr; 36, return_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:fetchItems; 41, argument_list; 41, 42; 41, 43; 42, identifier:key; 43, dictionary_splat; 43, 44; 44, identifier:kwargs
|
def all(self, sort=None, **kwargs):
sortStr = ''
if sort is not None:
sortStr = '?sort=' + sort
key = '/library/sections/%s/all%s' % (self.key, sortStr)
return self.fetchItems(key, **kwargs)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:as_sorted_list; 3, parameters; 3, 4; 4, identifier:options; 5, block; 5, 6; 5, 29; 6, if_statement; 6, 7; 6, 13; 7, comparison_operator:>; 7, 8; 7, 12; 8, call; 8, 9; 8, 10; 9, identifier:len; 10, argument_list; 10, 11; 11, identifier:options; 12, integer:0; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:options; 17, call; 17, 18; 17, 19; 18, identifier:sorted; 19, argument_list; 19, 20; 19, 21; 20, identifier:options; 21, keyword_argument; 21, 22; 21, 23; 22, identifier:key; 23, lambda; 23, 24; 23, 26; 24, lambda_parameters; 24, 25; 25, identifier:o; 26, attribute; 26, 27; 26, 28; 27, identifier:o; 28, identifier:number; 29, return_statement; 29, 30; 30, identifier:options
|
def as_sorted_list(options):
if len(options) > 0:
options = sorted(options, key=lambda o: o.number)
return options
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:df_all; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:phot; 6, block; 6, 7; 6, 30; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:df; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:pd; 13, identifier:concat; 14, argument_list; 14, 15; 15, list_comprehension; 15, 16; 15, 22; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:to_df; 20, argument_list; 20, 21; 21, identifier:f; 22, for_in_clause; 22, 23; 22, 24; 23, identifier:f; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:get_filenames; 28, argument_list; 28, 29; 29, identifier:phot; 30, return_statement; 30, 31; 31, identifier:df
|
def df_all(self, phot):
df = pd.concat([self.to_df(f) for f in self.get_filenames(phot)])
return df
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:searchsorted; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:arr; 5, identifier:N; 6, identifier:x; 7, block; 7, 8; 7, 12; 7, 18; 7, 22; 7, 31; 7, 90; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:L; 11, integer:0; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:R; 15, binary_operator:-; 15, 16; 15, 17; 16, identifier:N; 17, integer:1; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:done; 21, False; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:m; 25, binary_operator://; 25, 26; 25, 30; 26, parenthesized_expression; 26, 27; 27, binary_operator:+; 27, 28; 27, 29; 28, identifier:L; 29, identifier:R; 30, integer:2; 31, while_statement; 31, 32; 31, 34; 32, not_operator; 32, 33; 33, identifier:done; 34, block; 34, 35; 34, 72; 34, 81; 35, if_statement; 35, 36; 35, 41; 35, 48; 35, 61; 36, comparison_operator:<; 36, 37; 36, 40; 37, subscript; 37, 38; 37, 39; 38, identifier:arr; 39, identifier:m; 40, identifier:x; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:L; 45, binary_operator:+; 45, 46; 45, 47; 46, identifier:m; 47, integer:1; 48, elif_clause; 48, 49; 48, 54; 49, comparison_operator:>; 49, 50; 49, 53; 50, subscript; 50, 51; 50, 52; 51, identifier:arr; 52, identifier:m; 53, identifier:x; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:R; 58, binary_operator:-; 58, 59; 58, 60; 59, identifier:m; 60, integer:1; 61, elif_clause; 61, 62; 61, 67; 62, comparison_operator:==; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:arr; 65, identifier:m; 66, identifier:x; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:done; 71, True; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:m; 75, binary_operator://; 75, 76; 75, 80; 76, parenthesized_expression; 76, 77; 77, binary_operator:+; 77, 78; 77, 79; 78, identifier:L; 79, identifier:R; 80, integer:2; 81, if_statement; 81, 82; 81, 85; 82, comparison_operator:>; 82, 83; 82, 84; 83, identifier:L; 84, identifier:R; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:done; 89, True; 90, return_statement; 90, 91; 91, identifier:L
|
def searchsorted(arr, N, x):
L = 0
R = N-1
done = False
m = (L+R)//2
while not done:
if arr[m] < x:
L = m + 1
elif arr[m] > x:
R = m - 1
elif arr[m] == x:
done = True
m = (L+R)//2
if L>R:
done = True
return L
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_plot_spectrogram; 3, parameters; 3, 4; 3, 5; 4, identifier:G; 5, identifier:node_idx; 6, block; 6, 7; 6, 9; 6, 14; 6, 23; 6, 38; 6, 48; 6, 65; 6, 74; 6, 90; 6, 104; 6, 133; 6, 147; 6, 157; 6, 174; 6, 182; 6, 201; 6, 218; 6, 235; 6, 241; 6, 302; 6, 309; 6, 311; 7, expression_statement; 7, 8; 8, identifier:r; 9, import_from_statement; 9, 10; 9, 12; 10, dotted_name; 10, 11; 11, identifier:pygsp; 12, dotted_name; 12, 13; 13, identifier:features; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 20; 16, pattern_list; 16, 17; 16, 18; 16, 19; 17, identifier:qtg; 18, identifier:_; 19, identifier:_; 20, call; 20, 21; 20, 22; 21, identifier:_import_qtg; 22, argument_list; 23, if_statement; 23, 24; 23, 30; 24, not_operator; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:hasattr; 27, argument_list; 27, 28; 27, 29; 28, identifier:G; 29, string:'spectr'; 30, block; 30, 31; 31, expression_statement; 31, 32; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:features; 35, identifier:compute_spectrogram; 36, argument_list; 36, 37; 37, identifier:G; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:M; 41, subscript; 41, 42; 41, 47; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:G; 45, identifier:spectr; 46, identifier:shape; 47, integer:1; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:spectr; 51, conditional_expression:if; 51, 52; 51, 59; 51, 62; 52, subscript; 52, 53; 52, 56; 52, 57; 53, attribute; 53, 54; 53, 55; 54, identifier:G; 55, identifier:spectr; 56, identifier:node_idx; 57, slice; 57, 58; 58, colon; 59, comparison_operator:is; 59, 60; 59, 61; 60, identifier:node_idx; 61, None; 62, attribute; 62, 63; 62, 64; 63, identifier:G; 64, identifier:spectr; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:spectr; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:np; 71, identifier:ravel; 72, argument_list; 72, 73; 73, identifier:spectr; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, pattern_list; 76, 77; 76, 78; 77, identifier:min_spec; 78, identifier:max_spec; 79, expression_list; 79, 80; 79, 85; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:spectr; 83, identifier:min; 84, argument_list; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:spectr; 88, identifier:max; 89, argument_list; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 92, identifier:pos; 93, call; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:np; 96, identifier:array; 97, argument_list; 97, 98; 98, list:[0., 0.25, 0.5, 0.75, 1.]; 98, 99; 98, 100; 98, 101; 98, 102; 98, 103; 99, float:0.; 100, float:0.25; 101, float:0.5; 102, float:0.75; 103, float:1.; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 107; 106, identifier:color; 107, list:[[20, 133, 212, 255], [53, 42, 135, 255], [48, 174, 170, 255],
[210, 184, 87, 255], [249, 251, 14, 255]]; 107, 108; 107, 113; 107, 118; 107, 123; 107, 128; 108, list:[20, 133, 212, 255]; 108, 109; 108, 110; 108, 111; 108, 112; 109, integer:20; 110, integer:133; 111, integer:212; 112, integer:255; 113, list:[53, 42, 135, 255]; 113, 114; 113, 115; 113, 116; 113, 117; 114, integer:53; 115, integer:42; 116, integer:135; 117, integer:255; 118, list:[48, 174, 170, 255]; 118, 119; 118, 120; 118, 121; 118, 122; 119, integer:48; 120, integer:174; 121, integer:170; 122, integer:255; 123, list:[210, 184, 87, 255]; 123, 124; 123, 125; 123, 126; 123, 127; 124, integer:210; 125, integer:184; 126, integer:87; 127, integer:255; 128, list:[249, 251, 14, 255]; 128, 129; 128, 130; 128, 131; 128, 132; 129, integer:249; 130, integer:251; 131, integer:14; 132, integer:255; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:color; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:np; 139, identifier:array; 140, argument_list; 140, 141; 140, 142; 141, identifier:color; 142, keyword_argument; 142, 143; 142, 144; 143, identifier:dtype; 144, attribute; 144, 145; 144, 146; 145, identifier:np; 146, identifier:ubyte; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:cmap; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:qtg; 153, identifier:ColorMap; 154, argument_list; 154, 155; 154, 156; 155, identifier:pos; 156, identifier:color; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 160; 159, identifier:spectr; 160, binary_operator:/; 160, 161; 160, 170; 161, parenthesized_expression; 161, 162; 162, binary_operator:-; 162, 163; 162, 169; 163, call; 163, 164; 163, 167; 164, attribute; 164, 165; 164, 166; 165, identifier:spectr; 166, identifier:astype; 167, argument_list; 167, 168; 168, identifier:float; 169, identifier:min_spec; 170, parenthesized_expression; 170, 171; 171, binary_operator:-; 171, 172; 171, 173; 172, identifier:max_spec; 173, identifier:min_spec; 174, expression_statement; 174, 175; 175, assignment; 175, 176; 175, 177; 176, identifier:w; 177, call; 177, 178; 177, 181; 178, attribute; 178, 179; 178, 180; 179, identifier:qtg; 180, identifier:GraphicsWindow; 181, argument_list; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:w; 186, identifier:setWindowTitle; 187, argument_list; 187, 188; 188, call; 188, 189; 188, 192; 189, attribute; 189, 190; 189, 191; 190, string:"Spectrogram of {}"; 191, identifier:format; 192, argument_list; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:G; 196, identifier:__repr__; 197, argument_list; 197, 198; 198, keyword_argument; 198, 199; 198, 200; 199, identifier:limit; 200, integer:4; 201, expression_statement; 201, 202; 202, assignment; 202, 203; 202, 204; 203, identifier:label; 204, call; 204, 205; 204, 208; 205, attribute; 205, 206; 205, 207; 206, string:'frequencies {}:{:.2f}:{:.2f}'; 207, identifier:format; 208, argument_list; 208, 209; 208, 210; 208, 215; 209, integer:0; 210, binary_operator:/; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:G; 213, identifier:lmax; 214, identifier:M; 215, attribute; 215, 216; 215, 217; 216, identifier:G; 217, identifier:lmax; 218, expression_statement; 218, 219; 219, assignment; 219, 220; 219, 221; 220, identifier:v; 221, call; 221, 222; 221, 225; 222, attribute; 222, 223; 222, 224; 223, identifier:w; 224, identifier:addPlot; 225, argument_list; 225, 226; 226, keyword_argument; 226, 227; 226, 228; 227, identifier:labels; 228, dictionary; 228, 229; 228, 232; 229, pair; 229, 230; 229, 231; 230, string:'bottom'; 231, string:'nodes'; 232, pair; 232, 233; 232, 234; 233, string:'left'; 234, identifier:label; 235, expression_statement; 235, 236; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:v; 239, identifier:setAspectLocked; 240, argument_list; 241, expression_statement; 241, 242; 242, assignment; 242, 243; 242, 244; 243, identifier:spi; 244, call; 244, 245; 244, 248; 245, attribute; 245, 246; 245, 247; 246, identifier:qtg; 247, identifier:ScatterPlotItem; 248, argument_list; 248, 249; 248, 263; 248, 284; 248, 287; 248, 290; 248, 293; 249, call; 249, 250; 249, 253; 250, attribute; 250, 251; 250, 252; 251, identifier:np; 252, identifier:repeat; 253, argument_list; 253, 254; 253, 262; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:np; 257, identifier:arange; 258, argument_list; 258, 259; 259, attribute; 259, 260; 259, 261; 260, identifier:G; 261, identifier:N; 262, identifier:M; 263, call; 263, 264; 263, 267; 264, attribute; 264, 265; 264, 266; 265, identifier:np; 266, identifier:ravel; 267, argument_list; 267, 268; 268, call; 268, 269; 268, 272; 269, attribute; 269, 270; 269, 271; 270, identifier:np; 271, identifier:tile; 272, argument_list; 272, 273; 272, 279; 273, call; 273, 274; 273, 277; 274, attribute; 274, 275; 274, 276; 275, identifier:np; 276, identifier:arange; 277, argument_list; 277, 278; 278, identifier:M; 279, tuple; 279, 280; 279, 281; 280, integer:1; 281, attribute; 281, 282; 281, 283; 282, identifier:G; 283, identifier:N; 284, keyword_argument; 284, 285; 284, 286; 285, identifier:pxMode; 286, False; 287, keyword_argument; 287, 288; 287, 289; 288, identifier:symbol; 289, string:'s'; 290, keyword_argument; 290, 291; 290, 292; 291, identifier:size; 292, integer:1; 293, keyword_argument; 293, 294; 293, 295; 294, identifier:brush; 295, call; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:cmap; 298, identifier:map; 299, argument_list; 299, 300; 299, 301; 300, identifier:spectr; 301, string:'qcolor'; 302, expression_statement; 302, 303; 303, call; 303, 304; 303, 307; 304, attribute; 304, 305; 304, 306; 305, identifier:v; 306, identifier:addItem; 307, argument_list; 307, 308; 308, identifier:spi; 309, global_statement; 309, 310; 310, identifier:_qtg_windows; 311, expression_statement; 311, 312; 312, call; 312, 313; 312, 316; 313, attribute; 313, 314; 313, 315; 314, identifier:_qtg_windows; 315, identifier:append; 316, argument_list; 316, 317; 317, identifier:w
|
def _plot_spectrogram(G, node_idx):
r
from pygsp import features
qtg, _, _ = _import_qtg()
if not hasattr(G, 'spectr'):
features.compute_spectrogram(G)
M = G.spectr.shape[1]
spectr = G.spectr[node_idx, :] if node_idx is not None else G.spectr
spectr = np.ravel(spectr)
min_spec, max_spec = spectr.min(), spectr.max()
pos = np.array([0., 0.25, 0.5, 0.75, 1.])
color = [[20, 133, 212, 255], [53, 42, 135, 255], [48, 174, 170, 255],
[210, 184, 87, 255], [249, 251, 14, 255]]
color = np.array(color, dtype=np.ubyte)
cmap = qtg.ColorMap(pos, color)
spectr = (spectr.astype(float) - min_spec) / (max_spec - min_spec)
w = qtg.GraphicsWindow()
w.setWindowTitle("Spectrogram of {}".format(G.__repr__(limit=4)))
label = 'frequencies {}:{:.2f}:{:.2f}'.format(0, G.lmax/M, G.lmax)
v = w.addPlot(labels={'bottom': 'nodes',
'left': label})
v.setAspectLocked()
spi = qtg.ScatterPlotItem(np.repeat(np.arange(G.N), M),
np.ravel(np.tile(np.arange(M), (1, G.N))),
pxMode=False,
symbol='s',
size=1,
brush=cmap.map(spectr, 'qcolor'))
v.addItem(spi)
global _qtg_windows
_qtg_windows.append(w)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:write_omega_scan_config; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:channellist; 5, identifier:fobj; 6, default_parameter; 6, 7; 6, 8; 7, identifier:header; 8, True; 9, block; 9, 10; 9, 35; 10, if_statement; 10, 11; 10, 16; 10, 21; 11, call; 11, 12; 11, 13; 12, identifier:isinstance; 13, argument_list; 13, 14; 13, 15; 14, identifier:fobj; 15, identifier:FILE_LIKE; 16, block; 16, 17; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:close; 20, False; 21, else_clause; 21, 22; 22, block; 22, 23; 22, 31; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:fobj; 26, call; 26, 27; 26, 28; 27, identifier:open; 28, argument_list; 28, 29; 28, 30; 29, identifier:fobj; 30, string:'w'; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:close; 34, True; 35, try_statement; 35, 36; 35, 90; 36, block; 36, 37; 36, 47; 37, if_statement; 37, 38; 37, 39; 38, identifier:header; 39, block; 39, 40; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 41, 46; 42, identifier:print; 43, ERROR; 43, 44; 43, 45; 44, string:'
print('; 45, identifier:group; 46, None; 47, for_statement; 47, 48; 47, 49; 47, 50; 48, identifier:channel; 49, identifier:channellist; 50, block; 50, 51; 50, 74; 50, 82; 51, if_statement; 51, 52; 51, 57; 52, comparison_operator:!=; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:channel; 55, identifier:group; 56, identifier:group; 57, block; 57, 58; 57, 64; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:group; 61, attribute; 61, 62; 61, 63; 62, identifier:channel; 63, identifier:group; 64, expression_statement; 64, 65; 65, call; 65, 66; 65, 67; 66, identifier:print; 67, argument_list; 67, 68; 67, 71; 68, binary_operator:%; 68, 69; 68, 70; 69, string:'\n[%s]'; 70, identifier:group; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:file; 73, identifier:fobj; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 77; 76, identifier:print; 77, argument_list; 77, 78; 77, 79; 78, string:""; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:file; 81, identifier:fobj; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 85; 84, identifier:print_omega_channel; 85, argument_list; 85, 86; 85, 87; 86, identifier:channel; 87, keyword_argument; 87, 88; 87, 89; 88, identifier:file; 89, identifier:fobj; 90, finally_clause; 90, 91; 91, block; 91, 92; 92, if_statement; 92, 93; 92, 94; 93, identifier:close; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:fobj; 99, identifier:close; 100, argument_list
|
def write_omega_scan_config(channellist, fobj, header=True):
if isinstance(fobj, FILE_LIKE):
close = False
else:
fobj = open(fobj, 'w')
close = True
try:
if header:
print('
print('
group = None
for channel in channellist:
if channel.group != group:
group = channel.group
print('\n[%s]' % group, file=fobj)
print("", file=fobj)
print_omega_channel(channel, file=fobj)
finally:
if close:
fobj.close()
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:coalesce; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 22; 5, 28; 5, 35; 5, 153; 5, 159; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:self; 10, identifier:sort; 11, argument_list; 11, 12; 12, keyword_argument; 12, 13; 12, 14; 13, identifier:key; 14, lambda; 14, 15; 14, 17; 15, lambda_parameters; 15, 16; 16, identifier:ts; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:ts; 20, identifier:t0; 21, identifier:value; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:i; 25, assignment; 25, 26; 25, 27; 26, identifier:j; 27, integer:0; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:N; 31, call; 31, 32; 31, 33; 32, identifier:len; 33, argument_list; 33, 34; 34, identifier:self; 35, while_statement; 35, 36; 35, 39; 36, comparison_operator:<; 36, 37; 36, 38; 37, identifier:j; 38, identifier:N; 39, block; 39, 40; 39, 46; 39, 50; 39, 149; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:this; 43, subscript; 43, 44; 43, 45; 44, identifier:self; 45, identifier:j; 46, expression_statement; 46, 47; 47, augmented_assignment:+=; 47, 48; 47, 49; 48, identifier:j; 49, integer:1; 50, if_statement; 50, 51; 50, 65; 50, 141; 51, boolean_operator:and; 51, 52; 51, 55; 52, comparison_operator:<; 52, 53; 52, 54; 53, identifier:j; 54, identifier:N; 55, comparison_operator:==; 55, 56; 55, 64; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:this; 59, identifier:is_contiguous; 60, argument_list; 60, 61; 61, subscript; 61, 62; 61, 63; 62, identifier:self; 63, identifier:j; 64, integer:1; 65, block; 65, 66; 66, while_statement; 66, 67; 66, 79; 67, boolean_operator:and; 67, 68; 67, 71; 68, comparison_operator:<; 68, 69; 68, 70; 69, identifier:j; 70, identifier:N; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:this; 74, identifier:is_contiguous; 75, argument_list; 75, 76; 76, subscript; 76, 77; 76, 78; 77, identifier:self; 78, identifier:j; 79, block; 79, 80; 79, 137; 80, try_statement; 80, 81; 80, 97; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 85; 84, identifier:this; 85, assignment; 85, 86; 85, 89; 86, subscript; 86, 87; 86, 88; 87, identifier:self; 88, identifier:i; 89, call; 89, 90; 89, 93; 90, attribute; 90, 91; 90, 92; 91, identifier:this; 92, identifier:append; 93, argument_list; 93, 94; 94, subscript; 94, 95; 94, 96; 95, identifier:self; 96, identifier:j; 97, except_clause; 97, 98; 97, 102; 98, as_pattern; 98, 99; 98, 100; 99, identifier:ValueError; 100, as_pattern_target; 100, 101; 101, identifier:exc; 102, block; 102, 103; 103, if_statement; 103, 104; 103, 110; 103, 134; 104, comparison_operator:in; 104, 105; 104, 106; 105, string:'cannot resize this array'; 106, call; 106, 107; 106, 108; 107, identifier:str; 108, argument_list; 108, 109; 109, identifier:exc; 110, block; 110, 111; 110, 119; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:this; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:this; 117, identifier:copy; 118, argument_list; 119, expression_statement; 119, 120; 120, assignment; 120, 121; 120, 122; 121, identifier:this; 122, assignment; 122, 123; 122, 126; 123, subscript; 123, 124; 123, 125; 124, identifier:self; 125, identifier:i; 126, call; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:this; 129, identifier:append; 130, argument_list; 130, 131; 131, subscript; 131, 132; 131, 133; 132, identifier:self; 133, identifier:j; 134, else_clause; 134, 135; 135, block; 135, 136; 136, raise_statement; 137, expression_statement; 137, 138; 138, augmented_assignment:+=; 138, 139; 138, 140; 139, identifier:j; 140, integer:1; 141, else_clause; 141, 142; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:self; 147, identifier:i; 148, identifier:this; 149, expression_statement; 149, 150; 150, augmented_assignment:+=; 150, 151; 150, 152; 151, identifier:i; 152, integer:1; 153, delete_statement; 153, 154; 154, subscript; 154, 155; 154, 156; 155, identifier:self; 156, slice; 156, 157; 156, 158; 157, identifier:i; 158, colon; 159, return_statement; 159, 160; 160, identifier:self
|
def coalesce(self):
self.sort(key=lambda ts: ts.t0.value)
i = j = 0
N = len(self)
while j < N:
this = self[j]
j += 1
if j < N and this.is_contiguous(self[j]) == 1:
while j < N and this.is_contiguous(self[j]):
try:
this = self[i] = this.append(self[j])
except ValueError as exc:
if 'cannot resize this array' in str(exc):
this = this.copy()
this = self[i] = this.append(self[j])
else:
raise
j += 1
else:
self[i] = this
i += 1
del self[i:]
return self
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:read_cache; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:cachefile; 5, default_parameter; 5, 6; 5, 7; 6, identifier:coltype; 7, identifier:LIGOTimeGPS; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:segment; 13, None; 14, block; 14, 15; 14, 52; 14, 68; 14, 81; 14, 93; 15, if_statement; 15, 16; 15, 22; 16, not_operator; 16, 17; 17, call; 17, 18; 17, 19; 18, identifier:isinstance; 19, argument_list; 19, 20; 19, 21; 20, identifier:cachefile; 21, identifier:FILE_LIKE; 22, block; 22, 23; 23, with_statement; 23, 24; 23, 37; 24, with_clause; 24, 25; 25, with_item; 25, 26; 26, as_pattern; 26, 27; 26, 35; 27, call; 27, 28; 27, 29; 28, identifier:open; 29, argument_list; 29, 30; 29, 34; 30, call; 30, 31; 30, 32; 31, identifier:file_path; 32, argument_list; 32, 33; 33, identifier:cachefile; 34, string:'r'; 35, as_pattern_target; 35, 36; 36, identifier:fobj; 37, block; 37, 38; 38, return_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:read_cache; 41, argument_list; 41, 42; 41, 43; 41, 46; 41, 49; 42, identifier:fobj; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:coltype; 45, identifier:coltype; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:sort; 48, identifier:sort; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:segment; 51, identifier:segment; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:cache; 55, list_comprehension; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:x; 58, identifier:path; 59, for_in_clause; 59, 60; 59, 61; 60, identifier:x; 61, call; 61, 62; 61, 63; 62, identifier:_iter_cache; 63, argument_list; 63, 64; 63, 65; 64, identifier:cachefile; 65, keyword_argument; 65, 66; 65, 67; 66, identifier:gpstype; 67, identifier:coltype; 68, if_statement; 68, 69; 68, 70; 69, identifier:segment; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:cache; 74, call; 74, 75; 74, 76; 75, identifier:sieve; 76, argument_list; 76, 77; 76, 78; 77, identifier:cache; 78, keyword_argument; 78, 79; 78, 80; 79, identifier:segment; 80, identifier:segment; 81, if_statement; 81, 82; 81, 83; 82, identifier:sort; 83, block; 83, 84; 84, expression_statement; 84, 85; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:cache; 88, identifier:sort; 89, argument_list; 89, 90; 90, keyword_argument; 90, 91; 90, 92; 91, identifier:key; 92, identifier:sort; 93, return_statement; 93, 94; 94, identifier:cache
|
def read_cache(cachefile, coltype=LIGOTimeGPS, sort=None, segment=None):
if not isinstance(cachefile, FILE_LIKE):
with open(file_path(cachefile), 'r') as fobj:
return read_cache(fobj, coltype=coltype, sort=sort,
segment=segment)
cache = [x.path for x in _iter_cache(cachefile, gpstype=coltype)]
if segment:
cache = sieve(cache, segment=segment)
if sort:
cache.sort(key=sort)
return cache
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_learned_skills; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:lang; 6, block; 6, 7; 6, 23; 6, 30; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:skills; 10, list_comprehension; 10, 11; 10, 12; 11, identifier:skill; 12, for_in_clause; 12, 13; 12, 14; 13, identifier:skill; 14, subscript; 14, 15; 14, 22; 15, subscript; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:user_data; 20, identifier:language_data; 21, identifier:lang; 22, string:'skills'; 23, expression_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_compute_dependency_order; 28, argument_list; 28, 29; 29, identifier:skills; 30, return_statement; 30, 31; 31, list_comprehension; 31, 32; 31, 33; 31, 47; 32, identifier:skill; 33, for_in_clause; 33, 34; 33, 35; 34, identifier:skill; 35, call; 35, 36; 35, 37; 36, identifier:sorted; 37, argument_list; 37, 38; 37, 39; 38, identifier:skills; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:key; 41, lambda; 41, 42; 41, 44; 42, lambda_parameters; 42, 43; 43, identifier:skill; 44, subscript; 44, 45; 44, 46; 45, identifier:skill; 46, string:'dependency_order'; 47, if_clause; 47, 48; 48, subscript; 48, 49; 48, 50; 49, identifier:skill; 50, string:'learned'
|
def get_learned_skills(self, lang):
skills = [skill for skill in
self.user_data.language_data[lang]['skills']]
self._compute_dependency_order(skills)
return [skill for skill in
sorted(skills, key=lambda skill: skill['dependency_order'])
if skill['learned']]
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:combine_adjacent_lines; 3, parameters; 3, 4; 4, identifier:line_numbers; 5, block; 5, 6; 5, 10; 5, 14; 5, 21; 5, 27; 5, 31; 5, 92; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:combine_template; 9, string:"{0}-{1}"; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:combined_list; 13, list:[]; 14, expression_statement; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:line_numbers; 18, identifier:append; 19, argument_list; 19, 20; 20, None; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:start; 24, subscript; 24, 25; 24, 26; 25, identifier:line_numbers; 26, integer:0; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:end; 30, None; 31, for_statement; 31, 32; 31, 33; 31, 38; 32, identifier:line_number; 33, subscript; 33, 34; 33, 35; 34, identifier:line_numbers; 35, slice; 35, 36; 35, 37; 36, integer:1; 37, colon; 38, block; 38, 39; 39, if_statement; 39, 40; 39, 49; 39, 54; 40, comparison_operator:==; 40, 41; 40, 48; 41, binary_operator:+; 41, 42; 41, 47; 42, parenthesized_expression; 42, 43; 43, conditional_expression:if; 43, 44; 43, 45; 43, 46; 44, identifier:end; 45, identifier:end; 46, identifier:start; 47, integer:1; 48, identifier:line_number; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:end; 53, identifier:line_number; 54, else_clause; 54, 55; 55, block; 55, 56; 55, 84; 55, 88; 56, if_statement; 56, 57; 56, 58; 56, 72; 57, identifier:end; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:combined_list; 63, identifier:append; 64, argument_list; 64, 65; 65, call; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:combine_template; 68, identifier:format; 69, argument_list; 69, 70; 69, 71; 70, identifier:start; 71, identifier:end; 72, else_clause; 72, 73; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:combined_list; 78, identifier:append; 79, argument_list; 79, 80; 80, call; 80, 81; 80, 82; 81, identifier:str; 82, argument_list; 82, 83; 83, identifier:start; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:start; 87, identifier:line_number; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:end; 91, None; 92, return_statement; 92, 93; 93, identifier:combined_list
|
def combine_adjacent_lines(line_numbers):
combine_template = "{0}-{1}"
combined_list = []
line_numbers.append(None)
start = line_numbers[0]
end = None
for line_number in line_numbers[1:]:
if (end if end else start) + 1 == line_number:
end = line_number
else:
if end:
combined_list.append(combine_template.format(start, end))
else:
combined_list.append(str(start))
start = line_number
end = None
return combined_list
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_menus; 3, parameters; 3, 4; 4, identifier:c; 5, block; 5, 6; 6, for_statement; 6, 7; 6, 8; 6, 11; 7, identifier:name; 8, attribute; 8, 9; 8, 10; 9, identifier:c; 10, identifier:items; 11, block; 11, 12; 12, if_statement; 12, 13; 12, 19; 13, not_operator; 13, 14; 14, subscript; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:c; 17, identifier:sorted; 18, identifier:name; 19, block; 19, 20; 19, 38; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 29; 22, attribute; 22, 23; 22, 28; 23, subscript; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:c; 26, identifier:items; 27, identifier:name; 28, identifier:sort; 29, argument_list; 29, 30; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:key; 32, lambda; 32, 33; 32, 35; 33, lambda_parameters; 33, 34; 34, identifier:x; 35, attribute; 35, 36; 35, 37; 36, identifier:x; 37, identifier:weight; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 45; 40, subscript; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:c; 43, identifier:sorted; 44, identifier:name; 45, True
|
def sort_menus(c):
for name in c.items:
if not c.sorted[name]:
c.items[name].sort(key=lambda x: x.weight)
c.sorted[name] = True
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_frequency_order_transform; 3, parameters; 3, 4; 4, identifier:sets; 5, block; 5, 6; 5, 13; 5, 33; 5, 52; 5, 71; 5, 78; 6, expression_statement; 6, 7; 7, call; 7, 8; 7, 11; 8, attribute; 8, 9; 8, 10; 9, identifier:logging; 10, identifier:debug; 11, argument_list; 11, 12; 12, string:"Applying frequency order transform on tokens..."; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:counts; 16, call; 16, 17; 16, 18; 17, identifier:reversed; 18, argument_list; 18, 19; 19, call; 19, 20; 19, 32; 20, attribute; 20, 21; 20, 31; 21, call; 21, 22; 21, 23; 22, identifier:Counter; 23, generator_expression; 23, 24; 23, 25; 23, 28; 24, identifier:token; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:s; 27, identifier:sets; 28, for_in_clause; 28, 29; 28, 30; 29, identifier:token; 30, identifier:s; 31, identifier:most_common; 32, argument_list; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:order; 36, call; 36, 37; 36, 38; 37, identifier:dict; 38, generator_expression; 38, 39; 38, 42; 39, tuple; 39, 40; 39, 41; 40, identifier:token; 41, identifier:i; 42, for_in_clause; 42, 43; 42, 48; 43, pattern_list; 43, 44; 43, 45; 44, identifier:i; 45, tuple_pattern; 45, 46; 45, 47; 46, identifier:token; 47, identifier:_; 48, call; 48, 49; 48, 50; 49, identifier:enumerate; 50, argument_list; 50, 51; 51, identifier:counts; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:sets; 55, list_comprehension; 55, 56; 55, 68; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:np; 59, identifier:sort; 60, argument_list; 60, 61; 61, list_comprehension; 61, 62; 61, 65; 62, subscript; 62, 63; 62, 64; 63, identifier:order; 64, identifier:token; 65, for_in_clause; 65, 66; 65, 67; 66, identifier:token; 67, identifier:s; 68, for_in_clause; 68, 69; 68, 70; 69, identifier:s; 70, identifier:sets; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:logging; 75, identifier:debug; 76, argument_list; 76, 77; 77, string:"Done applying frequency order."; 78, return_statement; 78, 79; 79, expression_list; 79, 80; 79, 81; 80, identifier:sets; 81, identifier:order
|
def _frequency_order_transform(sets):
logging.debug("Applying frequency order transform on tokens...")
counts = reversed(Counter(token for s in sets for token in s).most_common())
order = dict((token, i) for i, (token, _) in enumerate(counts))
sets = [np.sort([order[token] for token in s]) for s in sets]
logging.debug("Done applying frequency order.")
return sets, order
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:to_numpy_vectors; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 13; 3, 18; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:variable_order; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:dtype; 10, attribute; 10, 11; 10, 12; 11, identifier:np; 12, identifier:float; 13, default_parameter; 13, 14; 13, 15; 14, identifier:index_dtype; 15, attribute; 15, 16; 15, 17; 16, identifier:np; 17, identifier:int64; 18, default_parameter; 18, 19; 18, 20; 19, identifier:sort_indices; 20, False; 21, block; 21, 22; 21, 28; 21, 34; 21, 41; 21, 48; 21, 60; 21, 72; 21, 84; 21, 248; 21, 326; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:linear; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:linear; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:quadratic; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:quadratic; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:num_variables; 37, call; 37, 38; 37, 39; 38, identifier:len; 39, argument_list; 39, 40; 40, identifier:linear; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:num_interactions; 44, call; 44, 45; 44, 46; 45, identifier:len; 46, argument_list; 46, 47; 47, identifier:quadratic; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:irow; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:np; 54, identifier:empty; 55, argument_list; 55, 56; 55, 57; 56, identifier:num_interactions; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:dtype; 59, identifier:index_dtype; 60, expression_statement; 60, 61; 61, assignment; 61, 62; 61, 63; 62, identifier:icol; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:np; 66, identifier:empty; 67, argument_list; 67, 68; 67, 69; 68, identifier:num_interactions; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:dtype; 71, identifier:index_dtype; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:qdata; 75, call; 75, 76; 75, 79; 76, attribute; 76, 77; 76, 78; 77, identifier:np; 78, identifier:empty; 79, argument_list; 79, 80; 79, 81; 80, identifier:num_interactions; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:dtype; 83, identifier:dtype; 84, if_statement; 84, 85; 84, 88; 84, 161; 85, comparison_operator:is; 85, 86; 85, 87; 86, identifier:variable_order; 87, None; 88, block; 88, 89; 88, 126; 89, try_statement; 89, 90; 89, 115; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:ldata; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:np; 97, identifier:fromiter; 98, argument_list; 98, 99; 98, 109; 98, 112; 99, generator_expression; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:linear; 102, identifier:v; 103, for_in_clause; 103, 104; 103, 105; 104, identifier:v; 105, call; 105, 106; 105, 107; 106, identifier:range; 107, argument_list; 107, 108; 108, identifier:num_variables; 109, keyword_argument; 109, 110; 109, 111; 110, identifier:count; 111, identifier:num_variables; 112, keyword_argument; 112, 113; 112, 114; 113, identifier:dtype; 114, identifier:dtype; 115, except_clause; 115, 116; 115, 117; 116, identifier:KeyError; 117, block; 117, 118; 118, raise_statement; 118, 119; 119, call; 119, 120; 119, 121; 120, identifier:ValueError; 121, argument_list; 121, 122; 122, parenthesized_expression; 122, 123; 123, concatenated_string; 123, 124; 123, 125; 124, string:"if 'variable_order' is not provided, binary quadratic model must be "; 125, string:"index labeled [0, ..., N-1]"; 126, for_statement; 126, 127; 126, 134; 126, 142; 127, pattern_list; 127, 128; 127, 129; 128, identifier:idx; 129, tuple_pattern; 129, 130; 129, 133; 130, tuple_pattern; 130, 131; 130, 132; 131, identifier:u; 132, identifier:v; 133, identifier:bias; 134, call; 134, 135; 134, 136; 135, identifier:enumerate; 136, argument_list; 136, 137; 137, call; 137, 138; 137, 141; 138, attribute; 138, 139; 138, 140; 139, identifier:quadratic; 140, identifier:items; 141, argument_list; 142, block; 142, 143; 142, 149; 142, 155; 143, expression_statement; 143, 144; 144, assignment; 144, 145; 144, 148; 145, subscript; 145, 146; 145, 147; 146, identifier:irow; 147, identifier:idx; 148, identifier:u; 149, expression_statement; 149, 150; 150, assignment; 150, 151; 150, 154; 151, subscript; 151, 152; 151, 153; 152, identifier:icol; 153, identifier:idx; 154, identifier:v; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 160; 157, subscript; 157, 158; 157, 159; 158, identifier:qdata; 159, identifier:idx; 160, identifier:bias; 161, else_clause; 161, 162; 162, block; 162, 163; 162, 194; 162, 209; 163, try_statement; 163, 164; 163, 186; 164, block; 164, 165; 165, expression_statement; 165, 166; 166, assignment; 166, 167; 166, 168; 167, identifier:ldata; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:np; 171, identifier:fromiter; 172, argument_list; 172, 173; 172, 180; 172, 183; 173, generator_expression; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:linear; 176, identifier:v; 177, for_in_clause; 177, 178; 177, 179; 178, identifier:v; 179, identifier:variable_order; 180, keyword_argument; 180, 181; 180, 182; 181, identifier:count; 182, identifier:num_variables; 183, keyword_argument; 183, 184; 183, 185; 184, identifier:dtype; 185, identifier:dtype; 186, except_clause; 186, 187; 186, 188; 187, identifier:KeyError; 188, block; 188, 189; 189, raise_statement; 189, 190; 190, call; 190, 191; 190, 192; 191, identifier:ValueError; 192, argument_list; 192, 193; 193, string:"provided 'variable_order' does not match binary quadratic model"; 194, expression_statement; 194, 195; 195, assignment; 195, 196; 195, 197; 196, identifier:label_to_idx; 197, dictionary_comprehension; 197, 198; 197, 201; 198, pair; 198, 199; 198, 200; 199, identifier:v; 200, identifier:idx; 201, for_in_clause; 201, 202; 201, 205; 202, pattern_list; 202, 203; 202, 204; 203, identifier:idx; 204, identifier:v; 205, call; 205, 206; 205, 207; 206, identifier:enumerate; 207, argument_list; 207, 208; 208, identifier:variable_order; 209, for_statement; 209, 210; 209, 217; 209, 225; 210, pattern_list; 210, 211; 210, 212; 211, identifier:idx; 212, tuple_pattern; 212, 213; 212, 216; 213, tuple_pattern; 213, 214; 213, 215; 214, identifier:u; 215, identifier:v; 216, identifier:bias; 217, call; 217, 218; 217, 219; 218, identifier:enumerate; 219, argument_list; 219, 220; 220, call; 220, 221; 220, 224; 221, attribute; 221, 222; 221, 223; 222, identifier:quadratic; 223, identifier:items; 224, argument_list; 225, block; 225, 226; 225, 234; 225, 242; 226, expression_statement; 226, 227; 227, assignment; 227, 228; 227, 231; 228, subscript; 228, 229; 228, 230; 229, identifier:irow; 230, identifier:idx; 231, subscript; 231, 232; 231, 233; 232, identifier:label_to_idx; 233, identifier:u; 234, expression_statement; 234, 235; 235, assignment; 235, 236; 235, 239; 236, subscript; 236, 237; 236, 238; 237, identifier:icol; 238, identifier:idx; 239, subscript; 239, 240; 239, 241; 240, identifier:label_to_idx; 241, identifier:v; 242, expression_statement; 242, 243; 243, assignment; 243, 244; 243, 247; 244, subscript; 244, 245; 244, 246; 245, identifier:qdata; 246, identifier:idx; 247, identifier:bias; 248, if_statement; 248, 249; 248, 250; 249, identifier:sort_indices; 250, block; 250, 251; 250, 257; 250, 280; 250, 291; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:swaps; 254, comparison_operator:>; 254, 255; 254, 256; 255, identifier:irow; 256, identifier:icol; 257, if_statement; 257, 258; 257, 263; 258, call; 258, 259; 258, 262; 259, attribute; 259, 260; 259, 261; 260, identifier:swaps; 261, identifier:any; 262, argument_list; 263, block; 263, 264; 264, expression_statement; 264, 265; 265, assignment; 265, 266; 265, 273; 266, pattern_list; 266, 267; 266, 270; 267, subscript; 267, 268; 267, 269; 268, identifier:irow; 269, identifier:swaps; 270, subscript; 270, 271; 270, 272; 271, identifier:icol; 272, identifier:swaps; 273, expression_list; 273, 274; 273, 277; 274, subscript; 274, 275; 274, 276; 275, identifier:icol; 276, identifier:swaps; 277, subscript; 277, 278; 277, 279; 278, identifier:irow; 279, identifier:swaps; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 283; 282, identifier:order; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:np; 286, identifier:lexsort; 287, argument_list; 287, 288; 288, tuple; 288, 289; 288, 290; 289, identifier:irow; 290, identifier:icol; 291, if_statement; 291, 292; 291, 307; 292, not_operator; 292, 293; 293, call; 293, 294; 293, 306; 294, attribute; 294, 295; 294, 305; 295, parenthesized_expression; 295, 296; 296, comparison_operator:==; 296, 297; 296, 298; 297, identifier:order; 298, call; 298, 299; 298, 300; 299, identifier:range; 300, argument_list; 300, 301; 301, call; 301, 302; 301, 303; 302, identifier:len; 303, argument_list; 303, 304; 304, identifier:order; 305, identifier:all; 306, argument_list; 307, block; 307, 308; 307, 314; 307, 320; 308, expression_statement; 308, 309; 309, assignment; 309, 310; 309, 311; 310, identifier:irow; 311, subscript; 311, 312; 311, 313; 312, identifier:irow; 313, identifier:order; 314, expression_statement; 314, 315; 315, assignment; 315, 316; 315, 317; 316, identifier:icol; 317, subscript; 317, 318; 317, 319; 318, identifier:icol; 319, identifier:order; 320, expression_statement; 320, 321; 321, assignment; 321, 322; 321, 323; 322, identifier:qdata; 323, subscript; 323, 324; 323, 325; 324, identifier:qdata; 325, identifier:order; 326, return_statement; 326, 327; 327, expression_list; 327, 328; 327, 329; 327, 333; 328, identifier:ldata; 329, tuple; 329, 330; 329, 331; 329, 332; 330, identifier:irow; 331, identifier:icol; 332, identifier:qdata; 333, call; 333, 334; 333, 339; 334, attribute; 334, 335; 334, 338; 335, attribute; 335, 336; 335, 337; 336, identifier:ldata; 337, identifier:dtype; 338, identifier:type; 339, argument_list; 339, 340; 340, attribute; 340, 341; 340, 342; 341, identifier:self; 342, identifier:offset
|
def to_numpy_vectors(self, variable_order=None, dtype=np.float, index_dtype=np.int64, sort_indices=False):
linear = self.linear
quadratic = self.quadratic
num_variables = len(linear)
num_interactions = len(quadratic)
irow = np.empty(num_interactions, dtype=index_dtype)
icol = np.empty(num_interactions, dtype=index_dtype)
qdata = np.empty(num_interactions, dtype=dtype)
if variable_order is None:
try:
ldata = np.fromiter((linear[v] for v in range(num_variables)), count=num_variables, dtype=dtype)
except KeyError:
raise ValueError(("if 'variable_order' is not provided, binary quadratic model must be "
"index labeled [0, ..., N-1]"))
for idx, ((u, v), bias) in enumerate(quadratic.items()):
irow[idx] = u
icol[idx] = v
qdata[idx] = bias
else:
try:
ldata = np.fromiter((linear[v] for v in variable_order), count=num_variables, dtype=dtype)
except KeyError:
raise ValueError("provided 'variable_order' does not match binary quadratic model")
label_to_idx = {v: idx for idx, v in enumerate(variable_order)}
for idx, ((u, v), bias) in enumerate(quadratic.items()):
irow[idx] = label_to_idx[u]
icol[idx] = label_to_idx[v]
qdata[idx] = bias
if sort_indices:
swaps = irow > icol
if swaps.any():
irow[swaps], icol[swaps] = icol[swaps], irow[swaps]
order = np.lexsort((irow, icol))
if not (order == range(len(order))).all():
irow = irow[order]
icol = icol[order]
qdata = qdata[order]
return ldata, (irow, icol, qdata), ldata.dtype.type(self.offset)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:from_samples_bqm; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:cls; 5, identifier:samples_like; 6, identifier:bqm; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 17; 9, 26; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:samples_like; 13, call; 13, 14; 13, 15; 14, identifier:as_samples; 15, argument_list; 15, 16; 16, identifier:samples_like; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:energies; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:bqm; 23, identifier:energies; 24, argument_list; 24, 25; 25, identifier:samples_like; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:cls; 30, identifier:from_samples; 31, argument_list; 31, 32; 31, 33; 31, 36; 31, 41; 32, identifier:samples_like; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:energy; 35, identifier:energies; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:vartype; 38, attribute; 38, 39; 38, 40; 39, identifier:bqm; 40, identifier:vartype; 41, dictionary_splat; 41, 42; 42, identifier:kwargs
|
def from_samples_bqm(cls, samples_like, bqm, **kwargs):
samples_like = as_samples(samples_like)
energies = bqm.energies(samples_like)
return cls.from_samples(samples_like, energy=energies, vartype=bqm.vartype, **kwargs)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:samples; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:n; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sorted_by; 10, string:'energy'; 11, block; 11, 12; 11, 30; 11, 68; 12, if_statement; 12, 13; 12, 16; 13, comparison_operator:is; 13, 14; 13, 15; 14, identifier:n; 15, None; 16, block; 16, 17; 17, return_statement; 17, 18; 18, subscript; 18, 19; 18, 27; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:samples; 23, argument_list; 23, 24; 24, keyword_argument; 24, 25; 24, 26; 25, identifier:sorted_by; 26, identifier:sorted_by; 27, slice; 27, 28; 27, 29; 28, colon; 29, identifier:n; 30, if_statement; 30, 31; 30, 34; 30, 43; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:sorted_by; 33, None; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:samples; 38, attribute; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:record; 42, identifier:sample; 43, else_clause; 43, 44; 44, block; 44, 45; 44, 58; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:order; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:np; 51, identifier:argsort; 52, argument_list; 52, 53; 53, subscript; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:record; 57, identifier:sorted_by; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:samples; 61, subscript; 61, 62; 61, 67; 62, attribute; 62, 63; 62, 66; 63, attribute; 63, 64; 63, 65; 64, identifier:self; 65, identifier:record; 66, identifier:sample; 67, identifier:order; 68, return_statement; 68, 69; 69, call; 69, 70; 69, 71; 70, identifier:SamplesArray; 71, argument_list; 71, 72; 71, 73; 72, identifier:samples; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:variables
|
def samples(self, n=None, sorted_by='energy'):
if n is not None:
return self.samples(sorted_by=sorted_by)[:n]
if sorted_by is None:
samples = self.record.sample
else:
order = np.argsort(self.record[sorted_by])
samples = self.record.sample[order]
return SamplesArray(samples, self.variables)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:append_variables; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:samples_like; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort_labels; 8, True; 9, block; 9, 10; 9, 19; 9, 26; 9, 75; 9, 81; 9, 101; 9, 110; 9, 125; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 15; 12, pattern_list; 12, 13; 12, 14; 13, identifier:samples; 14, identifier:labels; 15, call; 15, 16; 15, 17; 16, identifier:as_samples; 17, argument_list; 17, 18; 18, identifier:samples_like; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:num_samples; 22, call; 22, 23; 22, 24; 23, identifier:len; 24, argument_list; 24, 25; 25, identifier:self; 26, if_statement; 26, 27; 26, 34; 26, 36; 26, 60; 27, comparison_operator:==; 27, 28; 27, 33; 28, subscript; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:samples; 31, identifier:shape; 32, integer:0; 33, identifier:num_samples; 34, block; 34, 35; 35, pass_statement; 36, elif_clause; 36, 37; 36, 46; 37, boolean_operator:and; 37, 38; 37, 45; 38, comparison_operator:==; 38, 39; 38, 44; 39, subscript; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:samples; 42, identifier:shape; 43, integer:0; 44, integer:1; 45, identifier:num_samples; 46, block; 46, 47; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:samples; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:np; 53, identifier:repeat; 54, argument_list; 54, 55; 54, 56; 54, 57; 55, identifier:samples; 56, identifier:num_samples; 57, keyword_argument; 57, 58; 57, 59; 58, identifier:axis; 59, integer:0; 60, else_clause; 60, 61; 61, block; 61, 62; 61, 70; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:msg; 65, parenthesized_expression; 65, 66; 66, concatenated_string; 66, 67; 66, 68; 66, 69; 67, string:"mismatched shape. The samples to append should either be "; 68, string:"a single sample or should match the length of the sample "; 69, string:"set. Empty sample sets cannot be appended to."; 70, raise_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:ValueError; 73, argument_list; 73, 74; 74, identifier:msg; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:variables; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:variables; 81, if_statement; 81, 82; 81, 91; 82, call; 82, 83; 82, 84; 83, identifier:any; 84, generator_expression; 84, 85; 84, 88; 85, comparison_operator:in; 85, 86; 85, 87; 86, identifier:v; 87, identifier:variables; 88, for_in_clause; 88, 89; 88, 90; 89, identifier:v; 90, identifier:labels; 91, block; 91, 92; 91, 96; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:msg; 95, string:"Appended samples cannot contain variables in sample set"; 96, raise_statement; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:ValueError; 99, argument_list; 99, 100; 100, identifier:msg; 101, expression_statement; 101, 102; 102, assignment; 102, 103; 102, 104; 103, identifier:new_variables; 104, binary_operator:+; 104, 105; 104, 109; 105, call; 105, 106; 105, 107; 106, identifier:list; 107, argument_list; 107, 108; 108, identifier:variables; 109, identifier:labels; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:new_samples; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:np; 116, identifier:hstack; 117, argument_list; 117, 118; 118, tuple; 118, 119; 118, 124; 119, attribute; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:self; 122, identifier:record; 123, identifier:sample; 124, identifier:samples; 125, return_statement; 125, 126; 126, call; 126, 127; 126, 133; 127, attribute; 127, 128; 127, 132; 128, call; 128, 129; 128, 130; 129, identifier:type; 130, argument_list; 130, 131; 131, identifier:self; 132, identifier:from_samples; 133, argument_list; 133, 134; 133, 137; 133, 140; 133, 150; 133, 153; 134, tuple; 134, 135; 134, 136; 135, identifier:new_samples; 136, identifier:new_variables; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:vartype; 140, keyword_argument; 140, 141; 140, 142; 141, identifier:info; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:copy; 145, identifier:deepcopy; 146, argument_list; 146, 147; 147, attribute; 147, 148; 147, 149; 148, identifier:self; 149, identifier:info; 150, keyword_argument; 150, 151; 150, 152; 151, identifier:sort_labels; 152, identifier:sort_labels; 153, dictionary_splat; 153, 154; 154, attribute; 154, 155; 154, 156; 155, identifier:self; 156, identifier:data_vectors
|
def append_variables(self, samples_like, sort_labels=True):
samples, labels = as_samples(samples_like)
num_samples = len(self)
if samples.shape[0] == num_samples:
pass
elif samples.shape[0] == 1 and num_samples:
samples = np.repeat(samples, num_samples, axis=0)
else:
msg = ("mismatched shape. The samples to append should either be "
"a single sample or should match the length of the sample "
"set. Empty sample sets cannot be appended to.")
raise ValueError(msg)
variables = self.variables
if any(v in variables for v in labels):
msg = "Appended samples cannot contain variables in sample set"
raise ValueError(msg)
new_variables = list(variables) + labels
new_samples = np.hstack((self.record.sample, samples))
return type(self).from_samples((new_samples, new_variables),
self.vartype,
info=copy.deepcopy(self.info),
sort_labels=sort_labels,
**self.data_vectors)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:slice; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:slice_args; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 20; 9, 41; 9, 61; 9, 99; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:sorted_by; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:kwargs; 16, identifier:pop; 17, argument_list; 17, 18; 17, 19; 18, string:'sorted_by'; 19, string:'energy'; 20, if_statement; 20, 21; 20, 22; 21, identifier:kwargs; 22, block; 22, 23; 23, raise_statement; 23, 24; 24, call; 24, 25; 24, 26; 25, identifier:TypeError; 26, argument_list; 26, 27; 27, call; 27, 28; 27, 33; 28, attribute; 28, 29; 28, 32; 29, concatenated_string; 29, 30; 29, 31; 30, string:'slice got an unexpected '; 31, string:'keyword argument {!r}'; 32, identifier:format; 33, argument_list; 33, 34; 34, subscript; 34, 35; 34, 40; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:kwargs; 38, identifier:popitem; 39, argument_list; 40, integer:0; 41, if_statement; 41, 42; 41, 43; 41, 52; 42, identifier:slice_args; 43, block; 43, 44; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:selector; 47, call; 47, 48; 47, 49; 48, identifier:slice; 49, argument_list; 49, 50; 50, list_splat; 50, 51; 51, identifier:slice_args; 52, else_clause; 52, 53; 53, block; 53, 54; 54, expression_statement; 54, 55; 55, assignment; 55, 56; 55, 57; 56, identifier:selector; 57, call; 57, 58; 57, 59; 58, identifier:slice; 59, argument_list; 59, 60; 60, None; 61, if_statement; 61, 62; 61, 65; 61, 74; 62, comparison_operator:is; 62, 63; 62, 64; 63, identifier:sorted_by; 64, None; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, assignment; 67, 68; 67, 69; 68, identifier:record; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:record; 73, identifier:selector; 74, else_clause; 74, 75; 75, block; 75, 76; 75, 89; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:sort_indices; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:np; 82, identifier:argsort; 83, argument_list; 83, 84; 84, subscript; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:record; 88, identifier:sorted_by; 89, expression_statement; 89, 90; 90, assignment; 90, 91; 90, 92; 91, identifier:record; 92, subscript; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:self; 95, identifier:record; 96, subscript; 96, 97; 96, 98; 97, identifier:sort_indices; 98, identifier:selector; 99, return_statement; 99, 100; 100, call; 100, 101; 100, 105; 101, call; 101, 102; 101, 103; 102, identifier:type; 103, argument_list; 103, 104; 104, identifier:self; 105, argument_list; 105, 106; 105, 107; 105, 110; 105, 118; 106, identifier:record; 107, attribute; 107, 108; 107, 109; 108, identifier:self; 109, identifier:variables; 110, call; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:copy; 113, identifier:deepcopy; 114, argument_list; 114, 115; 115, attribute; 115, 116; 115, 117; 116, identifier:self; 117, identifier:info; 118, attribute; 118, 119; 118, 120; 119, identifier:self; 120, identifier:vartype
|
def slice(self, *slice_args, **kwargs):
sorted_by = kwargs.pop('sorted_by', 'energy')
if kwargs:
raise TypeError('slice got an unexpected '
'keyword argument {!r}'.format(kwargs.popitem()[0]))
if slice_args:
selector = slice(*slice_args)
else:
selector = slice(None)
if sorted_by is None:
record = self.record[selector]
else:
sort_indices = np.argsort(self.record[sorted_by])
record = self.record[sort_indices[selector]]
return type(self)(record, self.variables, copy.deepcopy(self.info),
self.vartype)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:describe_features; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:traj; 6, block; 6, 7; 6, 20; 6, 58; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:n_f; 10, subscript; 10, 11; 10, 19; 11, attribute; 11, 12; 11, 18; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:partial_transform; 16, argument_list; 16, 17; 17, identifier:traj; 18, identifier:shape; 19, integer:1; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:zippy; 23, call; 23, 24; 23, 25; 24, identifier:zip; 25, argument_list; 25, 26; 25, 33; 25, 40; 25, 47; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:itertools; 29, identifier:repeat; 30, argument_list; 30, 31; 30, 32; 31, string:"N/A"; 32, identifier:n_f; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:itertools; 36, identifier:repeat; 37, argument_list; 37, 38; 37, 39; 38, string:"N/A"; 39, identifier:n_f; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:itertools; 43, identifier:repeat; 44, argument_list; 44, 45; 44, 46; 45, string:"N/A"; 46, identifier:n_f; 47, call; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:itertools; 50, identifier:repeat; 51, argument_list; 51, 52; 51, 57; 52, tuple; 52, 53; 52, 54; 52, 55; 52, 56; 53, string:"N/A"; 54, string:"N/A"; 55, string:"N/A"; 56, string:"N/A"; 57, identifier:n_f; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:dict_maker; 61, argument_list; 61, 62; 62, identifier:zippy
|
def describe_features(self, traj):
n_f = self.partial_transform(traj).shape[1]
zippy=zip(itertools.repeat("N/A", n_f),
itertools.repeat("N/A", n_f),
itertools.repeat("N/A", n_f),
itertools.repeat(("N/A","N/A","N/A","N/A"), n_f))
return dict_maker(zippy)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_mapped_populations; 3, parameters; 3, 4; 3, 5; 4, identifier:mdl1; 5, identifier:mdl2; 6, block; 6, 7; 6, 18; 6, 64; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:return_vect; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:np; 13, identifier:zeros; 14, argument_list; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:mdl1; 17, identifier:n_states_; 18, for_statement; 18, 19; 18, 20; 18, 26; 19, identifier:i; 20, call; 20, 21; 20, 22; 21, identifier:range; 22, argument_list; 22, 23; 23, attribute; 23, 24; 23, 25; 24, identifier:mdl1; 25, identifier:n_states_; 26, block; 26, 27; 27, try_statement; 27, 28; 27, 61; 28, block; 28, 29; 28, 43; 28, 51; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:mdl1_unmapped; 32, subscript; 32, 33; 32, 42; 33, subscript; 33, 34; 33, 41; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:mdl1; 37, identifier:inverse_transform; 38, argument_list; 38, 39; 39, list:[i]; 39, 40; 40, identifier:i; 41, integer:0; 42, integer:0; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:mdl2_mapped; 46, subscript; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:mdl2; 49, identifier:mapping_; 50, identifier:mdl1_unmapped; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:return_vect; 55, identifier:i; 56, subscript; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:mdl2; 59, identifier:populations_; 60, identifier:mdl2_mapped; 61, except_clause; 61, 62; 62, block; 62, 63; 63, pass_statement; 64, return_statement; 64, 65; 65, identifier:return_vect
|
def _mapped_populations(mdl1, mdl2):
return_vect = np.zeros(mdl1.n_states_)
for i in range(mdl1.n_states_):
try:
mdl1_unmapped = mdl1.inverse_transform([i])[0][0]
mdl2_mapped = mdl2.mapping_[mdl1_unmapped]
return_vect[i] = mdl2.populations_[mdl2_mapped]
except:
pass
return return_vect
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:query; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, identifier:x; 6, default_parameter; 6, 7; 6, 8; 7, identifier:k; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:p; 11, integer:2; 12, default_parameter; 12, 13; 12, 14; 13, identifier:distance_upper_bound; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:inf; 17, block; 17, 18; 17, 34; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 23; 20, pattern_list; 20, 21; 20, 22; 21, identifier:cdists; 22, identifier:cinds; 23, call; 23, 24; 23, 29; 24, attribute; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_kdtree; 28, identifier:query; 29, argument_list; 29, 30; 29, 31; 29, 32; 29, 33; 30, identifier:x; 31, identifier:k; 32, identifier:p; 33, identifier:distance_upper_bound; 34, return_statement; 34, 35; 35, expression_list; 35, 36; 35, 37; 36, identifier:cdists; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:self; 40, identifier:_split_indices; 41, argument_list; 41, 42; 42, identifier:cinds
|
def query(self, x, k=1, p=2, distance_upper_bound=np.inf):
cdists, cinds = self._kdtree.query(x, k, p, distance_upper_bound)
return cdists, self._split_indices(cinds)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_fn_list; 3, parameters; 3, 4; 4, identifier:fn_list; 5, block; 5, 6; 5, 13; 5, 30; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:dt_list; 9, call; 9, 10; 9, 11; 10, identifier:get_dt_list; 11, argument_list; 11, 12; 12, identifier:fn_list; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:fn_list_sort; 16, list_comprehension; 16, 17; 16, 18; 17, identifier:fn; 18, for_in_clause; 18, 19; 18, 22; 19, tuple_pattern; 19, 20; 19, 21; 20, identifier:dt; 21, identifier:fn; 22, call; 22, 23; 22, 24; 23, identifier:sorted; 24, argument_list; 24, 25; 25, call; 25, 26; 25, 27; 26, identifier:zip; 27, argument_list; 27, 28; 27, 29; 28, identifier:dt_list; 29, identifier:fn_list; 30, return_statement; 30, 31; 31, identifier:fn_list_sort
|
def sort_fn_list(fn_list):
dt_list = get_dt_list(fn_list)
fn_list_sort = [fn for (dt,fn) in sorted(zip(dt_list,fn_list))]
return fn_list_sort
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:iterable; 5, block; 5, 6; 5, 19; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:ips; 9, call; 9, 10; 9, 11; 10, identifier:sorted; 11, generator_expression; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:normalize_ip; 14, argument_list; 14, 15; 15, identifier:ip; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:ip; 18, identifier:iterable; 19, return_statement; 19, 20; 20, list_comprehension; 20, 21; 20, 25; 21, call; 21, 22; 21, 23; 22, identifier:clean_ip; 23, argument_list; 23, 24; 24, identifier:ip; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:ip; 27, identifier:ips
|
def sort(iterable):
ips = sorted(normalize_ip(ip) for ip in iterable)
return [clean_ip(ip) for ip in ips]
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:glob; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 25; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:file_glob; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:glob; 12, identifier:glob; 13, argument_list; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:BASE_NAME; 17, identifier:format; 18, argument_list; 18, 19; 18, 20; 18, 23; 18, 24; 19, string:'*'; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:num; 23, string:'*'; 24, string:'.*'; 25, return_statement; 25, 26; 26, call; 26, 27; 26, 28; 27, identifier:sorted; 28, argument_list; 28, 29; 28, 30; 29, identifier:file_glob; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:key; 32, lambda; 32, 33; 32, 35; 33, lambda_parameters; 33, 34; 34, identifier:f; 35, call; 35, 36; 35, 41; 36, attribute; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:os; 39, identifier:path; 40, identifier:splitext; 41, argument_list; 41, 42; 42, identifier:f
|
def glob(self):
file_glob = glob.glob(BASE_NAME.format('*', self.num, '*', '.*'))
return sorted(file_glob, key=lambda f: os.path.splitext(f))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:event; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 8; 4, identifier:self; 5, identifier:interface_id; 6, identifier:address; 7, identifier:value_key; 8, identifier:value; 9, block; 9, 10; 9, 30; 9, 57; 9, 84; 10, expression_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:LOG; 14, identifier:debug; 15, argument_list; 15, 16; 16, binary_operator:%; 16, 17; 16, 18; 17, string:"RPCFunctions.event: interface_id = %s, address = %s, value_key = %s, value = %s"; 18, tuple; 18, 19; 18, 20; 18, 21; 18, 26; 19, identifier:interface_id; 20, identifier:address; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:value_key; 24, identifier:upper; 25, argument_list; 26, call; 26, 27; 26, 28; 27, identifier:str; 28, argument_list; 28, 29; 29, identifier:value; 30, expression_statement; 30, 31; 31, call; 31, 32; 31, 49; 32, attribute; 32, 33; 32, 48; 33, subscript; 33, 34; 33, 47; 34, subscript; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:devices_all; 38, subscript; 38, 39; 38, 45; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:interface_id; 42, identifier:split; 43, argument_list; 43, 44; 44, string:'-'; 45, unary_operator:-; 45, 46; 46, integer:1; 47, identifier:address; 48, identifier:event; 49, argument_list; 49, 50; 49, 51; 49, 56; 50, identifier:interface_id; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:value_key; 54, identifier:upper; 55, argument_list; 56, identifier:value; 57, if_statement; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:eventcallback; 61, block; 61, 62; 62, expression_statement; 62, 63; 63, call; 63, 64; 63, 67; 64, attribute; 64, 65; 64, 66; 65, identifier:self; 66, identifier:eventcallback; 67, argument_list; 67, 68; 67, 71; 67, 74; 67, 81; 68, keyword_argument; 68, 69; 68, 70; 69, identifier:interface_id; 70, identifier:interface_id; 71, keyword_argument; 71, 72; 71, 73; 72, identifier:address; 73, identifier:address; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:value_key; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:value_key; 79, identifier:upper; 80, argument_list; 81, keyword_argument; 81, 82; 81, 83; 82, identifier:value; 83, identifier:value; 84, return_statement; 84, 85; 85, True
|
def event(self, interface_id, address, value_key, value):
LOG.debug("RPCFunctions.event: interface_id = %s, address = %s, value_key = %s, value = %s" % (
interface_id, address, value_key.upper(), str(value)))
self.devices_all[interface_id.split(
'-')[-1]][address].event(interface_id, value_key.upper(), value)
if self.eventcallback:
self.eventcallback(interface_id=interface_id, address=address,
value_key=value_key.upper(), value=value)
return True
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:get_isolated_cpus; 3, parameters; 4, block; 4, 5; 4, 12; 4, 19; 4, 27; 4, 37; 4, 67; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:path; 8, call; 8, 9; 8, 10; 9, identifier:sysfs_path; 10, argument_list; 10, 11; 11, string:'devices/system/cpu/isolated'; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:isolated; 15, call; 15, 16; 15, 17; 16, identifier:read_first_line; 17, argument_list; 17, 18; 18, identifier:path; 19, if_statement; 19, 20; 19, 21; 20, identifier:isolated; 21, block; 21, 22; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:parse_cpu_list; 25, argument_list; 25, 26; 26, identifier:isolated; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:cmdline; 30, call; 30, 31; 30, 32; 31, identifier:read_first_line; 32, argument_list; 32, 33; 33, call; 33, 34; 33, 35; 34, identifier:proc_path; 35, argument_list; 35, 36; 36, string:'cmdline'; 37, if_statement; 37, 38; 37, 39; 38, identifier:cmdline; 39, block; 39, 40; 39, 50; 40, expression_statement; 40, 41; 41, assignment; 41, 42; 41, 43; 42, identifier:match; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, identifier:re; 46, identifier:search; 47, argument_list; 47, 48; 47, 49; 48, string:r'\bisolcpus=([^ ]+)'; 49, identifier:cmdline; 50, if_statement; 50, 51; 50, 52; 51, identifier:match; 52, block; 52, 53; 52, 62; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:isolated; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:match; 59, identifier:group; 60, argument_list; 60, 61; 61, integer:1; 62, return_statement; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:parse_cpu_list; 65, argument_list; 65, 66; 66, identifier:isolated; 67, return_statement; 67, 68; 68, None
|
def get_isolated_cpus():
path = sysfs_path('devices/system/cpu/isolated')
isolated = read_first_line(path)
if isolated:
return parse_cpu_list(isolated)
cmdline = read_first_line(proc_path('cmdline'))
if cmdline:
match = re.search(r'\bisolcpus=([^ ]+)', cmdline)
if match:
isolated = match.group(1)
return parse_cpu_list(isolated)
return None
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:framesToFrameRange; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:frames; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, True; 8, default_parameter; 8, 9; 8, 10; 9, identifier:zfill; 10, integer:0; 11, default_parameter; 11, 12; 11, 13; 12, identifier:compress; 13, False; 14, block; 14, 15; 14, 28; 14, 35; 14, 41; 14, 57; 14, 66; 15, if_statement; 15, 16; 15, 17; 16, identifier:compress; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:frames; 21, call; 21, 22; 21, 23; 22, identifier:unique; 23, argument_list; 23, 24; 23, 27; 24, call; 24, 25; 24, 26; 25, identifier:set; 26, argument_list; 27, identifier:frames; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:frames; 31, call; 31, 32; 31, 33; 32, identifier:list; 33, argument_list; 33, 34; 34, identifier:frames; 35, if_statement; 35, 36; 35, 38; 36, not_operator; 36, 37; 37, identifier:frames; 38, block; 38, 39; 39, return_statement; 39, 40; 40, string:''; 41, if_statement; 41, 42; 41, 48; 42, comparison_operator:==; 42, 43; 42, 47; 43, call; 43, 44; 43, 45; 44, identifier:len; 45, argument_list; 45, 46; 46, identifier:frames; 47, integer:1; 48, block; 48, 49; 49, return_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:pad; 52, argument_list; 52, 53; 52, 56; 53, subscript; 53, 54; 53, 55; 54, identifier:frames; 55, integer:0; 56, identifier:zfill; 57, if_statement; 57, 58; 57, 59; 58, identifier:sort; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:frames; 64, identifier:sort; 65, argument_list; 66, return_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, string:','; 70, identifier:join; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:FrameSet; 75, identifier:framesToFrameRanges; 76, argument_list; 76, 77; 76, 78; 77, identifier:frames; 78, identifier:zfill
|
def framesToFrameRange(frames, sort=True, zfill=0, compress=False):
if compress:
frames = unique(set(), frames)
frames = list(frames)
if not frames:
return ''
if len(frames) == 1:
return pad(frames[0], zfill)
if sort:
frames.sort()
return ','.join(FrameSet.framesToFrameRanges(frames, zfill))
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:_normalize_request_parameters; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:oauth_params; 6, identifier:req_kwargs; 7, block; 7, 8; 7, 10; 7, 14; 7, 24; 7, 34; 7, 44; 7, 66; 7, 95; 7, 99; 7, 138; 7, 163; 7, 169; 8, expression_statement; 8, 9; 9, string:'''
This process normalizes the request parameters as detailed in the OAuth
1.0 spec.
Additionally we apply a `Content-Type` header to the request of the
`FORM_URLENCODE` type if the `Content-Type` was previously set, i.e. if
this is a `POST` or `PUT` request. This ensures the correct header is
set as per spec.
Finally we sort the parameters in preparation for signing and return
a URL encoded string of all normalized parameters.
:param oauth_params: OAuth params to sign with.
:type oauth_params: dict
:param req_kwargs: Request kwargs to normalize.
:type req_kwargs: dict
'''; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:normalized; 13, list:[]; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:params; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:req_kwargs; 20, identifier:get; 21, argument_list; 21, 22; 21, 23; 22, string:'params'; 23, dictionary; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:data; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:req_kwargs; 30, identifier:get; 31, argument_list; 31, 32; 31, 33; 32, string:'data'; 33, dictionary; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:headers; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:req_kwargs; 40, identifier:get; 41, argument_list; 41, 42; 41, 43; 42, string:'headers'; 43, dictionary; 44, for_statement; 44, 45; 44, 48; 44, 53; 45, pattern_list; 45, 46; 45, 47; 46, identifier:k; 47, identifier:v; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:params; 51, identifier:items; 52, argument_list; 53, block; 53, 54; 54, if_statement; 54, 55; 54, 58; 55, comparison_operator:is; 55, 56; 55, 57; 56, identifier:v; 57, None; 58, block; 58, 59; 59, expression_statement; 59, 60; 60, augmented_assignment:+=; 60, 61; 60, 62; 61, identifier:normalized; 62, list:[(k, v)]; 62, 63; 63, tuple; 63, 64; 63, 65; 64, identifier:k; 65, identifier:v; 66, if_statement; 66, 67; 66, 77; 67, boolean_operator:and; 67, 68; 67, 71; 67, 72; 68, comparison_operator:in; 68, 69; 68, 70; 69, string:'Content-Type'; 70, identifier:headers; 71, line_continuation:\; 72, comparison_operator:==; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:headers; 75, string:'Content-Type'; 76, identifier:FORM_URLENCODED; 77, block; 77, 78; 78, for_statement; 78, 79; 78, 82; 78, 87; 79, pattern_list; 79, 80; 79, 81; 80, identifier:k; 81, identifier:v; 82, call; 82, 83; 82, 86; 83, attribute; 83, 84; 83, 85; 84, identifier:data; 85, identifier:items; 86, argument_list; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, augmented_assignment:+=; 89, 90; 89, 91; 90, identifier:normalized; 91, list:[(k, v)]; 91, 92; 92, tuple; 92, 93; 92, 94; 93, identifier:k; 94, identifier:v; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:all_normalized; 98, list:[]; 99, for_statement; 99, 100; 99, 101; 99, 102; 100, identifier:t; 101, identifier:normalized; 102, block; 102, 103; 102, 109; 102, 131; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, pattern_list; 105, 106; 105, 107; 106, identifier:k; 107, identifier:v; 108, identifier:t; 109, if_statement; 109, 110; 109, 121; 110, boolean_operator:and; 110, 111; 110, 115; 111, call; 111, 112; 111, 113; 112, identifier:is_basestring; 113, argument_list; 113, 114; 114, identifier:v; 115, not_operator; 115, 116; 116, call; 116, 117; 116, 118; 117, identifier:isinstance; 118, argument_list; 118, 119; 118, 120; 119, identifier:v; 120, identifier:bytes; 121, block; 121, 122; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 125; 124, identifier:v; 125, call; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:v; 128, identifier:encode; 129, argument_list; 129, 130; 130, string:'utf-8'; 131, expression_statement; 131, 132; 132, augmented_assignment:+=; 132, 133; 132, 134; 133, identifier:all_normalized; 134, list:[(k, v)]; 134, 135; 135, tuple; 135, 136; 135, 137; 136, identifier:k; 137, identifier:v; 138, for_statement; 138, 139; 138, 142; 138, 147; 139, pattern_list; 139, 140; 139, 141; 140, identifier:k; 141, identifier:v; 142, call; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:oauth_params; 145, identifier:items; 146, argument_list; 147, block; 147, 148; 147, 156; 148, if_statement; 148, 149; 148, 154; 149, comparison_operator:in; 149, 150; 149, 153; 150, tuple; 150, 151; 150, 152; 151, identifier:k; 152, identifier:v; 153, identifier:all_normalized; 154, block; 154, 155; 155, continue_statement; 156, expression_statement; 156, 157; 157, augmented_assignment:+=; 157, 158; 157, 159; 158, identifier:all_normalized; 159, list:[(k, v)]; 159, 160; 160, tuple; 160, 161; 160, 162; 161, identifier:k; 162, identifier:v; 163, expression_statement; 163, 164; 164, call; 164, 165; 164, 168; 165, attribute; 165, 166; 165, 167; 166, identifier:all_normalized; 167, identifier:sort; 168, argument_list; 169, return_statement; 169, 170; 170, call; 170, 171; 170, 186; 171, attribute; 171, 172; 171, 184; 171, 185; 172, call; 172, 173; 172, 181; 173, attribute; 173, 174; 173, 179; 173, 180; 174, call; 174, 175; 174, 176; 175, identifier:urlencode; 176, argument_list; 176, 177; 176, 178; 177, identifier:all_normalized; 178, True; 179, line_continuation:\; 180, identifier:replace; 181, argument_list; 181, 182; 181, 183; 182, string:'+'; 183, string:'%20'; 184, line_continuation:\; 185, identifier:replace; 186, argument_list; 186, 187; 186, 188; 187, string:'%7E'; 188, string:'~'
|
def _normalize_request_parameters(self, oauth_params, req_kwargs):
'''
This process normalizes the request parameters as detailed in the OAuth
1.0 spec.
Additionally we apply a `Content-Type` header to the request of the
`FORM_URLENCODE` type if the `Content-Type` was previously set, i.e. if
this is a `POST` or `PUT` request. This ensures the correct header is
set as per spec.
Finally we sort the parameters in preparation for signing and return
a URL encoded string of all normalized parameters.
:param oauth_params: OAuth params to sign with.
:type oauth_params: dict
:param req_kwargs: Request kwargs to normalize.
:type req_kwargs: dict
'''
normalized = []
params = req_kwargs.get('params', {})
data = req_kwargs.get('data', {})
headers = req_kwargs.get('headers', {})
for k, v in params.items():
if v is not None:
normalized += [(k, v)]
if 'Content-Type' in headers and \
headers['Content-Type'] == FORM_URLENCODED:
for k, v in data.items():
normalized += [(k, v)]
all_normalized = []
for t in normalized:
k, v = t
if is_basestring(v) and not isinstance(v, bytes):
v = v.encode('utf-8')
all_normalized += [(k, v)]
for k, v in oauth_params.items():
if (k, v) in all_normalized:
continue
all_normalized += [(k, v)]
all_normalized.sort()
return urlencode(all_normalized, True)\
.replace('+', '%20')\
.replace('%7E', '~')
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:do_summary; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:params; 6, block; 6, 7; 6, 33; 6, 49; 6, 130; 6, 148; 7, expression_statement; 7, 8; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:show_output; 12, argument_list; 12, 13; 12, 14; 12, 20; 12, 26; 12, 32; 13, string:"%s%s%s%s"; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, string:"Created"; 17, identifier:ljust; 18, argument_list; 18, 19; 19, integer:32; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, string:"Last modified"; 23, identifier:ljust; 24, argument_list; 24, 25; 25, integer:32; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, string:"Owner"; 29, identifier:ljust; 30, argument_list; 30, 31; 31, integer:23; 32, string:"Name"; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:results; 36, call; 36, 37; 36, 38; 37, identifier:sorted; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 45; 40, attribute; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:self; 43, identifier:_zk; 44, identifier:stat_map; 45, argument_list; 45, 46; 46, attribute; 46, 47; 46, 48; 47, identifier:params; 48, identifier:path; 49, if_statement; 49, 50; 49, 55; 49, 67; 49, 97; 50, comparison_operator:==; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:params; 53, identifier:top; 54, integer:0; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 61; 58, pattern_list; 58, 59; 58, 60; 59, identifier:start; 60, identifier:end; 61, expression_list; 61, 62; 61, 63; 62, integer:0; 63, call; 63, 64; 63, 65; 64, identifier:len; 65, argument_list; 65, 66; 66, identifier:results; 67, elif_clause; 67, 68; 67, 73; 68, comparison_operator:>; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:params; 71, identifier:top; 72, integer:0; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 79; 76, pattern_list; 76, 77; 76, 78; 77, identifier:start; 78, identifier:end; 79, expression_list; 79, 80; 79, 81; 80, integer:0; 81, conditional_expression:if; 81, 82; 81, 85; 81, 93; 82, attribute; 82, 83; 82, 84; 83, identifier:params; 84, identifier:top; 85, comparison_operator:<; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:params; 88, identifier:top; 89, call; 89, 90; 89, 91; 90, identifier:len; 91, argument_list; 91, 92; 92, identifier:results; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, identifier:results; 97, else_clause; 97, 98; 98, block; 98, 99; 98, 123; 99, expression_statement; 99, 100; 100, assignment; 100, 101; 100, 102; 101, identifier:start; 102, conditional_expression:if; 102, 103; 102, 111; 102, 122; 103, binary_operator:+; 103, 104; 103, 108; 104, call; 104, 105; 104, 106; 105, identifier:len; 106, argument_list; 106, 107; 107, identifier:results; 108, attribute; 108, 109; 108, 110; 109, identifier:params; 110, identifier:top; 111, comparison_operator:<; 111, 112; 111, 118; 112, call; 112, 113; 112, 114; 113, identifier:abs; 114, argument_list; 114, 115; 115, attribute; 115, 116; 115, 117; 116, identifier:params; 117, identifier:top; 118, call; 118, 119; 118, 120; 119, identifier:len; 120, argument_list; 120, 121; 121, identifier:results; 122, integer:0; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 126; 125, identifier:end; 126, call; 126, 127; 126, 128; 127, identifier:len; 128, argument_list; 128, 129; 129, identifier:results; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:offs; 133, conditional_expression:if; 133, 134; 133, 135; 133, 140; 134, integer:1; 135, comparison_operator:==; 135, 136; 135, 139; 136, attribute; 136, 137; 136, 138; 137, identifier:params; 138, identifier:path; 139, string:"/"; 140, binary_operator:+; 140, 141; 140, 147; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, attribute; 144, 145; 144, 146; 145, identifier:params; 146, identifier:path; 147, integer:1; 148, for_statement; 148, 149; 148, 150; 148, 155; 149, identifier:i; 150, call; 150, 151; 150, 152; 151, identifier:range; 152, argument_list; 152, 153; 152, 154; 153, identifier:start; 154, identifier:end; 155, block; 155, 156; 155, 164; 156, expression_statement; 156, 157; 157, assignment; 157, 158; 157, 161; 158, pattern_list; 158, 159; 158, 160; 159, identifier:path; 160, identifier:stat; 161, subscript; 161, 162; 161, 163; 162, identifier:results; 163, identifier:i; 164, expression_statement; 164, 165; 165, call; 165, 166; 165, 169; 166, attribute; 166, 167; 166, 168; 167, identifier:self; 168, identifier:show_output; 169, argument_list; 169, 170; 169, 171; 169, 184; 169, 197; 169, 208; 170, string:"%s%s%s%s"; 171, call; 171, 172; 171, 182; 172, attribute; 172, 173; 172, 181; 173, call; 173, 174; 173, 177; 174, attribute; 174, 175; 174, 176; 175, identifier:time; 176, identifier:ctime; 177, argument_list; 177, 178; 178, attribute; 178, 179; 178, 180; 179, identifier:stat; 180, identifier:created; 181, identifier:ljust; 182, argument_list; 182, 183; 183, integer:32; 184, call; 184, 185; 184, 195; 185, attribute; 185, 186; 185, 194; 186, call; 186, 187; 186, 190; 187, attribute; 187, 188; 187, 189; 188, identifier:time; 189, identifier:ctime; 190, argument_list; 190, 191; 191, attribute; 191, 192; 191, 193; 192, identifier:stat; 193, identifier:last_modified; 194, identifier:ljust; 195, argument_list; 195, 196; 196, integer:32; 197, call; 197, 198; 197, 206; 198, attribute; 198, 199; 198, 205; 199, parenthesized_expression; 199, 200; 200, binary_operator:%; 200, 201; 200, 202; 201, string:"0x%x"; 202, attribute; 202, 203; 202, 204; 203, identifier:stat; 204, identifier:ephemeralOwner; 205, identifier:ljust; 206, argument_list; 206, 207; 207, integer:23; 208, subscript; 208, 209; 208, 210; 209, identifier:path; 210, slice; 210, 211; 210, 212; 211, identifier:offs; 212, colon
|
def do_summary(self, params):
self.show_output("%s%s%s%s",
"Created".ljust(32),
"Last modified".ljust(32),
"Owner".ljust(23),
"Name")
results = sorted(self._zk.stat_map(params.path))
if params.top == 0:
start, end = 0, len(results)
elif params.top > 0:
start, end = 0, params.top if params.top < len(results) else len(results)
else:
start = len(results) + params.top if abs(params.top) < len(results) else 0
end = len(results)
offs = 1 if params.path == "/" else len(params.path) + 1
for i in range(start, end):
path, stat = results[i]
self.show_output(
"%s%s%s%s",
time.ctime(stat.created).ljust(32),
time.ctime(stat.last_modified).ljust(32),
("0x%x" % stat.ephemeralOwner).ljust(23),
path[offs:]
)
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:do_json_count_values; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:params; 6, block; 6, 7; 6, 37; 6, 49; 6, 56; 6, 130; 6, 154; 6, 170; 6, 251; 6, 272; 6, 297; 7, try_statement; 7, 8; 7, 18; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:Keys; 13, identifier:validate; 14, argument_list; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:params; 17, identifier:keys; 18, except_clause; 18, 19; 18, 25; 19, as_pattern; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:Keys; 22, identifier:Bad; 23, as_pattern_target; 23, 24; 24, identifier:ex; 25, block; 25, 26; 25, 36; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:show_output; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:str; 34, argument_list; 34, 35; 35, identifier:ex; 36, return_statement; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:path_map; 40, call; 40, 41; 40, 42; 41, identifier:PathMap; 42, argument_list; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_zk; 46, attribute; 46, 47; 46, 48; 47, identifier:params; 48, identifier:path; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:values; 52, call; 52, 53; 52, 54; 53, identifier:defaultdict; 54, argument_list; 54, 55; 55, identifier:int; 56, for_statement; 56, 57; 56, 60; 56, 65; 57, pattern_list; 57, 58; 57, 59; 58, identifier:path; 59, identifier:data; 60, call; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:path_map; 63, identifier:get; 64, argument_list; 65, block; 65, 66; 66, try_statement; 66, 67; 66, 89; 66, 108; 67, block; 67, 68; 67, 83; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:value; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:Keys; 74, identifier:value; 75, argument_list; 75, 76; 75, 80; 76, call; 76, 77; 76, 78; 77, identifier:json_deserialize; 78, argument_list; 78, 79; 79, identifier:data; 80, attribute; 80, 81; 80, 82; 81, identifier:params; 82, identifier:keys; 83, expression_statement; 83, 84; 84, augmented_assignment:+=; 84, 85; 84, 88; 85, subscript; 85, 86; 85, 87; 86, identifier:values; 87, identifier:value; 88, integer:1; 89, except_clause; 89, 90; 89, 94; 90, as_pattern; 90, 91; 90, 92; 91, identifier:BadJSON; 92, as_pattern_target; 92, 93; 93, identifier:ex; 94, block; 94, 95; 95, if_statement; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:params; 98, identifier:report_errors; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 105; 102, attribute; 102, 103; 102, 104; 103, identifier:self; 104, identifier:show_output; 105, argument_list; 105, 106; 105, 107; 106, string:"Path %s has bad JSON."; 107, identifier:path; 108, except_clause; 108, 109; 108, 115; 109, as_pattern; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:Keys; 112, identifier:Missing; 113, as_pattern_target; 113, 114; 114, identifier:ex; 115, block; 115, 116; 116, if_statement; 116, 117; 116, 120; 117, attribute; 117, 118; 117, 119; 118, identifier:params; 119, identifier:report_errors; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:self; 125, identifier:show_output; 126, argument_list; 126, 127; 126, 128; 126, 129; 127, string:"Path %s is missing key %s."; 128, identifier:path; 129, identifier:ex; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:results; 133, call; 133, 134; 133, 135; 134, identifier:sorted; 135, argument_list; 135, 136; 135, 141; 135, 149; 136, call; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:values; 139, identifier:items; 140, argument_list; 141, keyword_argument; 141, 142; 141, 143; 142, identifier:key; 143, lambda; 143, 144; 143, 146; 144, lambda_parameters; 144, 145; 145, identifier:item; 146, subscript; 146, 147; 146, 148; 147, identifier:item; 148, integer:1; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:reverse; 151, attribute; 151, 152; 151, 153; 152, identifier:params; 153, identifier:reverse; 154, expression_statement; 154, 155; 155, assignment; 155, 156; 155, 157; 156, identifier:results; 157, list_comprehension; 157, 158; 157, 159; 157, 162; 158, identifier:r; 159, for_in_clause; 159, 160; 159, 161; 160, identifier:r; 161, identifier:results; 162, if_clause; 162, 163; 163, comparison_operator:>=; 163, 164; 163, 167; 164, subscript; 164, 165; 164, 166; 165, identifier:r; 166, integer:1; 167, attribute; 167, 168; 167, 169; 168, identifier:params; 169, identifier:minfreq; 170, if_statement; 170, 171; 170, 176; 170, 188; 170, 218; 171, comparison_operator:==; 171, 172; 171, 175; 172, attribute; 172, 173; 172, 174; 173, identifier:params; 174, identifier:top; 175, integer:0; 176, block; 176, 177; 177, expression_statement; 177, 178; 178, assignment; 178, 179; 178, 182; 179, pattern_list; 179, 180; 179, 181; 180, identifier:start; 181, identifier:end; 182, expression_list; 182, 183; 182, 184; 183, integer:0; 184, call; 184, 185; 184, 186; 185, identifier:len; 186, argument_list; 186, 187; 187, identifier:results; 188, elif_clause; 188, 189; 188, 194; 189, comparison_operator:>; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:params; 192, identifier:top; 193, integer:0; 194, block; 194, 195; 195, expression_statement; 195, 196; 196, assignment; 196, 197; 196, 200; 197, pattern_list; 197, 198; 197, 199; 198, identifier:start; 199, identifier:end; 200, expression_list; 200, 201; 200, 202; 201, integer:0; 202, conditional_expression:if; 202, 203; 202, 206; 202, 214; 203, attribute; 203, 204; 203, 205; 204, identifier:params; 205, identifier:top; 206, comparison_operator:<; 206, 207; 206, 210; 207, attribute; 207, 208; 207, 209; 208, identifier:params; 209, identifier:top; 210, call; 210, 211; 210, 212; 211, identifier:len; 212, argument_list; 212, 213; 213, identifier:results; 214, call; 214, 215; 214, 216; 215, identifier:len; 216, argument_list; 216, 217; 217, identifier:results; 218, else_clause; 218, 219; 219, block; 219, 220; 219, 244; 220, expression_statement; 220, 221; 221, assignment; 221, 222; 221, 223; 222, identifier:start; 223, conditional_expression:if; 223, 224; 223, 232; 223, 243; 224, binary_operator:+; 224, 225; 224, 229; 225, call; 225, 226; 225, 227; 226, identifier:len; 227, argument_list; 227, 228; 228, identifier:results; 229, attribute; 229, 230; 229, 231; 230, identifier:params; 231, identifier:top; 232, comparison_operator:<; 232, 233; 232, 239; 233, call; 233, 234; 233, 235; 234, identifier:abs; 235, argument_list; 235, 236; 236, attribute; 236, 237; 236, 238; 237, identifier:params; 238, identifier:top; 239, call; 239, 240; 239, 241; 240, identifier:len; 241, argument_list; 241, 242; 242, identifier:results; 243, integer:0; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:end; 247, call; 247, 248; 247, 249; 248, identifier:len; 249, argument_list; 249, 250; 250, identifier:results; 251, if_statement; 251, 252; 251, 262; 252, boolean_operator:and; 252, 253; 252, 259; 253, comparison_operator:>; 253, 254; 253, 258; 254, call; 254, 255; 254, 256; 255, identifier:len; 256, argument_list; 256, 257; 257, identifier:results; 258, integer:0; 259, attribute; 259, 260; 259, 261; 260, identifier:params; 261, identifier:print_path; 262, block; 262, 263; 263, expression_statement; 263, 264; 264, call; 264, 265; 264, 268; 265, attribute; 265, 266; 265, 267; 266, identifier:self; 267, identifier:show_output; 268, argument_list; 268, 269; 269, attribute; 269, 270; 269, 271; 270, identifier:params; 271, identifier:path; 272, for_statement; 272, 273; 272, 274; 272, 279; 273, identifier:i; 274, call; 274, 275; 274, 276; 275, identifier:range; 276, argument_list; 276, 277; 276, 278; 277, identifier:start; 278, identifier:end; 279, block; 279, 280; 279, 288; 280, expression_statement; 280, 281; 281, assignment; 281, 282; 281, 285; 282, pattern_list; 282, 283; 282, 284; 283, identifier:value; 284, identifier:frequency; 285, subscript; 285, 286; 285, 287; 286, identifier:results; 287, identifier:i; 288, expression_statement; 288, 289; 289, call; 289, 290; 289, 293; 290, attribute; 290, 291; 290, 292; 291, identifier:self; 292, identifier:show_output; 293, argument_list; 293, 294; 293, 295; 293, 296; 294, string:"%s = %d"; 295, identifier:value; 296, identifier:frequency; 297, if_statement; 297, 298; 297, 304; 298, comparison_operator:==; 298, 299; 298, 303; 299, call; 299, 300; 299, 301; 300, identifier:len; 301, argument_list; 301, 302; 302, identifier:results; 303, integer:0; 304, block; 304, 305; 305, return_statement; 305, 306; 306, False
|
def do_json_count_values(self, params):
try:
Keys.validate(params.keys)
except Keys.Bad as ex:
self.show_output(str(ex))
return
path_map = PathMap(self._zk, params.path)
values = defaultdict(int)
for path, data in path_map.get():
try:
value = Keys.value(json_deserialize(data), params.keys)
values[value] += 1
except BadJSON as ex:
if params.report_errors:
self.show_output("Path %s has bad JSON.", path)
except Keys.Missing as ex:
if params.report_errors:
self.show_output("Path %s is missing key %s.", path, ex)
results = sorted(values.items(), key=lambda item: item[1], reverse=params.reverse)
results = [r for r in results if r[1] >= params.minfreq]
if params.top == 0:
start, end = 0, len(results)
elif params.top > 0:
start, end = 0, params.top if params.top < len(results) else len(results)
else:
start = len(results) + params.top if abs(params.top) < len(results) else 0
end = len(results)
if len(results) > 0 and params.print_path:
self.show_output(params.path)
for i in range(start, end):
value, frequency = results[i]
self.show_output("%s = %d", value, frequency)
if len(results) == 0:
return False
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:do_json_dupes_for_keys; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:params; 6, block; 6, 7; 6, 37; 6, 49; 6, 60; 6, 160; 6, 164; 6, 233; 6, 244; 7, try_statement; 7, 8; 7, 18; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:Keys; 13, identifier:validate; 14, argument_list; 14, 15; 15, attribute; 15, 16; 15, 17; 16, identifier:params; 17, identifier:keys; 18, except_clause; 18, 19; 18, 25; 19, as_pattern; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:Keys; 22, identifier:Bad; 23, as_pattern_target; 23, 24; 24, identifier:ex; 25, block; 25, 26; 25, 36; 26, expression_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:show_output; 31, argument_list; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:str; 34, argument_list; 34, 35; 35, identifier:ex; 36, return_statement; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:path_map; 40, call; 40, 41; 40, 42; 41, identifier:PathMap; 42, argument_list; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:self; 45, identifier:_zk; 46, attribute; 46, 47; 46, 48; 47, identifier:params; 48, identifier:path; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:dupes_by_path; 52, call; 52, 53; 52, 54; 53, identifier:defaultdict; 54, argument_list; 54, 55; 55, lambda; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:defaultdict; 58, argument_list; 58, 59; 59, identifier:list; 60, for_statement; 60, 61; 60, 64; 60, 69; 61, pattern_list; 61, 62; 61, 63; 62, identifier:path; 63, identifier:data; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:path_map; 67, identifier:get; 68, argument_list; 69, block; 69, 70; 69, 79; 69, 91; 70, expression_statement; 70, 71; 71, assignment; 71, 72; 71, 75; 72, pattern_list; 72, 73; 72, 74; 73, identifier:parent; 74, identifier:child; 75, call; 75, 76; 75, 77; 76, identifier:split; 77, argument_list; 77, 78; 78, identifier:path; 79, if_statement; 79, 80; 79, 89; 80, not_operator; 80, 81; 81, call; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:child; 84, identifier:startswith; 85, argument_list; 85, 86; 86, attribute; 86, 87; 86, 88; 87, identifier:params; 88, identifier:prefix; 89, block; 89, 90; 90, continue_statement; 91, try_statement; 91, 92; 91, 119; 91, 138; 92, block; 92, 93; 92, 108; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:value; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:Keys; 99, identifier:value; 100, argument_list; 100, 101; 100, 105; 101, call; 101, 102; 101, 103; 102, identifier:json_deserialize; 103, argument_list; 103, 104; 104, identifier:data; 105, attribute; 105, 106; 105, 107; 106, identifier:params; 107, identifier:keys; 108, expression_statement; 108, 109; 109, call; 109, 110; 109, 117; 110, attribute; 110, 111; 110, 116; 111, subscript; 111, 112; 111, 115; 112, subscript; 112, 113; 112, 114; 113, identifier:dupes_by_path; 114, identifier:parent; 115, identifier:value; 116, identifier:append; 117, argument_list; 117, 118; 118, identifier:path; 119, except_clause; 119, 120; 119, 124; 120, as_pattern; 120, 121; 120, 122; 121, identifier:BadJSON; 122, as_pattern_target; 122, 123; 123, identifier:ex; 124, block; 124, 125; 125, if_statement; 125, 126; 125, 129; 126, attribute; 126, 127; 126, 128; 127, identifier:params; 128, identifier:report_errors; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:self; 134, identifier:show_output; 135, argument_list; 135, 136; 135, 137; 136, string:"Path %s has bad JSON."; 137, identifier:path; 138, except_clause; 138, 139; 138, 145; 139, as_pattern; 139, 140; 139, 143; 140, attribute; 140, 141; 140, 142; 141, identifier:Keys; 142, identifier:Missing; 143, as_pattern_target; 143, 144; 144, identifier:ex; 145, block; 145, 146; 146, if_statement; 146, 147; 146, 150; 147, attribute; 147, 148; 147, 149; 148, identifier:params; 149, identifier:report_errors; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, call; 152, 153; 152, 156; 153, attribute; 153, 154; 153, 155; 154, identifier:self; 155, identifier:show_output; 156, argument_list; 156, 157; 156, 158; 156, 159; 157, string:"Path %s is missing key %s."; 158, identifier:path; 159, identifier:ex; 160, expression_statement; 160, 161; 161, assignment; 161, 162; 161, 163; 162, identifier:dupes; 163, list:[]; 164, for_statement; 164, 165; 164, 168; 164, 173; 165, pattern_list; 165, 166; 165, 167; 166, identifier:_; 167, identifier:paths_by_value; 168, call; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:dupes_by_path; 171, identifier:items; 172, argument_list; 173, block; 173, 174; 174, for_statement; 174, 175; 174, 178; 174, 183; 175, pattern_list; 175, 176; 175, 177; 176, identifier:_; 177, identifier:paths; 178, call; 178, 179; 178, 182; 179, attribute; 179, 180; 179, 181; 180, identifier:paths_by_value; 181, identifier:items; 182, argument_list; 183, block; 183, 184; 184, if_statement; 184, 185; 184, 191; 185, comparison_operator:>; 185, 186; 185, 190; 186, call; 186, 187; 186, 188; 187, identifier:len; 188, argument_list; 188, 189; 189, identifier:paths; 190, integer:1; 191, block; 191, 192; 191, 198; 191, 211; 192, expression_statement; 192, 193; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, identifier:paths; 196, identifier:sort; 197, argument_list; 198, expression_statement; 198, 199; 199, assignment; 199, 200; 199, 201; 200, identifier:paths; 201, conditional_expression:if; 201, 202; 201, 203; 201, 206; 202, identifier:paths; 203, attribute; 203, 204; 203, 205; 204, identifier:params; 205, identifier:first; 206, subscript; 206, 207; 206, 208; 207, identifier:paths; 208, slice; 208, 209; 208, 210; 209, integer:1; 210, colon; 211, for_statement; 211, 212; 211, 213; 211, 214; 212, identifier:path; 213, identifier:paths; 214, block; 214, 215; 214, 225; 215, expression_statement; 215, 216; 216, assignment; 216, 217; 216, 218; 217, identifier:idx; 218, call; 218, 219; 218, 222; 219, attribute; 219, 220; 219, 221; 220, identifier:bisect; 221, identifier:bisect; 222, argument_list; 222, 223; 222, 224; 223, identifier:dupes; 224, identifier:path; 225, expression_statement; 225, 226; 226, call; 226, 227; 226, 230; 227, attribute; 227, 228; 227, 229; 228, identifier:dupes; 229, identifier:insert; 230, argument_list; 230, 231; 230, 232; 231, identifier:idx; 232, identifier:path; 233, for_statement; 233, 234; 233, 235; 233, 236; 234, identifier:dup; 235, identifier:dupes; 236, block; 236, 237; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:self; 241, identifier:show_output; 242, argument_list; 242, 243; 243, identifier:dup; 244, if_statement; 244, 245; 244, 251; 245, comparison_operator:==; 245, 246; 245, 250; 246, call; 246, 247; 246, 248; 247, identifier:len; 248, argument_list; 248, 249; 249, identifier:dupes; 250, integer:0; 251, block; 251, 252; 252, return_statement; 252, 253; 253, False
|
def do_json_dupes_for_keys(self, params):
try:
Keys.validate(params.keys)
except Keys.Bad as ex:
self.show_output(str(ex))
return
path_map = PathMap(self._zk, params.path)
dupes_by_path = defaultdict(lambda: defaultdict(list))
for path, data in path_map.get():
parent, child = split(path)
if not child.startswith(params.prefix):
continue
try:
value = Keys.value(json_deserialize(data), params.keys)
dupes_by_path[parent][value].append(path)
except BadJSON as ex:
if params.report_errors:
self.show_output("Path %s has bad JSON.", path)
except Keys.Missing as ex:
if params.report_errors:
self.show_output("Path %s is missing key %s.", path, ex)
dupes = []
for _, paths_by_value in dupes_by_path.items():
for _, paths in paths_by_value.items():
if len(paths) > 1:
paths.sort()
paths = paths if params.first else paths[1:]
for path in paths:
idx = bisect.bisect(dupes, path)
dupes.insert(idx, path)
for dup in dupes:
self.show_output(dup)
if len(dupes) == 0:
return False
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:add_property_orders; 3, parameters; 3, 4; 3, 5; 4, identifier:query_proto; 5, list_splat_pattern; 5, 6; 6, identifier:orders; 7, block; 7, 8; 8, for_statement; 8, 9; 8, 10; 8, 11; 9, identifier:order; 10, identifier:orders; 11, block; 11, 12; 11, 22; 11, 59; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:proto; 15, call; 15, 16; 15, 21; 16, attribute; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:query_proto; 19, identifier:order; 20, identifier:add; 21, argument_list; 22, if_statement; 22, 23; 22, 28; 22, 47; 23, comparison_operator:==; 23, 24; 23, 27; 24, subscript; 24, 25; 24, 26; 25, identifier:order; 26, integer:0; 27, string:'-'; 28, block; 28, 29; 28, 37; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:order; 32, subscript; 32, 33; 32, 34; 33, identifier:order; 34, slice; 34, 35; 34, 36; 35, integer:1; 36, colon; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:proto; 41, identifier:direction; 42, attribute; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:query_pb2; 45, identifier:PropertyOrder; 46, identifier:DESCENDING; 47, else_clause; 47, 48; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:proto; 53, identifier:direction; 54, attribute; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:query_pb2; 57, identifier:PropertyOrder; 58, identifier:ASCENDING; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 66; 61, attribute; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:proto; 64, identifier:property; 65, identifier:name; 66, identifier:order
|
def add_property_orders(query_proto, *orders):
for order in orders:
proto = query_proto.order.add()
if order[0] == '-':
order = order[1:]
proto.direction = query_pb2.PropertyOrder.DESCENDING
else:
proto.direction = query_pb2.PropertyOrder.ASCENDING
proto.property.name = order
|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:check_levels; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:imls; 5, identifier:imt; 6, default_parameter; 6, 7; 6, 8; 7, identifier:min_iml; 8, float:1E-10; 9, block; 9, 10; 10, if_statement; 10, 11; 10, 17; 10, 27; 10, 44; 10, 67; 10, 92; 11, comparison_operator:<; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:len; 14, argument_list; 14, 15; 15, identifier:imls; 16, integer:1; 17, block; 17, 18; 18, raise_statement; 18, 19; 19, call; 19, 20; 19, 21; 20, identifier:ValueError; 21, argument_list; 21, 22; 22, binary_operator:%; 22, 23; 22, 24; 23, string:'No imls for %s: %s'; 24, tuple; 24, 25; 24, 26; 25, identifier:imt; 26, identifier:imls; 27, elif_clause; 27, 28; 27, 34; 28, comparison_operator:!=; 28, 29; 28, 30; 29, identifier:imls; 30, call; 30, 31; 30, 32; 31, identifier:sorted; 32, argument_list; 32, 33; 33, identifier:imls; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:ValueError; 38, argument_list; 38, 39; 39, binary_operator:%; 39, 40; 39, 41; 40, string:'The imls for %s are not sorted: %s'; 41, tuple; 41, 42; 41, 43; 42, identifier:imt; 43, identifier:imls; 44, elif_clause; 44, 45; 44, 57; 45, comparison_operator:<; 45, 46; 45, 53; 46, call; 46, 47; 46, 48; 47, identifier:len; 48, argument_list; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:distinct; 51, argument_list; 51, 52; 52, identifier:imls; 53, call; 53, 54; 53, 55; 54, identifier:len; 55, argument_list; 55, 56; 56, identifier:imls; 57, block; 57, 58; 58, raise_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:ValueError; 61, argument_list; 61, 62; 62, binary_operator:%; 62, 63; 62, 64; 63, string:"Found duplicated levels for %s: %s"; 64, tuple; 64, 65; 64, 66; 65, identifier:imt; 66, identifier:imls; 67, elif_clause; 67, 68; 67, 79; 68, boolean_operator:and; 68, 69; 68, 74; 69, comparison_operator:==; 69, 70; 69, 73; 70, subscript; 70, 71; 70, 72; 71, identifier:imls; 72, integer:0; 73, integer:0; 74, comparison_operator:<=; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:imls; 77, integer:1; 78, identifier:min_iml; 79, block; 79, 80; 80, raise_statement; 80, 81; 81, call; 81, 82; 81, 83; 82, identifier:ValueError; 83, argument_list; 83, 84; 84, binary_operator:%; 84, 85; 84, 88; 85, concatenated_string; 85, 86; 85, 87; 86, string:"The min_iml %s=%s is larger than the second level "; 87, string:"for %s"; 88, tuple; 88, 89; 88, 90; 88, 91; 89, identifier:imt; 90, identifier:min_iml; 91, identifier:imls; 92, elif_clause; 92, 93; 92, 104; 93, boolean_operator:and; 93, 94; 93, 99; 94, comparison_operator:==; 94, 95; 94, 98; 95, subscript; 95, 96; 95, 97; 96, identifier:imls; 97, integer:0; 98, integer:0; 99, comparison_operator:>; 99, 100; 99, 103; 100, subscript; 100, 101; 100, 102; 101, identifier:imls; 102, integer:1; 103, identifier:min_iml; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 110; 107, subscript; 107, 108; 107, 109; 108, identifier:imls; 109, integer:0; 110, identifier:min_iml
|
def check_levels(imls, imt, min_iml=1E-10):
if len(imls) < 1:
raise ValueError('No imls for %s: %s' % (imt, imls))
elif imls != sorted(imls):
raise ValueError('The imls for %s are not sorted: %s' % (imt, imls))
elif len(distinct(imls)) < len(imls):
raise ValueError("Found duplicated levels for %s: %s" % (imt, imls))
elif imls[0] == 0 and imls[1] <= min_iml:
raise ValueError("The min_iml %s=%s is larger than the second level "
"for %s" % (imt, min_iml, imls))
elif imls[0] == 0 and imls[1] > min_iml:
imls[0] = min_iml
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.