sequence
stringlengths 492
15.9k
| code
stringlengths 75
8.58k
|
|---|---|
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 32; 2, function_name:usearch_chimera_filter_de_novo; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:fasta_filepath; 5, default_parameter; 5, 6; 5, 7; 6, identifier:output_chimera_filepath; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:output_non_chimera_filepath; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:abundance_skew; 13, float:2.0; 14, default_parameter; 14, 15; 14, 16; 15, identifier:log_name; 16, string:"uchime_de_novo_chimera_filtering.log"; 17, default_parameter; 17, 18; 17, 19; 18, identifier:usersort; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:HALT_EXEC; 22, False; 23, default_parameter; 23, 24; 23, 25; 24, identifier:save_intermediate_files; 25, False; 26, default_parameter; 26, 27; 26, 28; 27, identifier:remove_usearch_logs; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:working_dir; 31, None; 32, block; 32, 33; 32, 51; 32, 69; 32, 77; 32, 84; 32, 97; 32, 110; 32, 123; 32, 133; 32, 140; 32, 150; 33, if_statement; 33, 34; 33, 36; 34, not_operator; 34, 35; 35, identifier:output_chimera_filepath; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, pattern_list; 39, 40; 39, 41; 40, identifier:_; 41, identifier:output_chimera_filepath; 42, call; 42, 43; 42, 44; 43, identifier:mkstemp; 44, argument_list; 44, 45; 44, 48; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:prefix; 47, string:'uchime_chimeras_'; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:suffix; 50, string:'.fasta'; 51, if_statement; 51, 52; 51, 54; 52, not_operator; 52, 53; 53, identifier:output_non_chimera_filepath; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, pattern_list; 57, 58; 57, 59; 58, identifier:_; 59, identifier:output_non_chimera_filepath; 60, call; 60, 61; 60, 62; 61, identifier:mkstemp; 62, argument_list; 62, 63; 62, 66; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:prefix; 65, string:'uchime_non_chimeras_'; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:suffix; 68, string:'.fasta'; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:log_filepath; 72, call; 72, 73; 72, 74; 73, identifier:join; 74, argument_list; 74, 75; 74, 76; 75, identifier:working_dir; 76, identifier:log_name; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:params; 80, dictionary; 80, 81; 81, pair; 81, 82; 81, 83; 82, string:'--abskew'; 83, identifier:abundance_skew; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:app; 87, call; 87, 88; 87, 89; 88, identifier:Usearch; 89, argument_list; 89, 90; 89, 91; 89, 94; 90, identifier:params; 91, keyword_argument; 91, 92; 91, 93; 92, identifier:WorkingDir; 93, identifier:working_dir; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:HALT_EXEC; 96, identifier:HALT_EXEC; 97, if_statement; 97, 98; 97, 99; 98, identifier:usersort; 99, block; 99, 100; 100, expression_statement; 100, 101; 101, call; 101, 102; 101, 109; 102, attribute; 102, 103; 102, 108; 103, subscript; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:app; 106, identifier:Parameters; 107, string:'--usersort'; 108, identifier:on; 109, argument_list; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:data; 113, dictionary; 113, 114; 113, 117; 113, 120; 114, pair; 114, 115; 114, 116; 115, string:'--uchime'; 116, identifier:fasta_filepath; 117, pair; 117, 118; 117, 119; 118, string:'--chimeras'; 119, identifier:output_chimera_filepath; 120, pair; 120, 121; 120, 122; 121, string:'--nonchimeras'; 122, identifier:output_non_chimera_filepath; 123, if_statement; 123, 124; 123, 126; 124, not_operator; 124, 125; 125, identifier:remove_usearch_logs; 126, block; 126, 127; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 132; 129, subscript; 129, 130; 129, 131; 130, identifier:data; 131, string:'--log'; 132, identifier:log_filepath; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:app_result; 136, call; 136, 137; 136, 138; 137, identifier:app; 138, argument_list; 138, 139; 139, identifier:data; 140, if_statement; 140, 141; 140, 143; 141, not_operator; 141, 142; 142, identifier:save_intermediate_files; 143, block; 143, 144; 144, expression_statement; 144, 145; 145, call; 145, 146; 145, 147; 146, identifier:remove_files; 147, argument_list; 147, 148; 148, list:[output_chimera_filepath]; 148, 149; 149, identifier:output_chimera_filepath; 150, return_statement; 150, 151; 151, expression_list; 151, 152; 151, 153; 152, identifier:app_result; 153, identifier:output_non_chimera_filepath | def usearch_chimera_filter_de_novo(
fasta_filepath,
output_chimera_filepath=None,
output_non_chimera_filepath=None,
abundance_skew=2.0,
log_name="uchime_de_novo_chimera_filtering.log",
usersort=False,
HALT_EXEC=False,
save_intermediate_files=False,
remove_usearch_logs=False,
working_dir=None):
if not output_chimera_filepath:
_, output_chimera_filepath = mkstemp(prefix='uchime_chimeras_',
suffix='.fasta')
if not output_non_chimera_filepath:
_, output_non_chimera_filepath = mkstemp(prefix='uchime_non_chimeras_',
suffix='.fasta')
log_filepath = join(working_dir, log_name)
params = {'--abskew': abundance_skew}
app = Usearch(params, WorkingDir=working_dir, HALT_EXEC=HALT_EXEC)
if usersort:
app.Parameters['--usersort'].on()
data = {'--uchime': fasta_filepath,
'--chimeras': output_chimera_filepath,
'--nonchimeras': output_non_chimera_filepath
}
if not remove_usearch_logs:
data['--log'] = log_filepath
app_result = app(data)
if not save_intermediate_files:
remove_files([output_chimera_filepath])
return app_result, output_non_chimera_filepath |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 56; 2, function_name:usearch_cluster_seqs_ref; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 3, 38; 3, 41; 3, 44; 3, 47; 3, 50; 3, 53; 4, identifier:fasta_filepath; 5, default_parameter; 5, 6; 5, 7; 6, identifier:output_filepath; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:percent_id; 10, float:0.97; 11, default_parameter; 11, 12; 11, 13; 12, identifier:sizein; 13, True; 14, default_parameter; 14, 15; 14, 16; 15, identifier:sizeout; 16, True; 17, default_parameter; 17, 18; 17, 19; 18, identifier:w; 19, integer:64; 20, default_parameter; 20, 21; 20, 22; 21, identifier:slots; 22, integer:16769023; 23, default_parameter; 23, 24; 23, 25; 24, identifier:maxrejects; 25, integer:64; 26, default_parameter; 26, 27; 26, 28; 27, identifier:log_name; 28, string:"usearch_cluster_seqs.log"; 29, default_parameter; 29, 30; 29, 31; 30, identifier:usersort; 31, True; 32, default_parameter; 32, 33; 32, 34; 33, identifier:HALT_EXEC; 34, False; 35, default_parameter; 35, 36; 35, 37; 36, identifier:save_intermediate_files; 37, False; 38, default_parameter; 38, 39; 38, 40; 39, identifier:remove_usearch_logs; 40, False; 41, default_parameter; 41, 42; 41, 43; 42, identifier:suppress_new_clusters; 43, False; 44, default_parameter; 44, 45; 44, 46; 45, identifier:refseqs_fp; 46, None; 47, default_parameter; 47, 48; 47, 49; 48, identifier:output_dir; 49, None; 50, default_parameter; 50, 51; 50, 52; 51, identifier:working_dir; 52, None; 53, default_parameter; 53, 54; 53, 55; 54, identifier:rev; 55, False; 56, block; 56, 57; 56, 75; 56, 83; 56, 91; 56, 113; 56, 126; 56, 139; 56, 152; 56, 165; 56, 175; 56, 182; 56, 186; 56, 362; 56, 371; 57, if_statement; 57, 58; 57, 60; 58, not_operator; 58, 59; 59, identifier:output_filepath; 60, block; 60, 61; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, pattern_list; 63, 64; 63, 65; 64, identifier:_; 65, identifier:output_filepath; 66, call; 66, 67; 66, 68; 67, identifier:mkstemp; 68, argument_list; 68, 69; 68, 72; 69, keyword_argument; 69, 70; 69, 71; 70, identifier:prefix; 71, string:'usearch_cluster_ref_based'; 72, keyword_argument; 72, 73; 72, 74; 73, identifier:suffix; 74, string:'.uc'; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 78; 77, identifier:log_filepath; 78, call; 78, 79; 78, 80; 79, identifier:join; 80, argument_list; 80, 81; 80, 82; 81, identifier:working_dir; 82, identifier:log_name; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:uc_filepath; 86, call; 86, 87; 86, 88; 87, identifier:join; 88, argument_list; 88, 89; 88, 90; 89, identifier:working_dir; 90, string:"clustered_seqs_post_chimera.uc"; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:params; 94, dictionary; 94, 95; 94, 98; 94, 101; 94, 104; 94, 107; 94, 110; 95, pair; 95, 96; 95, 97; 96, string:'--sizein'; 97, identifier:sizein; 98, pair; 98, 99; 98, 100; 99, string:'--sizeout'; 100, identifier:sizeout; 101, pair; 101, 102; 101, 103; 102, string:'--id'; 103, identifier:percent_id; 104, pair; 104, 105; 104, 106; 105, string:'--w'; 106, identifier:w; 107, pair; 107, 108; 107, 109; 108, string:'--slots'; 109, identifier:slots; 110, pair; 110, 111; 110, 112; 111, string:'--maxrejects'; 112, identifier:maxrejects; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:app; 116, call; 116, 117; 116, 118; 117, identifier:Usearch; 118, argument_list; 118, 119; 118, 120; 118, 123; 119, identifier:params; 120, keyword_argument; 120, 121; 120, 122; 121, identifier:WorkingDir; 122, identifier:working_dir; 123, keyword_argument; 123, 124; 123, 125; 124, identifier:HALT_EXEC; 125, identifier:HALT_EXEC; 126, if_statement; 126, 127; 126, 128; 127, identifier:usersort; 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:app; 135, identifier:Parameters; 136, string:'--usersort'; 137, identifier:on; 138, argument_list; 139, if_statement; 139, 140; 139, 141; 140, identifier:rev; 141, block; 141, 142; 142, expression_statement; 142, 143; 143, call; 143, 144; 143, 151; 144, attribute; 144, 145; 144, 150; 145, subscript; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:app; 148, identifier:Parameters; 149, string:'--rev'; 150, identifier:on; 151, argument_list; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:data; 155, dictionary; 155, 156; 155, 159; 155, 162; 156, pair; 156, 157; 156, 158; 157, string:'--query'; 158, identifier:fasta_filepath; 159, pair; 159, 160; 159, 161; 160, string:'--uc'; 161, identifier:uc_filepath; 162, pair; 162, 163; 162, 164; 163, string:'--db'; 164, identifier:refseqs_fp; 165, if_statement; 165, 166; 165, 168; 166, not_operator; 166, 167; 167, identifier:remove_usearch_logs; 168, block; 168, 169; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 174; 171, subscript; 171, 172; 171, 173; 172, identifier:data; 173, string:'--log'; 174, identifier:log_filepath; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 178; 177, identifier:app_result; 178, call; 178, 179; 178, 180; 179, identifier:app; 180, argument_list; 180, 181; 181, identifier:data; 182, expression_statement; 182, 183; 183, assignment; 183, 184; 183, 185; 184, identifier:files_to_remove; 185, list:[]; 186, if_statement; 186, 187; 186, 188; 186, 223; 187, identifier:suppress_new_clusters; 188, block; 188, 189; 188, 197; 188, 216; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:output_fna_filepath; 192, call; 192, 193; 192, 194; 193, identifier:join; 194, argument_list; 194, 195; 194, 196; 195, identifier:output_dir; 196, string:'ref_clustered_seqs.fasta'; 197, expression_statement; 197, 198; 198, assignment; 198, 199; 198, 202; 199, pattern_list; 199, 200; 199, 201; 200, identifier:output_filepath; 201, identifier:labels_hits; 202, call; 202, 203; 202, 204; 203, identifier:get_fasta_from_uc_file; 204, argument_list; 204, 205; 204, 206; 204, 207; 204, 210; 204, 213; 205, identifier:fasta_filepath; 206, identifier:uc_filepath; 207, keyword_argument; 207, 208; 207, 209; 208, identifier:hit_type; 209, string:"H"; 210, keyword_argument; 210, 211; 210, 212; 211, identifier:output_dir; 212, identifier:output_dir; 213, keyword_argument; 213, 214; 213, 215; 214, identifier:output_fna_filepath; 215, identifier:output_fna_filepath; 216, expression_statement; 216, 217; 217, call; 217, 218; 217, 221; 218, attribute; 218, 219; 218, 220; 219, identifier:files_to_remove; 220, identifier:append; 221, argument_list; 221, 222; 222, identifier:uc_filepath; 223, else_clause; 223, 224; 224, block; 224, 225; 224, 233; 224, 253; 224, 262; 224, 282; 224, 326; 224, 341; 224, 348; 224, 355; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:output_fna_clustered; 228, call; 228, 229; 228, 230; 229, identifier:join; 230, argument_list; 230, 231; 230, 232; 231, identifier:output_dir; 232, string:'ref_clustered_seqs.fasta'; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 238; 234, 239; 235, pattern_list; 235, 236; 235, 237; 236, identifier:output_filepath_ref_clusters; 237, identifier:labels_hits; 238, line_continuation:\; 239, call; 239, 240; 239, 241; 240, identifier:get_fasta_from_uc_file; 241, argument_list; 241, 242; 241, 243; 241, 244; 241, 247; 241, 250; 242, identifier:fasta_filepath; 243, identifier:uc_filepath; 244, keyword_argument; 244, 245; 244, 246; 245, identifier:hit_type; 246, string:"H"; 247, keyword_argument; 247, 248; 247, 249; 248, identifier:output_dir; 249, identifier:output_dir; 250, keyword_argument; 250, 251; 250, 252; 251, identifier:output_fna_filepath; 252, identifier:output_fna_clustered; 253, expression_statement; 253, 254; 254, assignment; 254, 255; 254, 256; 254, 257; 255, identifier:output_fna_failures; 256, line_continuation:\; 257, call; 257, 258; 257, 259; 258, identifier:join; 259, argument_list; 259, 260; 259, 261; 260, identifier:output_dir; 261, string:'ref_clustered_seqs_failures.fasta'; 262, expression_statement; 262, 263; 263, assignment; 263, 264; 263, 267; 263, 268; 264, pattern_list; 264, 265; 264, 266; 265, identifier:output_filepath_failures; 266, identifier:labels_hits; 267, line_continuation:\; 268, call; 268, 269; 268, 270; 269, identifier:get_fasta_from_uc_file; 270, argument_list; 270, 271; 270, 272; 270, 273; 270, 276; 270, 279; 271, identifier:fasta_filepath; 272, identifier:uc_filepath; 273, keyword_argument; 273, 274; 273, 275; 274, identifier:hit_type; 275, string:"N"; 276, keyword_argument; 276, 277; 276, 278; 277, identifier:output_dir; 278, identifier:output_dir; 279, keyword_argument; 279, 280; 279, 281; 280, identifier:output_fna_filepath; 281, identifier:output_fna_failures; 282, expression_statement; 282, 283; 283, assignment; 283, 284; 283, 287; 283, 288; 284, pattern_list; 284, 285; 284, 286; 285, identifier:app_result; 286, identifier:output_filepath_clustered_failures; 287, line_continuation:\; 288, call; 288, 289; 288, 290; 289, identifier:usearch_cluster_seqs; 290, argument_list; 290, 291; 290, 292; 290, 299; 290, 302; 290, 305; 290, 308; 290, 311; 290, 314; 290, 317; 290, 320; 290, 323; 291, identifier:output_fna_failures; 292, keyword_argument; 292, 293; 292, 294; 293, identifier:output_filepath; 294, call; 294, 295; 294, 296; 295, identifier:join; 296, argument_list; 296, 297; 296, 298; 297, identifier:output_dir; 298, string:'clustered_seqs_reference_failures.fasta'; 299, keyword_argument; 299, 300; 299, 301; 300, identifier:percent_id; 301, identifier:percent_id; 302, keyword_argument; 302, 303; 302, 304; 303, identifier:sizein; 304, identifier:sizein; 305, keyword_argument; 305, 306; 305, 307; 306, identifier:sizeout; 307, identifier:sizeout; 308, keyword_argument; 308, 309; 308, 310; 309, identifier:w; 310, identifier:w; 311, keyword_argument; 311, 312; 311, 313; 312, identifier:slots; 313, identifier:slots; 314, keyword_argument; 314, 315; 314, 316; 315, identifier:maxrejects; 316, identifier:maxrejects; 317, keyword_argument; 317, 318; 317, 319; 318, identifier:save_intermediate_files; 319, identifier:save_intermediate_files; 320, keyword_argument; 320, 321; 320, 322; 321, identifier:remove_usearch_logs; 322, identifier:remove_usearch_logs; 323, keyword_argument; 323, 324; 323, 325; 324, identifier:working_dir; 325, identifier:working_dir; 326, expression_statement; 326, 327; 327, assignment; 327, 328; 327, 329; 328, identifier:output_filepath; 329, call; 329, 330; 329, 331; 330, identifier:concatenate_fastas; 331, argument_list; 331, 332; 331, 333; 331, 334; 332, identifier:output_fna_clustered; 333, identifier:output_fna_failures; 334, keyword_argument; 334, 335; 334, 336; 335, identifier:output_concat_filepath; 336, call; 336, 337; 336, 338; 337, identifier:join; 338, argument_list; 338, 339; 338, 340; 339, identifier:output_dir; 340, string:'concatenated_reference_denovo_clusters.fasta'; 341, expression_statement; 341, 342; 342, call; 342, 343; 342, 346; 343, attribute; 343, 344; 343, 345; 344, identifier:files_to_remove; 345, identifier:append; 346, argument_list; 346, 347; 347, identifier:output_fna_clustered; 348, expression_statement; 348, 349; 349, call; 349, 350; 349, 353; 350, attribute; 350, 351; 350, 352; 351, identifier:files_to_remove; 352, identifier:append; 353, argument_list; 353, 354; 354, identifier:output_fna_failures; 355, expression_statement; 355, 356; 356, call; 356, 357; 356, 360; 357, attribute; 357, 358; 357, 359; 358, identifier:files_to_remove; 359, identifier:append; 360, argument_list; 360, 361; 361, identifier:output_filepath_clustered_failures; 362, if_statement; 362, 363; 362, 365; 363, not_operator; 363, 364; 364, identifier:save_intermediate_files; 365, block; 365, 366; 366, expression_statement; 366, 367; 367, call; 367, 368; 367, 369; 368, identifier:remove_files; 369, argument_list; 369, 370; 370, identifier:files_to_remove; 371, return_statement; 371, 372; 372, expression_list; 372, 373; 372, 374; 373, identifier:app_result; 374, identifier:output_filepath | def usearch_cluster_seqs_ref(
fasta_filepath,
output_filepath=None,
percent_id=0.97,
sizein=True,
sizeout=True,
w=64,
slots=16769023,
maxrejects=64,
log_name="usearch_cluster_seqs.log",
usersort=True,
HALT_EXEC=False,
save_intermediate_files=False,
remove_usearch_logs=False,
suppress_new_clusters=False,
refseqs_fp=None,
output_dir=None,
working_dir=None,
rev=False):
if not output_filepath:
_, output_filepath = mkstemp(prefix='usearch_cluster_ref_based',
suffix='.uc')
log_filepath = join(working_dir, log_name)
uc_filepath = join(working_dir, "clustered_seqs_post_chimera.uc")
params = {'--sizein': sizein,
'--sizeout': sizeout,
'--id': percent_id,
'--w': w,
'--slots': slots,
'--maxrejects': maxrejects}
app = Usearch(params, WorkingDir=working_dir, HALT_EXEC=HALT_EXEC)
if usersort:
app.Parameters['--usersort'].on()
if rev:
app.Parameters['--rev'].on()
data = {'--query': fasta_filepath,
'--uc': uc_filepath,
'--db': refseqs_fp
}
if not remove_usearch_logs:
data['--log'] = log_filepath
app_result = app(data)
files_to_remove = []
if suppress_new_clusters:
output_fna_filepath = join(output_dir, 'ref_clustered_seqs.fasta')
output_filepath, labels_hits = get_fasta_from_uc_file(fasta_filepath,
uc_filepath, hit_type="H", output_dir=output_dir,
output_fna_filepath=output_fna_filepath)
files_to_remove.append(uc_filepath)
else:
output_fna_clustered = join(output_dir, 'ref_clustered_seqs.fasta')
output_filepath_ref_clusters, labels_hits =\
get_fasta_from_uc_file(fasta_filepath, uc_filepath, hit_type="H",
output_dir=output_dir, output_fna_filepath=output_fna_clustered)
output_fna_failures =\
join(output_dir, 'ref_clustered_seqs_failures.fasta')
output_filepath_failures, labels_hits =\
get_fasta_from_uc_file(fasta_filepath,
uc_filepath, hit_type="N", output_dir=output_dir,
output_fna_filepath=output_fna_failures)
app_result, output_filepath_clustered_failures =\
usearch_cluster_seqs(output_fna_failures, output_filepath=
join(
output_dir,
'clustered_seqs_reference_failures.fasta'),
percent_id=percent_id, sizein=sizein, sizeout=sizeout, w=w,
slots=slots, maxrejects=maxrejects,
save_intermediate_files=save_intermediate_files,
remove_usearch_logs=remove_usearch_logs, working_dir=working_dir)
output_filepath = concatenate_fastas(output_fna_clustered,
output_fna_failures, output_concat_filepath=join(
output_dir,
'concatenated_reference_denovo_clusters.fasta'))
files_to_remove.append(output_fna_clustered)
files_to_remove.append(output_fna_failures)
files_to_remove.append(output_filepath_clustered_failures)
if not save_intermediate_files:
remove_files(files_to_remove)
return app_result, output_filepath |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 30; 2, function_name:assign_reads_to_otus; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 3, 27; 4, identifier:original_fasta; 5, identifier:filtered_fasta; 6, default_parameter; 6, 7; 6, 8; 7, identifier:output_filepath; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:log_name; 11, string:"assign_reads_to_otus.log"; 12, default_parameter; 12, 13; 12, 14; 13, identifier:perc_id_blast; 14, float:0.97; 15, default_parameter; 15, 16; 15, 17; 16, identifier:global_alignment; 17, True; 18, default_parameter; 18, 19; 18, 20; 19, identifier:HALT_EXEC; 20, False; 21, default_parameter; 21, 22; 21, 23; 22, identifier:save_intermediate_files; 23, False; 24, default_parameter; 24, 25; 24, 26; 25, identifier:remove_usearch_logs; 26, False; 27, default_parameter; 27, 28; 27, 29; 28, identifier:working_dir; 29, None; 30, block; 30, 31; 30, 49; 30, 57; 30, 67; 30, 80; 30, 93; 30, 103; 30, 110; 31, if_statement; 31, 32; 31, 34; 32, not_operator; 32, 33; 33, identifier:output_filepath; 34, block; 34, 35; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 40; 37, pattern_list; 37, 38; 37, 39; 38, identifier:_; 39, identifier:output_filepath; 40, call; 40, 41; 40, 42; 41, identifier:mkstemp; 42, argument_list; 42, 43; 42, 46; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:prefix; 45, string:'assign_reads_to_otus'; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:suffix; 48, string:'.uc'; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:log_filepath; 52, call; 52, 53; 52, 54; 53, identifier:join; 54, argument_list; 54, 55; 54, 56; 55, identifier:working_dir; 56, identifier:log_name; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:params; 60, dictionary; 60, 61; 60, 64; 61, pair; 61, 62; 61, 63; 62, string:'--id'; 63, identifier:perc_id_blast; 64, pair; 64, 65; 64, 66; 65, string:'--global'; 66, identifier:global_alignment; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:app; 70, call; 70, 71; 70, 72; 71, identifier:Usearch; 72, argument_list; 72, 73; 72, 74; 72, 77; 73, identifier:params; 74, keyword_argument; 74, 75; 74, 76; 75, identifier:WorkingDir; 76, identifier:working_dir; 77, keyword_argument; 77, 78; 77, 79; 78, identifier:HALT_EXEC; 79, identifier:HALT_EXEC; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:data; 83, dictionary; 83, 84; 83, 87; 83, 90; 84, pair; 84, 85; 84, 86; 85, string:'--query'; 86, identifier:original_fasta; 87, pair; 87, 88; 87, 89; 88, string:'--db'; 89, identifier:filtered_fasta; 90, pair; 90, 91; 90, 92; 91, string:'--uc'; 92, identifier:output_filepath; 93, if_statement; 93, 94; 93, 96; 94, not_operator; 94, 95; 95, identifier:remove_usearch_logs; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:data; 101, string:'--log'; 102, identifier:log_filepath; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:app_result; 106, call; 106, 107; 106, 108; 107, identifier:app; 108, argument_list; 108, 109; 109, identifier:data; 110, return_statement; 110, 111; 111, expression_list; 111, 112; 111, 113; 112, identifier:app_result; 113, identifier:output_filepath | def assign_reads_to_otus(original_fasta,
filtered_fasta,
output_filepath=None,
log_name="assign_reads_to_otus.log",
perc_id_blast=0.97,
global_alignment=True,
HALT_EXEC=False,
save_intermediate_files=False,
remove_usearch_logs=False,
working_dir=None):
if not output_filepath:
_, output_filepath = mkstemp(prefix='assign_reads_to_otus',
suffix='.uc')
log_filepath = join(working_dir, log_name)
params = {'--id': perc_id_blast,
'--global': global_alignment}
app = Usearch(params, WorkingDir=working_dir, HALT_EXEC=HALT_EXEC)
data = {'--query': original_fasta,
'--db': filtered_fasta,
'--uc': output_filepath
}
if not remove_usearch_logs:
data['--log'] = log_filepath
app_result = app(data)
return app_result, output_filepath |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 32; 2, function_name:sort_by_abundance_usearch61; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 4, identifier:seq_path; 5, default_parameter; 5, 6; 5, 7; 6, identifier:output_dir; 7, string:'.'; 8, default_parameter; 8, 9; 8, 10; 9, identifier:rev; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:minlen; 13, integer:64; 14, default_parameter; 14, 15; 14, 16; 15, identifier:remove_usearch_logs; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:HALT_EXEC; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:output_fna_filepath; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:output_uc_filepath; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:log_name; 28, string:"abundance_sorted.log"; 29, default_parameter; 29, 30; 29, 31; 30, identifier:threads; 31, float:1.0; 32, block; 32, 33; 32, 51; 32, 69; 32, 77; 32, 99; 32, 108; 32, 118; 32, 131; 32, 137; 33, if_statement; 33, 34; 33, 36; 34, not_operator; 34, 35; 35, identifier:output_fna_filepath; 36, block; 36, 37; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, pattern_list; 39, 40; 39, 41; 40, identifier:_; 41, identifier:output_fna_filepath; 42, call; 42, 43; 42, 44; 43, identifier:mkstemp; 44, argument_list; 44, 45; 44, 48; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:prefix; 47, string:'abundance_sorted'; 48, keyword_argument; 48, 49; 48, 50; 49, identifier:suffix; 50, string:'.fna'; 51, if_statement; 51, 52; 51, 54; 52, not_operator; 52, 53; 53, identifier:output_uc_filepath; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 60; 57, pattern_list; 57, 58; 57, 59; 58, identifier:_; 59, identifier:output_uc_filepath; 60, call; 60, 61; 60, 62; 61, identifier:mkstemp; 62, argument_list; 62, 63; 62, 66; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:prefix; 65, string:'abundance_sorted'; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:suffix; 68, string:'.uc'; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:log_filepath; 72, call; 72, 73; 72, 74; 73, identifier:join; 74, argument_list; 74, 75; 74, 76; 75, identifier:output_dir; 76, identifier:log_name; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:params; 80, dictionary; 80, 81; 80, 84; 80, 87; 80, 90; 80, 93; 80, 96; 81, pair; 81, 82; 81, 83; 82, string:'--minseqlength'; 83, identifier:minlen; 84, pair; 84, 85; 84, 86; 85, string:'--sizeout'; 86, True; 87, pair; 87, 88; 87, 89; 88, string:'--derep_fulllength'; 89, identifier:seq_path; 90, pair; 90, 91; 90, 92; 91, string:'--output'; 92, identifier:output_fna_filepath; 93, pair; 93, 94; 93, 95; 94, string:'--uc'; 95, identifier:output_uc_filepath; 96, pair; 96, 97; 96, 98; 97, string:'--threads'; 98, identifier:threads; 99, if_statement; 99, 100; 99, 101; 100, identifier:rev; 101, block; 101, 102; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:params; 106, string:'--strand'; 107, string:'both'; 108, if_statement; 108, 109; 108, 111; 109, not_operator; 109, 110; 110, identifier:remove_usearch_logs; 111, block; 111, 112; 112, expression_statement; 112, 113; 113, assignment; 113, 114; 113, 117; 114, subscript; 114, 115; 114, 116; 115, identifier:params; 116, string:'--log'; 117, identifier:log_filepath; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:app; 121, call; 121, 122; 121, 123; 122, identifier:Usearch61; 123, argument_list; 123, 124; 123, 125; 123, 128; 124, identifier:params; 125, keyword_argument; 125, 126; 125, 127; 126, identifier:WorkingDir; 127, identifier:output_dir; 128, keyword_argument; 128, 129; 128, 130; 129, identifier:HALT_EXEC; 130, identifier:HALT_EXEC; 131, expression_statement; 131, 132; 132, assignment; 132, 133; 132, 134; 133, identifier:app_result; 134, call; 134, 135; 134, 136; 135, identifier:app; 136, argument_list; 137, return_statement; 137, 138; 138, expression_list; 138, 139; 138, 140; 138, 141; 139, identifier:output_fna_filepath; 140, identifier:output_uc_filepath; 141, identifier:app_result | def sort_by_abundance_usearch61(seq_path,
output_dir='.',
rev=False,
minlen=64,
remove_usearch_logs=False,
HALT_EXEC=False,
output_fna_filepath=None,
output_uc_filepath=None,
log_name="abundance_sorted.log",
threads=1.0):
if not output_fna_filepath:
_, output_fna_filepath = mkstemp(prefix='abundance_sorted',
suffix='.fna')
if not output_uc_filepath:
_, output_uc_filepath = mkstemp(prefix='abundance_sorted',
suffix='.uc')
log_filepath = join(output_dir, log_name)
params = {'--minseqlength': minlen,
'--sizeout': True,
'--derep_fulllength': seq_path,
'--output': output_fna_filepath,
'--uc': output_uc_filepath,
'--threads': threads
}
if rev:
params['--strand'] = 'both'
if not remove_usearch_logs:
params['--log'] = log_filepath
app = Usearch61(params, WorkingDir=output_dir, HALT_EXEC=HALT_EXEC)
app_result = app()
return output_fna_filepath, output_uc_filepath, app_result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:sort_by_length_usearch61; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 4, identifier:seq_path; 5, default_parameter; 5, 6; 5, 7; 6, identifier:output_dir; 7, string:"."; 8, default_parameter; 8, 9; 8, 10; 9, identifier:minlen; 10, integer:64; 11, default_parameter; 11, 12; 11, 13; 12, identifier:remove_usearch_logs; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:HALT_EXEC; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:output_fna_filepath; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:log_name; 22, string:"length_sorted.log"; 23, block; 23, 24; 23, 42; 23, 50; 23, 63; 23, 73; 23, 86; 23, 92; 24, if_statement; 24, 25; 24, 27; 25, not_operator; 25, 26; 26, identifier:output_fna_filepath; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 33; 30, pattern_list; 30, 31; 30, 32; 31, identifier:_; 32, identifier:output_fna_filepath; 33, call; 33, 34; 33, 35; 34, identifier:mkstemp; 35, argument_list; 35, 36; 35, 39; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:prefix; 38, string:'length_sorted'; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:suffix; 41, string:'.fna'; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:log_filepath; 45, call; 45, 46; 45, 47; 46, identifier:join; 47, argument_list; 47, 48; 47, 49; 48, identifier:output_dir; 49, identifier:log_name; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:params; 53, dictionary; 53, 54; 53, 57; 53, 60; 54, pair; 54, 55; 54, 56; 55, string:'--minseqlength'; 56, identifier:minlen; 57, pair; 57, 58; 57, 59; 58, string:'--sortbylength'; 59, identifier:seq_path; 60, pair; 60, 61; 60, 62; 61, string:'--output'; 62, identifier:output_fna_filepath; 63, if_statement; 63, 64; 63, 66; 64, not_operator; 64, 65; 65, identifier:remove_usearch_logs; 66, block; 66, 67; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:params; 71, string:'--log'; 72, identifier:log_filepath; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:app; 76, call; 76, 77; 76, 78; 77, identifier:Usearch61; 78, argument_list; 78, 79; 78, 80; 78, 83; 79, identifier:params; 80, keyword_argument; 80, 81; 80, 82; 81, identifier:WorkingDir; 82, identifier:output_dir; 83, keyword_argument; 83, 84; 83, 85; 84, identifier:HALT_EXEC; 85, identifier:HALT_EXEC; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 89; 88, identifier:app_result; 89, call; 89, 90; 89, 91; 90, identifier:app; 91, argument_list; 92, return_statement; 92, 93; 93, expression_list; 93, 94; 93, 95; 94, identifier:output_fna_filepath; 95, identifier:app_result | def sort_by_length_usearch61(seq_path,
output_dir=".",
minlen=64,
remove_usearch_logs=False,
HALT_EXEC=False,
output_fna_filepath=None,
log_name="length_sorted.log"):
if not output_fna_filepath:
_, output_fna_filepath = mkstemp(prefix='length_sorted', suffix='.fna')
log_filepath = join(output_dir, log_name)
params = {'--minseqlength': minlen,
'--sortbylength': seq_path,
'--output': output_fna_filepath
}
if not remove_usearch_logs:
params['--log'] = log_filepath
app = Usearch61(params, WorkingDir=output_dir, HALT_EXEC=HALT_EXEC)
app_result = app()
return output_fna_filepath, app_result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 38; 2, function_name:usearch61_fast_cluster; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 4, identifier:intermediate_fasta; 5, default_parameter; 5, 6; 5, 7; 6, identifier:percent_id; 7, float:0.97; 8, default_parameter; 8, 9; 8, 10; 9, identifier:minlen; 10, integer:64; 11, default_parameter; 11, 12; 11, 13; 12, identifier:output_dir; 13, string:"."; 14, default_parameter; 14, 15; 14, 16; 15, identifier:remove_usearch_logs; 16, False; 17, default_parameter; 17, 18; 17, 19; 18, identifier:wordlength; 19, integer:8; 20, default_parameter; 20, 21; 20, 22; 21, identifier:usearch61_maxrejects; 22, integer:8; 23, default_parameter; 23, 24; 23, 25; 24, identifier:usearch61_maxaccepts; 25, integer:1; 26, default_parameter; 26, 27; 26, 28; 27, identifier:HALT_EXEC; 28, False; 29, default_parameter; 29, 30; 29, 31; 30, identifier:output_uc_filepath; 31, None; 32, default_parameter; 32, 33; 32, 34; 33, identifier:log_name; 34, string:"fast_clustered.log"; 35, default_parameter; 35, 36; 35, 37; 36, identifier:threads; 37, float:1.0; 38, block; 38, 39; 38, 47; 38, 78; 38, 88; 38, 92; 38, 105; 38, 111; 39, expression_statement; 39, 40; 40, assignment; 40, 41; 40, 42; 41, identifier:log_filepath; 42, call; 42, 43; 42, 44; 43, identifier:join; 44, argument_list; 44, 45; 44, 46; 45, identifier:output_dir; 46, identifier:log_name; 47, expression_statement; 47, 48; 48, assignment; 48, 49; 48, 50; 49, identifier:params; 50, dictionary; 50, 51; 50, 54; 50, 57; 50, 60; 50, 63; 50, 66; 50, 69; 50, 72; 50, 75; 51, pair; 51, 52; 51, 53; 52, string:'--minseqlength'; 53, identifier:minlen; 54, pair; 54, 55; 54, 56; 55, string:'--cluster_fast'; 56, identifier:intermediate_fasta; 57, pair; 57, 58; 57, 59; 58, string:'--id'; 59, identifier:percent_id; 60, pair; 60, 61; 60, 62; 61, string:'--uc'; 62, identifier:output_uc_filepath; 63, pair; 63, 64; 63, 65; 64, string:'--wordlength'; 65, identifier:wordlength; 66, pair; 66, 67; 66, 68; 67, string:'--maxrejects'; 68, identifier:usearch61_maxrejects; 69, pair; 69, 70; 69, 71; 70, string:'--maxaccepts'; 71, identifier:usearch61_maxaccepts; 72, pair; 72, 73; 72, 74; 73, string:'--usersort'; 74, True; 75, pair; 75, 76; 75, 77; 76, string:'--threads'; 77, identifier:threads; 78, if_statement; 78, 79; 78, 81; 79, not_operator; 79, 80; 80, identifier:remove_usearch_logs; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:params; 86, string:'--log'; 87, identifier:log_filepath; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:clusters_fp; 91, identifier:output_uc_filepath; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:app; 95, call; 95, 96; 95, 97; 96, identifier:Usearch61; 97, argument_list; 97, 98; 97, 99; 97, 102; 98, identifier:params; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:WorkingDir; 101, identifier:output_dir; 102, keyword_argument; 102, 103; 102, 104; 103, identifier:HALT_EXEC; 104, identifier:HALT_EXEC; 105, expression_statement; 105, 106; 106, assignment; 106, 107; 106, 108; 107, identifier:app_result; 108, call; 108, 109; 108, 110; 109, identifier:app; 110, argument_list; 111, return_statement; 111, 112; 112, expression_list; 112, 113; 112, 114; 113, identifier:clusters_fp; 114, identifier:app_result | def usearch61_fast_cluster(intermediate_fasta,
percent_id=0.97,
minlen=64,
output_dir=".",
remove_usearch_logs=False,
wordlength=8,
usearch61_maxrejects=8,
usearch61_maxaccepts=1,
HALT_EXEC=False,
output_uc_filepath=None,
log_name="fast_clustered.log",
threads=1.0):
log_filepath = join(output_dir, log_name)
params = {'--minseqlength': minlen,
'--cluster_fast': intermediate_fasta,
'--id': percent_id,
'--uc': output_uc_filepath,
'--wordlength': wordlength,
'--maxrejects': usearch61_maxrejects,
'--maxaccepts': usearch61_maxaccepts,
'--usersort': True,
'--threads': threads
}
if not remove_usearch_logs:
params['--log'] = log_filepath
clusters_fp = output_uc_filepath
app = Usearch61(params, WorkingDir=output_dir, HALT_EXEC=HALT_EXEC)
app_result = app()
return clusters_fp, app_result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 47; 2, function_name:usearch61_smallmem_cluster; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 3, 29; 3, 32; 3, 35; 3, 38; 3, 41; 3, 44; 4, identifier:intermediate_fasta; 5, default_parameter; 5, 6; 5, 7; 6, identifier:percent_id; 7, float:0.97; 8, default_parameter; 8, 9; 8, 10; 9, identifier:minlen; 10, integer:64; 11, default_parameter; 11, 12; 11, 13; 12, identifier:rev; 13, False; 14, default_parameter; 14, 15; 14, 16; 15, identifier:output_dir; 16, string:"."; 17, default_parameter; 17, 18; 17, 19; 18, identifier:remove_usearch_logs; 19, False; 20, default_parameter; 20, 21; 20, 22; 21, identifier:wordlength; 22, integer:8; 23, default_parameter; 23, 24; 23, 25; 24, identifier:usearch61_maxrejects; 25, integer:32; 26, default_parameter; 26, 27; 26, 28; 27, identifier:usearch61_maxaccepts; 28, integer:1; 29, default_parameter; 29, 30; 29, 31; 30, identifier:sizeorder; 31, False; 32, default_parameter; 32, 33; 32, 34; 33, identifier:HALT_EXEC; 34, False; 35, default_parameter; 35, 36; 35, 37; 36, identifier:output_uc_filepath; 37, None; 38, default_parameter; 38, 39; 38, 40; 39, identifier:log_name; 40, string:"smallmem_clustered.log"; 41, default_parameter; 41, 42; 41, 43; 42, identifier:sizeout; 43, False; 44, default_parameter; 44, 45; 44, 46; 45, identifier:consout_filepath; 46, None; 47, block; 47, 48; 47, 56; 47, 84; 47, 93; 47, 103; 47, 120; 47, 129; 47, 138; 47, 142; 47, 155; 47, 161; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:log_filepath; 51, call; 51, 52; 51, 53; 52, identifier:join; 53, argument_list; 53, 54; 53, 55; 54, identifier:output_dir; 55, identifier:log_name; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:params; 59, dictionary; 59, 60; 59, 63; 59, 66; 59, 69; 59, 72; 59, 75; 59, 78; 59, 81; 60, pair; 60, 61; 60, 62; 61, string:'--minseqlength'; 62, identifier:minlen; 63, pair; 63, 64; 63, 65; 64, string:'--cluster_smallmem'; 65, identifier:intermediate_fasta; 66, pair; 66, 67; 66, 68; 67, string:'--id'; 68, identifier:percent_id; 69, pair; 69, 70; 69, 71; 70, string:'--uc'; 71, identifier:output_uc_filepath; 72, pair; 72, 73; 72, 74; 73, string:'--wordlength'; 74, identifier:wordlength; 75, pair; 75, 76; 75, 77; 76, string:'--maxrejects'; 77, identifier:usearch61_maxrejects; 78, pair; 78, 79; 78, 80; 79, string:'--maxaccepts'; 80, identifier:usearch61_maxaccepts; 81, pair; 81, 82; 81, 83; 82, string:'--usersort'; 83, True; 84, if_statement; 84, 85; 84, 86; 85, identifier:sizeorder; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, assignment; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:params; 91, string:'--sizeorder'; 92, True; 93, if_statement; 93, 94; 93, 96; 94, not_operator; 94, 95; 95, identifier:remove_usearch_logs; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 102; 99, subscript; 99, 100; 99, 101; 100, identifier:params; 101, string:'--log'; 102, identifier:log_filepath; 103, if_statement; 103, 104; 103, 105; 103, 112; 104, identifier:rev; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:params; 110, string:'--strand'; 111, string:'both'; 112, else_clause; 112, 113; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:params; 118, string:'--strand'; 119, string:'plus'; 120, if_statement; 120, 121; 120, 122; 121, identifier:sizeout; 122, block; 122, 123; 123, expression_statement; 123, 124; 124, assignment; 124, 125; 124, 128; 125, subscript; 125, 126; 125, 127; 126, identifier:params; 127, string:'--sizeout'; 128, True; 129, if_statement; 129, 130; 129, 131; 130, identifier:consout_filepath; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, assignment; 133, 134; 133, 137; 134, subscript; 134, 135; 134, 136; 135, identifier:params; 136, string:'--consout'; 137, identifier:consout_filepath; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:clusters_fp; 141, identifier:output_uc_filepath; 142, expression_statement; 142, 143; 143, assignment; 143, 144; 143, 145; 144, identifier:app; 145, call; 145, 146; 145, 147; 146, identifier:Usearch61; 147, argument_list; 147, 148; 147, 149; 147, 152; 148, identifier:params; 149, keyword_argument; 149, 150; 149, 151; 150, identifier:WorkingDir; 151, identifier:output_dir; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:HALT_EXEC; 154, identifier:HALT_EXEC; 155, expression_statement; 155, 156; 156, assignment; 156, 157; 156, 158; 157, identifier:app_result; 158, call; 158, 159; 158, 160; 159, identifier:app; 160, argument_list; 161, return_statement; 161, 162; 162, expression_list; 162, 163; 162, 164; 163, identifier:clusters_fp; 164, identifier:app_result | def usearch61_smallmem_cluster(intermediate_fasta,
percent_id=0.97,
minlen=64,
rev=False,
output_dir=".",
remove_usearch_logs=False,
wordlength=8,
usearch61_maxrejects=32,
usearch61_maxaccepts=1,
sizeorder=False,
HALT_EXEC=False,
output_uc_filepath=None,
log_name="smallmem_clustered.log",
sizeout=False,
consout_filepath=None):
log_filepath = join(output_dir, log_name)
params = {'--minseqlength': minlen,
'--cluster_smallmem': intermediate_fasta,
'--id': percent_id,
'--uc': output_uc_filepath,
'--wordlength': wordlength,
'--maxrejects': usearch61_maxrejects,
'--maxaccepts': usearch61_maxaccepts,
'--usersort': True
}
if sizeorder:
params['--sizeorder'] = True
if not remove_usearch_logs:
params['--log'] = log_filepath
if rev:
params['--strand'] = 'both'
else:
params['--strand'] = 'plus'
if sizeout:
params['--sizeout'] = True
if consout_filepath:
params['--consout'] = consout_filepath
clusters_fp = output_uc_filepath
app = Usearch61(params, WorkingDir=output_dir, HALT_EXEC=HALT_EXEC)
app_result = app()
return clusters_fp, app_result |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:normalize; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 49; 8, for_statement; 8, 9; 8, 12; 8, 20; 9, pattern_list; 9, 10; 9, 11; 10, identifier:key; 11, identifier:offset; 12, call; 12, 13; 12, 14; 13, identifier:sorted; 14, argument_list; 14, 15; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:kwargs; 18, identifier:items; 19, argument_list; 20, block; 20, 21; 21, if_statement; 21, 22; 21, 25; 22, comparison_operator:in; 22, 23; 22, 24; 23, identifier:key; 24, identifier:self; 25, block; 25, 26; 25, 34; 25, 48; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:delta; 29, binary_operator:-; 29, 30; 29, 31; 30, identifier:offset; 31, subscript; 31, 32; 31, 33; 32, identifier:self; 33, identifier:key; 34, for_statement; 34, 35; 34, 36; 34, 41; 35, identifier:key; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:self; 39, identifier:keys; 40, argument_list; 41, block; 41, 42; 42, expression_statement; 42, 43; 43, augmented_assignment:+=; 43, 44; 43, 47; 44, subscript; 44, 45; 44, 46; 45, identifier:self; 46, identifier:key; 47, identifier:delta; 48, break_statement; 49, return_statement; 49, 50; 50, identifier:self | def normalize(self, **kwargs):
for key, offset in sorted(kwargs.items()):
if key in self:
delta = offset - self[key]
for key in self.keys():
self[key] += delta
break
return self |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 15; 2, function_name:_modifyInternal; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:self; 5, keyword_separator; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:purge; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:done; 14, None; 15, block; 15, 16; 15, 30; 15, 44; 15, 202; 15, 320; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 21; 18, pattern_list; 18, 19; 18, 20; 19, identifier:sortAll; 20, identifier:sortLevels; 21, boolean_operator:or; 21, 22; 21, 27; 22, boolean_operator:and; 22, 23; 22, 26; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:sort; 25, None; 26, identifier:sort; 27, tuple; 27, 28; 27, 29; 28, list:[]; 29, dictionary; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 35; 32, pattern_list; 32, 33; 32, 34; 33, identifier:doneAll; 34, identifier:doneLevels; 35, boolean_operator:or; 35, 36; 35, 41; 36, boolean_operator:and; 36, 37; 36, 40; 37, comparison_operator:is; 37, 38; 37, 39; 38, identifier:done; 39, None; 40, identifier:done; 41, tuple; 41, 42; 41, 43; 42, list:[]; 43, dictionary; 44, function_definition; 44, 45; 44, 46; 44, 49; 45, function_name:_mark; 46, parameters; 46, 47; 46, 48; 47, identifier:v; 48, identifier:i; 49, block; 49, 50; 49, 61; 49, 150; 49, 177; 49, 189; 49, 200; 50, if_statement; 50, 51; 50, 54; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:done; 53, None; 54, block; 54, 55; 55, return_statement; 55, 56; 56, subscript; 56, 57; 56, 58; 57, identifier:v; 58, slice; 58, 59; 58, 60; 59, colon; 60, integer:4; 61, function_definition; 61, 62; 61, 63; 61, 67; 62, function_name:_mark_; 63, parameters; 63, 64; 63, 65; 63, 66; 64, identifier:index; 65, identifier:regexp; 66, identifier:du; 67, block; 67, 68; 67, 79; 67, 123; 68, if_statement; 68, 69; 68, 72; 69, comparison_operator:is; 69, 70; 69, 71; 70, identifier:du; 71, None; 72, block; 72, 73; 73, return_statement; 73, 74; 74, subscript; 74, 75; 74, 76; 75, identifier:v; 76, slice; 76, 77; 76, 78; 77, colon; 78, integer:4; 79, if_statement; 79, 80; 79, 83; 80, comparison_operator:is; 80, 81; 80, 82; 81, identifier:index; 82, None; 83, block; 83, 84; 83, 117; 84, for_statement; 84, 85; 84, 86; 84, 91; 85, identifier:v_; 86, subscript; 86, 87; 86, 88; 87, identifier:v; 88, slice; 88, 89; 88, 90; 89, colon; 90, integer:3; 91, block; 91, 92; 92, if_statement; 92, 93; 92, 107; 93, boolean_operator:or; 93, 94; 93, 97; 94, comparison_operator:is; 94, 95; 94, 96; 95, identifier:regexp; 96, None; 97, call; 97, 98; 97, 101; 98, attribute; 98, 99; 98, 100; 99, identifier:re; 100, identifier:match; 101, argument_list; 101, 102; 101, 103; 102, identifier:regexp; 103, call; 103, 104; 103, 105; 104, identifier:str; 105, argument_list; 105, 106; 106, identifier:v_; 107, block; 107, 108; 108, return_statement; 108, 109; 109, binary_operator:+; 109, 110; 109, 115; 110, subscript; 110, 111; 110, 112; 111, identifier:v; 112, slice; 112, 113; 112, 114; 113, colon; 114, integer:3; 115, list:[du]; 115, 116; 116, identifier:du; 117, return_statement; 117, 118; 118, subscript; 118, 119; 118, 120; 119, identifier:v; 120, slice; 120, 121; 120, 122; 121, colon; 122, integer:4; 123, if_statement; 123, 124; 123, 140; 124, boolean_operator:or; 124, 125; 124, 128; 125, comparison_operator:is; 125, 126; 125, 127; 126, identifier:regexp; 127, None; 128, call; 128, 129; 128, 132; 129, attribute; 129, 130; 129, 131; 130, identifier:re; 131, identifier:match; 132, argument_list; 132, 133; 132, 134; 133, identifier:regexp; 134, call; 134, 135; 134, 136; 135, identifier:str; 136, argument_list; 136, 137; 137, subscript; 137, 138; 137, 139; 138, identifier:v; 139, identifier:index; 140, block; 140, 141; 141, return_statement; 141, 142; 142, binary_operator:+; 142, 143; 142, 148; 143, subscript; 143, 144; 143, 145; 144, identifier:v; 145, slice; 145, 146; 145, 147; 146, colon; 147, integer:3; 148, list:[du]; 148, 149; 149, identifier:du; 150, try_statement; 150, 151; 150, 173; 151, block; 151, 152; 151, 166; 152, for_statement; 152, 153; 152, 154; 152, 157; 153, identifier:doneLevel; 154, subscript; 154, 155; 154, 156; 155, identifier:doneLevels; 156, identifier:i; 157, block; 157, 158; 158, expression_statement; 158, 159; 159, assignment; 159, 160; 159, 161; 160, identifier:result; 161, call; 161, 162; 161, 163; 162, identifier:_mark_; 163, argument_list; 163, 164; 164, list_splat; 164, 165; 165, identifier:doneLevel; 166, if_statement; 166, 167; 166, 170; 167, comparison_operator:is; 167, 168; 167, 169; 168, identifier:result; 169, None; 170, block; 170, 171; 171, return_statement; 171, 172; 172, identifier:result; 173, except_clause; 173, 174; 173, 175; 174, identifier:KeyError; 175, block; 175, 176; 176, pass_statement; 177, for_statement; 177, 178; 177, 179; 177, 180; 178, identifier:doneAll_; 179, identifier:doneAll; 180, block; 180, 181; 181, expression_statement; 181, 182; 182, assignment; 182, 183; 182, 184; 183, identifier:result; 184, call; 184, 185; 184, 186; 185, identifier:_mark_; 186, argument_list; 186, 187; 187, list_splat; 187, 188; 188, identifier:doneAll_; 189, if_statement; 189, 190; 189, 193; 190, comparison_operator:is; 190, 191; 190, 192; 191, identifier:result; 192, None; 193, block; 193, 194; 194, return_statement; 194, 195; 195, subscript; 195, 196; 195, 197; 196, identifier:v; 197, slice; 197, 198; 197, 199; 198, colon; 199, integer:4; 200, return_statement; 200, 201; 201, identifier:result; 202, function_definition; 202, 203; 202, 204; 202, 207; 203, function_name:_modify; 204, parameters; 204, 205; 204, 206; 205, identifier:submodel; 206, identifier:i; 207, block; 207, 208; 207, 214; 207, 273; 207, 292; 207, 318; 208, expression_statement; 208, 209; 209, assignment; 209, 210; 209, 211; 210, identifier:_new; 211, call; 211, 212; 211, 213; 212, identifier:list; 213, argument_list; 214, for_statement; 214, 215; 214, 216; 214, 217; 215, identifier:v; 216, identifier:submodel; 217, block; 217, 218; 218, if_statement; 218, 219; 218, 220; 218, 249; 219, identifier:purge; 220, block; 220, 221; 221, if_statement; 221, 222; 221, 226; 222, not_operator; 222, 223; 223, subscript; 223, 224; 223, 225; 224, identifier:v; 225, integer:3; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, call; 228, 229; 228, 232; 229, attribute; 229, 230; 229, 231; 230, identifier:_new; 231, identifier:append; 232, argument_list; 232, 233; 233, binary_operator:+; 233, 234; 233, 239; 234, call; 234, 235; 234, 236; 235, identifier:_mark; 236, argument_list; 236, 237; 236, 238; 237, identifier:v; 238, identifier:i; 239, list:[_modify(v[4], i + 1)]; 239, 240; 240, call; 240, 241; 240, 242; 241, identifier:_modify; 242, argument_list; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:v; 245, integer:4; 246, binary_operator:+; 246, 247; 246, 248; 247, identifier:i; 248, integer:1; 249, else_clause; 249, 250; 250, block; 250, 251; 251, expression_statement; 251, 252; 252, call; 252, 253; 252, 256; 253, attribute; 253, 254; 253, 255; 254, identifier:_new; 255, identifier:append; 256, argument_list; 256, 257; 257, binary_operator:+; 257, 258; 257, 263; 258, call; 258, 259; 258, 260; 259, identifier:_mark; 260, argument_list; 260, 261; 260, 262; 261, identifier:v; 262, identifier:i; 263, list:[_modify(v[4], i + 1)]; 263, 264; 264, call; 264, 265; 264, 266; 265, identifier:_modify; 266, argument_list; 266, 267; 266, 270; 267, subscript; 267, 268; 267, 269; 268, identifier:v; 269, integer:4; 270, binary_operator:+; 270, 271; 270, 272; 271, identifier:i; 272, integer:1; 273, expression_statement; 273, 274; 274, assignment; 274, 275; 274, 276; 275, identifier:levels; 276, boolean_operator:or; 276, 277; 276, 283; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, identifier:sortLevels; 280, identifier:get; 281, argument_list; 281, 282; 282, identifier:i; 283, call; 283, 284; 283, 287; 284, attribute; 284, 285; 284, 286; 285, identifier:sortLevels; 286, identifier:get; 287, argument_list; 287, 288; 288, call; 288, 289; 288, 290; 289, identifier:str; 290, argument_list; 290, 291; 291, identifier:i; 292, for_statement; 292, 293; 292, 296; 292, 299; 293, pattern_list; 293, 294; 293, 295; 294, identifier:index; 295, identifier:reverse; 296, boolean_operator:or; 296, 297; 296, 298; 297, identifier:levels; 298, identifier:sortAll; 299, block; 299, 300; 300, expression_statement; 300, 301; 301, assignment; 301, 302; 301, 303; 302, identifier:_new; 303, call; 303, 304; 303, 305; 304, identifier:sorted; 305, argument_list; 305, 306; 305, 307; 305, 315; 306, identifier:_new; 307, keyword_argument; 307, 308; 307, 309; 308, identifier:key; 309, lambda; 309, 310; 309, 312; 310, lambda_parameters; 310, 311; 311, identifier:e; 312, subscript; 312, 313; 312, 314; 313, identifier:e; 314, identifier:index; 315, keyword_argument; 315, 316; 315, 317; 316, identifier:reverse; 317, identifier:reverse; 318, return_statement; 318, 319; 319, identifier:_new; 320, return_statement; 320, 321; 321, call; 321, 322; 321, 323; 322, identifier:_modify; 323, argument_list; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:self; 326, identifier:data; 327, integer:1 | def _modifyInternal(self, *, sort=None, purge=False, done=None):
sortAll, sortLevels = sort is not None and sort or ([], {})
doneAll, doneLevels = done is not None and done or ([], {})
def _mark(v, i):
if done is None:
return v[:4]
def _mark_(index, regexp, du):
if du is None:
return v[:4]
if index is None:
for v_ in v[:3]:
if regexp is None or re.match(regexp, str(v_)):
return v[:3] + [du]
return v[:4]
if regexp is None or re.match(regexp, str(v[index])):
return v[:3] + [du]
try:
for doneLevel in doneLevels[i]:
result = _mark_(*doneLevel)
if result is not None:
return result
except KeyError:
pass
for doneAll_ in doneAll:
result = _mark_(*doneAll_)
if result is None:
return v[:4]
return result
def _modify(submodel, i):
_new = list()
for v in submodel:
if purge:
if not v[3]:
_new.append(_mark(v, i) + [_modify(v[4], i + 1)])
else:
_new.append(_mark(v, i) + [_modify(v[4], i + 1)])
levels = sortLevels.get(i) or sortLevels.get(str(i))
for index, reverse in levels or sortAll:
_new = sorted(_new, key=lambda e: e[index], reverse=reverse)
return _new
return _modify(self.data, 1) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_getPattern; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:ipattern; 6, default_parameter; 6, 7; 6, 8; 7, identifier:done; 8, None; 9, block; 9, 10; 9, 17; 9, 42; 9, 51; 9, 72; 9, 127; 9, 133; 9, 139; 9, 365; 10, if_statement; 10, 11; 10, 14; 11, comparison_operator:is; 11, 12; 11, 13; 12, identifier:ipattern; 13, None; 14, block; 14, 15; 15, return_statement; 15, 16; 16, None; 17, if_statement; 17, 18; 17, 21; 18, comparison_operator:is; 18, 19; 18, 20; 19, identifier:ipattern; 20, True; 21, block; 21, 22; 21, 35; 22, if_statement; 22, 23; 22, 26; 23, comparison_operator:is; 23, 24; 23, 25; 24, identifier:done; 25, None; 26, block; 26, 27; 27, return_statement; 27, 28; 28, tuple; 28, 29; 28, 34; 29, list:[(None, None, done)]; 29, 30; 30, tuple; 30, 31; 30, 32; 30, 33; 31, None; 32, None; 33, identifier:done; 34, dictionary; 35, return_statement; 35, 36; 36, tuple; 36, 37; 36, 41; 37, list:[(0, False)]; 37, 38; 38, tuple; 38, 39; 38, 40; 39, integer:0; 40, False; 41, dictionary; 42, function_definition; 42, 43; 42, 44; 42, 46; 43, function_name:_getReverse; 44, parameters; 44, 45; 45, identifier:pm; 46, block; 46, 47; 47, return_statement; 47, 48; 48, comparison_operator:==; 48, 49; 48, 50; 49, identifier:pm; 50, string:'-'; 51, function_definition; 51, 52; 51, 53; 51, 55; 52, function_name:_getIndex; 53, parameters; 53, 54; 54, identifier:k; 55, block; 55, 56; 56, try_statement; 56, 57; 56, 63; 57, block; 57, 58; 58, return_statement; 58, 59; 59, call; 59, 60; 59, 61; 60, identifier:int; 61, argument_list; 61, 62; 62, identifier:k; 63, except_clause; 63, 64; 63, 65; 64, identifier:ValueError; 65, block; 65, 66; 66, raise_statement; 66, 67; 67, call; 67, 68; 67, 69; 68, identifier:InvalidPatternError; 69, argument_list; 69, 70; 69, 71; 70, identifier:k; 71, string:"Invalid level number"; 72, function_definition; 72, 73; 72, 74; 72, 76; 73, function_name:_getDone; 74, parameters; 74, 75; 75, identifier:p; 76, block; 76, 77; 76, 86; 76, 120; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:v; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:p; 83, identifier:split; 84, argument_list; 84, 85; 85, string:'='; 86, if_statement; 86, 87; 86, 93; 87, comparison_operator:==; 87, 88; 87, 92; 88, call; 88, 89; 88, 90; 89, identifier:len; 90, argument_list; 90, 91; 91, identifier:v; 92, integer:2; 93, block; 93, 94; 94, try_statement; 94, 95; 94, 109; 95, block; 95, 96; 96, return_statement; 96, 97; 97, tuple; 97, 98; 97, 105; 97, 108; 98, subscript; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:Model; 101, identifier:indexes; 102, subscript; 102, 103; 102, 104; 103, identifier:v; 104, integer:0; 105, subscript; 105, 106; 105, 107; 106, identifier:v; 107, integer:1; 108, identifier:done; 109, except_clause; 109, 110; 109, 111; 110, identifier:KeyError; 111, block; 111, 112; 112, raise_statement; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:InvalidPatternError; 115, argument_list; 115, 116; 115, 119; 116, subscript; 116, 117; 116, 118; 117, identifier:v; 118, integer:0; 119, string:'Invalid field name'; 120, return_statement; 120, 121; 121, tuple; 121, 122; 121, 123; 121, 126; 122, None; 123, subscript; 123, 124; 123, 125; 124, identifier:v; 125, integer:0; 126, identifier:done; 127, expression_statement; 127, 128; 128, assignment; 128, 129; 128, 130; 129, identifier:ipattern1; 130, call; 130, 131; 130, 132; 131, identifier:list; 132, argument_list; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 136; 135, identifier:ipattern2; 136, call; 136, 137; 136, 138; 137, identifier:dict; 138, argument_list; 139, for_statement; 139, 140; 139, 141; 139, 147; 140, identifier:s; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:ipattern; 144, identifier:split; 145, argument_list; 145, 146; 146, string:','; 147, block; 147, 148; 147, 169; 147, 178; 147, 352; 148, if_statement; 148, 149; 148, 152; 148, 157; 149, comparison_operator:is; 149, 150; 149, 151; 150, identifier:done; 151, None; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, assignment; 154, 155; 154, 156; 155, identifier:v; 156, identifier:done; 157, else_clause; 157, 158; 158, block; 158, 159; 159, expression_statement; 159, 160; 160, assignment; 160, 161; 160, 162; 161, identifier:v; 162, call; 162, 163; 162, 164; 163, identifier:_getReverse; 164, argument_list; 164, 165; 165, subscript; 165, 166; 165, 167; 166, identifier:s; 167, unary_operator:-; 167, 168; 168, integer:1; 169, expression_statement; 169, 170; 170, assignment; 170, 171; 170, 172; 171, identifier:k; 172, call; 172, 173; 172, 176; 173, attribute; 173, 174; 173, 175; 174, identifier:s; 175, identifier:split; 176, argument_list; 176, 177; 177, string:':'; 178, if_statement; 178, 179; 178, 185; 178, 276; 178, 344; 179, comparison_operator:==; 179, 180; 179, 184; 180, call; 180, 181; 180, 182; 181, identifier:len; 182, argument_list; 182, 183; 183, identifier:k; 184, integer:1; 185, block; 185, 186; 185, 204; 185, 215; 185, 270; 186, if_statement; 186, 187; 186, 190; 187, comparison_operator:is; 187, 188; 187, 189; 188, identifier:done; 189, None; 190, block; 190, 191; 190, 203; 191, expression_statement; 191, 192; 192, call; 192, 193; 192, 196; 193, attribute; 193, 194; 193, 195; 194, identifier:ipattern1; 195, identifier:append; 196, argument_list; 196, 197; 197, call; 197, 198; 197, 199; 198, identifier:_getDone; 199, argument_list; 199, 200; 200, subscript; 200, 201; 200, 202; 201, identifier:k; 202, integer:0; 203, continue_statement; 204, expression_statement; 204, 205; 205, assignment; 205, 206; 205, 207; 206, identifier:ko; 207, subscript; 207, 208; 207, 211; 208, subscript; 208, 209; 208, 210; 209, identifier:k; 210, integer:0; 211, slice; 211, 212; 211, 213; 212, colon; 213, unary_operator:-; 213, 214; 214, integer:1; 215, try_statement; 215, 216; 215, 241; 215, 258; 216, block; 216, 217; 217, if_statement; 217, 218; 217, 226; 217, 231; 218, comparison_operator:==; 218, 219; 218, 225; 219, call; 219, 220; 219, 221; 220, identifier:len; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 224; 223, identifier:k; 224, integer:0; 225, integer:1; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, assignment; 228, 229; 228, 230; 229, identifier:k; 230, integer:0; 231, else_clause; 231, 232; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:k; 236, subscript; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:Model; 239, identifier:indexes; 240, identifier:ko; 241, except_clause; 241, 242; 241, 243; 242, identifier:KeyError; 243, block; 243, 244; 244, expression_statement; 244, 245; 245, assignment; 245, 246; 245, 247; 246, identifier:k; 247, call; 247, 248; 247, 249; 248, identifier:_getIndex; 249, argument_list; 249, 250; 250, subscript; 250, 251; 250, 254; 251, subscript; 251, 252; 251, 253; 252, identifier:k; 253, integer:0; 254, slice; 254, 255; 254, 256; 255, colon; 256, unary_operator:-; 256, 257; 257, integer:1; 258, else_clause; 258, 259; 259, block; 259, 260; 259, 269; 260, expression_statement; 260, 261; 261, call; 261, 262; 261, 265; 262, attribute; 262, 263; 262, 264; 263, identifier:ipattern1; 264, identifier:append; 265, argument_list; 265, 266; 266, tuple; 266, 267; 266, 268; 267, identifier:k; 268, identifier:v; 269, continue_statement; 270, expression_statement; 270, 271; 271, assignment; 271, 272; 271, 273; 272, identifier:v; 273, tuple; 273, 274; 273, 275; 274, integer:0; 275, identifier:v; 276, elif_clause; 276, 277; 276, 283; 277, comparison_operator:==; 277, 278; 277, 282; 278, call; 278, 279; 278, 280; 279, identifier:len; 280, argument_list; 280, 281; 281, identifier:k; 282, integer:2; 283, block; 283, 284; 284, try_statement; 284, 285; 284, 328; 285, block; 285, 286; 285, 319; 286, if_statement; 286, 287; 286, 290; 286, 300; 287, comparison_operator:is; 287, 288; 287, 289; 288, identifier:done; 289, None; 290, block; 290, 291; 291, expression_statement; 291, 292; 292, assignment; 292, 293; 292, 294; 293, identifier:v; 294, call; 294, 295; 294, 296; 295, identifier:_getDone; 296, argument_list; 296, 297; 297, subscript; 297, 298; 297, 299; 298, identifier:k; 299, integer:1; 300, else_clause; 300, 301; 301, block; 301, 302; 302, expression_statement; 302, 303; 303, assignment; 303, 304; 303, 305; 304, identifier:v; 305, tuple; 305, 306; 305, 318; 306, subscript; 306, 307; 306, 310; 307, attribute; 307, 308; 307, 309; 308, identifier:Model; 309, identifier:indexes; 310, subscript; 310, 311; 310, 314; 311, subscript; 311, 312; 311, 313; 312, identifier:k; 313, integer:1; 314, slice; 314, 315; 314, 316; 315, colon; 316, unary_operator:-; 316, 317; 317, integer:1; 318, identifier:v; 319, expression_statement; 319, 320; 320, assignment; 320, 321; 320, 322; 321, identifier:k; 322, call; 322, 323; 322, 324; 323, identifier:_getIndex; 324, argument_list; 324, 325; 325, subscript; 325, 326; 325, 327; 326, identifier:k; 327, integer:0; 328, except_clause; 328, 329; 328, 330; 329, identifier:KeyError; 330, block; 330, 331; 331, raise_statement; 331, 332; 332, call; 332, 333; 332, 334; 333, identifier:InvalidPatternError; 334, argument_list; 334, 335; 334, 343; 335, subscript; 335, 336; 335, 339; 336, subscript; 336, 337; 336, 338; 337, identifier:k; 338, integer:1; 339, slice; 339, 340; 339, 341; 340, colon; 341, unary_operator:-; 341, 342; 342, integer:1; 343, string:'Invalid field name'; 344, else_clause; 344, 345; 345, block; 345, 346; 346, raise_statement; 346, 347; 347, call; 347, 348; 347, 349; 348, identifier:InvalidPatternError; 349, argument_list; 349, 350; 349, 351; 350, identifier:s; 351, string:'Unrecognized token in'; 352, expression_statement; 352, 353; 353, call; 353, 354; 353, 363; 354, attribute; 354, 355; 354, 362; 355, call; 355, 356; 355, 359; 356, attribute; 356, 357; 356, 358; 357, identifier:ipattern2; 358, identifier:setdefault; 359, argument_list; 359, 360; 359, 361; 360, identifier:k; 361, list:[]; 362, identifier:append; 363, argument_list; 363, 364; 364, identifier:v; 365, return_statement; 365, 366; 366, tuple; 366, 367; 366, 368; 367, identifier:ipattern1; 368, identifier:ipattern2 | def _getPattern(self, ipattern, done=None):
if ipattern is None:
return None
if ipattern is True:
if done is not None:
return ([(None, None, done)], {})
return ([(0, False)], {})
def _getReverse(pm):
return pm == '-'
def _getIndex(k):
try:
return int(k)
except ValueError:
raise InvalidPatternError(k, "Invalid level number")
def _getDone(p):
v = p.split('=')
if len(v) == 2:
try:
return (Model.indexes[v[0]], v[1], done)
except KeyError:
raise InvalidPatternError(v[0], 'Invalid field name')
return (None, v[0], done)
ipattern1 = list()
ipattern2 = dict()
for s in ipattern.split(','):
if done is not None:
v = done
else:
v = _getReverse(s[-1])
k = s.split(':')
if len(k) == 1:
if done is not None:
ipattern1.append(_getDone(k[0]))
continue
ko = k[0][:-1]
try:
if len(k[0]) == 1:
k = 0
else:
k = Model.indexes[ko]
except KeyError:
k = _getIndex(k[0][:-1])
else:
ipattern1.append((k, v))
continue
v = (0, v)
elif len(k) == 2:
try:
if done is not None:
v = _getDone(k[1])
else:
v = (Model.indexes[k[1][:-1]], v)
k = _getIndex(k[0])
except KeyError:
raise InvalidPatternError(k[1][:-1], 'Invalid field name')
else:
raise InvalidPatternError(s, 'Unrecognized token in')
ipattern2.setdefault(k, []).append(v)
return (ipattern1, ipattern2) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 19; 2, function_name:view; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:purge; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:done; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:undone; 16, None; 17, dictionary_splat_pattern; 17, 18; 18, identifier:kwargs; 19, block; 19, 20; 20, expression_statement; 20, 21; 21, call; 21, 22; 21, 23; 22, identifier:View; 23, argument_list; 23, 24; 23, 51; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:model; 29, identifier:modify; 30, argument_list; 30, 31; 30, 39; 30, 42; 31, keyword_argument; 31, 32; 31, 33; 32, identifier:sort; 33, call; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:self; 36, identifier:_getPattern; 37, argument_list; 37, 38; 38, identifier:sort; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:purge; 41, identifier:purge; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:done; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:self; 47, identifier:_getDone; 48, argument_list; 48, 49; 48, 50; 49, identifier:done; 50, identifier:undone; 51, dictionary_splat; 51, 52; 52, identifier:kwargs | def view(self, sort=None, purge=False, done=None, undone=None, **kwargs):
View(self.model.modify(
sort=self._getPattern(sort),
purge=purge,
done=self._getDone(done, undone)
), **kwargs) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 17; 2, function_name:modify; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:purge; 10, False; 11, default_parameter; 11, 12; 11, 13; 12, identifier:done; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:undone; 16, None; 17, block; 17, 18; 18, expression_statement; 18, 19; 19, call; 19, 20; 19, 25; 20, attribute; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:model; 24, identifier:modifyInPlace; 25, argument_list; 25, 26; 25, 34; 25, 37; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:sort; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_getPattern; 32, argument_list; 32, 33; 33, identifier:sort; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:purge; 36, identifier:purge; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:done; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:_getDone; 43, argument_list; 43, 44; 43, 45; 44, identifier:done; 45, identifier:undone | def modify(self, sort=None, purge=False, done=None, undone=None):
self.model.modifyInPlace(
sort=self._getPattern(sort),
purge=purge,
done=self._getDone(done, undone)
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:inorder; 3, parameters; 3, 4; 3, 6; 4, list_splat_pattern; 4, 5; 5, identifier:iterables; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 19; 8, 32; 8, 48; 8, 52; 8, 89; 8, 94; 8, 107; 8, 113; 8, 175; 8, 185; 8, 188; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:reverse; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:kwargs; 15, identifier:pop; 16, argument_list; 16, 17; 16, 18; 17, string:"reverse"; 18, False; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:keyfunc; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:kwargs; 25, identifier:pop; 26, argument_list; 26, 27; 26, 28; 27, string:"key"; 28, lambda; 28, 29; 28, 31; 29, lambda_parameters; 29, 30; 30, identifier:x; 31, identifier:x; 32, if_statement; 32, 33; 32, 34; 33, identifier:kwargs; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:TypeError; 38, argument_list; 38, 39; 39, binary_operator:%; 39, 40; 39, 41; 40, string:"invalid keyword argument '%s'"; 41, subscript; 41, 42; 41, 47; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:kwargs; 45, identifier:keys; 46, argument_list; 47, integer:0; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:nextvals; 51, dictionary; 52, for_statement; 52, 53; 52, 54; 52, 55; 53, identifier:iterable; 54, identifier:iterables; 55, block; 55, 56; 55, 65; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:next; 59, attribute; 59, 60; 59, 64; 60, call; 60, 61; 60, 62; 61, identifier:iter; 62, argument_list; 62, 63; 63, identifier:iterable; 64, identifier:next; 65, try_statement; 65, 66; 65, 85; 66, block; 66, 67; 66, 73; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 69, identifier:nextval; 70, call; 70, 71; 70, 72; 71, identifier:next; 72, argument_list; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:nextvals; 77, identifier:next; 78, expression_list; 78, 79; 78, 83; 78, 84; 79, call; 79, 80; 79, 81; 80, identifier:keyfunc; 81, argument_list; 81, 82; 82, identifier:nextval; 83, identifier:nextval; 84, identifier:next; 85, except_clause; 85, 86; 85, 87; 86, identifier:StopIteration; 87, block; 87, 88; 88, pass_statement; 89, if_statement; 89, 90; 89, 92; 90, not_operator; 90, 91; 91, identifier:nextvals; 92, block; 92, 93; 93, return_statement; 94, if_statement; 94, 95; 94, 96; 94, 101; 95, identifier:reverse; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:select; 100, identifier:max; 101, else_clause; 101, 102; 102, block; 102, 103; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:select; 106, identifier:min; 107, expression_statement; 107, 108; 108, assignment; 108, 109; 108, 110; 109, identifier:values; 110, attribute; 110, 111; 110, 112; 111, identifier:nextvals; 112, identifier:itervalues; 113, if_statement; 113, 114; 113, 120; 114, comparison_operator:>; 114, 115; 114, 119; 115, call; 115, 116; 115, 117; 116, identifier:len; 117, argument_list; 117, 118; 118, identifier:nextvals; 119, integer:1; 120, block; 120, 121; 121, while_statement; 121, 122; 121, 123; 122, integer:1; 123, block; 123, 124; 123, 136; 123, 139; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 130; 126, pattern_list; 126, 127; 126, 128; 126, 129; 127, identifier:_; 128, identifier:val; 129, identifier:next; 130, call; 130, 131; 130, 132; 131, identifier:select; 132, argument_list; 132, 133; 133, call; 133, 134; 133, 135; 134, identifier:values; 135, argument_list; 136, expression_statement; 136, 137; 137, yield; 137, 138; 138, identifier:val; 139, try_statement; 139, 140; 139, 159; 140, block; 140, 141; 140, 147; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 144; 143, identifier:nextval; 144, call; 144, 145; 144, 146; 145, identifier:next; 146, argument_list; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 152; 149, subscript; 149, 150; 149, 151; 150, identifier:nextvals; 151, identifier:next; 152, expression_list; 152, 153; 152, 157; 152, 158; 153, call; 153, 154; 153, 155; 154, identifier:keyfunc; 155, argument_list; 155, 156; 156, identifier:nextval; 157, identifier:nextval; 158, identifier:next; 159, except_clause; 159, 160; 159, 161; 160, identifier:StopIteration; 161, block; 161, 162; 161, 166; 162, delete_statement; 162, 163; 163, subscript; 163, 164; 163, 165; 164, identifier:nextvals; 165, identifier:next; 166, if_statement; 166, 167; 166, 173; 167, comparison_operator:<; 167, 168; 167, 172; 168, call; 168, 169; 168, 170; 169, identifier:len; 170, argument_list; 170, 171; 171, identifier:nextvals; 172, integer:2; 173, block; 173, 174; 174, break_statement; 175, expression_statement; 175, 176; 176, assignment; 176, 177; 176, 182; 177, pattern_list; 177, 178; 178, tuple_pattern; 178, 179; 178, 180; 178, 181; 179, identifier:_; 180, identifier:val; 181, identifier:next; 182, call; 182, 183; 182, 184; 183, identifier:values; 184, argument_list; 185, expression_statement; 185, 186; 186, yield; 186, 187; 187, identifier:val; 188, while_statement; 188, 189; 188, 190; 189, integer:1; 190, block; 190, 191; 191, expression_statement; 191, 192; 192, yield; 192, 193; 193, call; 193, 194; 193, 195; 194, identifier:next; 195, argument_list | def inorder(*iterables, **kwargs):
reverse = kwargs.pop("reverse", False)
keyfunc = kwargs.pop("key", lambda x: x)
if kwargs:
raise TypeError("invalid keyword argument '%s'" % kwargs.keys()[0])
nextvals = {}
for iterable in iterables:
next = iter(iterable).next
try:
nextval = next()
nextvals[next] = keyfunc(nextval), nextval, next
except StopIteration:
pass
if not nextvals:
return
if reverse:
select = max
else:
select = min
values = nextvals.itervalues
if len(nextvals) > 1:
while 1:
_, val, next = select(values())
yield val
try:
nextval = next()
nextvals[next] = keyfunc(nextval), nextval, next
except StopIteration:
del nextvals[next]
if len(nextvals) < 2:
break
(_, val, next), = values()
yield val
while 1:
yield next() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:add_tag; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:tag; 6, identifier:value; 7, block; 7, 8; 7, 20; 7, 24; 7, 46; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:index; 11, call; 11, 12; 11, 13; 12, identifier:bisect_left; 13, argument_list; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:self; 16, identifier:tags; 17, tuple; 17, 18; 17, 19; 18, identifier:tag; 19, identifier:value; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:contains; 23, False; 24, if_statement; 24, 25; 24, 33; 25, comparison_operator:<; 25, 26; 25, 27; 26, identifier:index; 27, call; 27, 28; 27, 29; 28, identifier:len; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:tags; 33, block; 33, 34; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:contains; 37, comparison_operator:==; 37, 38; 37, 43; 38, subscript; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:tags; 42, identifier:index; 43, tuple; 43, 44; 43, 45; 44, identifier:tag; 45, identifier:value; 46, if_statement; 46, 47; 46, 49; 47, not_operator; 47, 48; 48, identifier:contains; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 57; 52, attribute; 52, 53; 52, 56; 53, attribute; 53, 54; 53, 55; 54, identifier:self; 55, identifier:tags; 56, identifier:insert; 57, argument_list; 57, 58; 57, 59; 58, identifier:index; 59, tuple; 59, 60; 59, 61; 60, identifier:tag; 61, identifier:value | def add_tag(self, tag, value):
index = bisect_left(self.tags, (tag, value))
contains = False
if index < len(self.tags):
contains = self.tags[index] == (tag, value)
if not contains:
self.tags.insert(index, (tag, value)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:by; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:external; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:offset; 14, integer:0; 15, default_parameter; 15, 16; 15, 17; 16, identifier:limit; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:order; 20, None; 21, default_parameter; 21, 22; 21, 23; 22, identifier:alpha; 23, False; 24, default_parameter; 24, 25; 24, 26; 25, identifier:store_as; 26, None; 27, block; 27, 28; 27, 49; 27, 55; 27, 64; 27, 92; 27, 118; 27, 128; 27, 140; 27, 149; 28, if_statement; 28, 29; 28, 38; 29, boolean_operator:and; 29, 30; 29, 31; 30, identifier:order; 31, comparison_operator:not; 31, 32; 31, 33; 32, identifier:order; 33, list:[b'ASC', b'DESC', 'ASC', 'DESC']; 33, 34; 33, 35; 33, 36; 33, 37; 34, string:b'ASC'; 35, string:b'DESC'; 36, string:'ASC'; 37, string:'DESC'; 38, block; 38, 39; 39, raise_statement; 39, 40; 40, call; 40, 41; 40, 42; 41, identifier:ValueError; 42, argument_list; 42, 43; 43, call; 43, 44; 43, 47; 44, attribute; 44, 45; 44, 46; 45, string:'invalid sort order "{}"'; 46, identifier:format; 47, argument_list; 47, 48; 48, identifier:order; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:command; 52, list:[b'SORT', key]; 52, 53; 52, 54; 53, string:b'SORT'; 54, identifier:key; 55, if_statement; 55, 56; 55, 57; 56, identifier:by; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, augmented_assignment:+=; 59, 60; 59, 61; 60, identifier:command; 61, list:[b'BY', by]; 61, 62; 61, 63; 62, string:b'BY'; 63, identifier:by; 64, if_statement; 64, 65; 64, 72; 64, 83; 65, boolean_operator:and; 65, 66; 65, 67; 66, identifier:external; 67, call; 67, 68; 67, 69; 68, identifier:isinstance; 69, argument_list; 69, 70; 69, 71; 70, identifier:external; 71, identifier:list; 72, block; 72, 73; 73, for_statement; 73, 74; 73, 75; 73, 76; 74, identifier:entry; 75, identifier:external; 76, block; 76, 77; 77, expression_statement; 77, 78; 78, augmented_assignment:+=; 78, 79; 78, 80; 79, identifier:command; 80, list:[b'GET', entry]; 80, 81; 80, 82; 81, string:b'GET'; 82, identifier:entry; 83, elif_clause; 83, 84; 83, 85; 84, identifier:external; 85, block; 85, 86; 86, expression_statement; 86, 87; 87, augmented_assignment:+=; 87, 88; 87, 89; 88, identifier:command; 89, list:[b'GET', external]; 89, 90; 89, 91; 90, string:b'GET'; 91, identifier:external; 92, if_statement; 92, 93; 92, 94; 93, identifier:limit; 94, block; 94, 95; 95, expression_statement; 95, 96; 96, augmented_assignment:+=; 96, 97; 96, 98; 97, identifier:command; 98, list:[
b'LIMIT',
ascii(offset).encode('utf-8'),
ascii(limit).encode('utf-8')
]; 98, 99; 98, 100; 98, 109; 99, string:b'LIMIT'; 100, call; 100, 101; 100, 107; 101, attribute; 101, 102; 101, 106; 102, call; 102, 103; 102, 104; 103, identifier:ascii; 104, argument_list; 104, 105; 105, identifier:offset; 106, identifier:encode; 107, argument_list; 107, 108; 108, string:'utf-8'; 109, call; 109, 110; 109, 116; 110, attribute; 110, 111; 110, 115; 111, call; 111, 112; 111, 113; 112, identifier:ascii; 113, argument_list; 113, 114; 114, identifier:limit; 115, identifier:encode; 116, argument_list; 116, 117; 117, string:'utf-8'; 118, if_statement; 118, 119; 118, 120; 119, identifier:order; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:command; 125, identifier:append; 126, argument_list; 126, 127; 127, identifier:order; 128, if_statement; 128, 129; 128, 132; 129, comparison_operator:is; 129, 130; 129, 131; 130, identifier:alpha; 131, True; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, call; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:command; 137, identifier:append; 138, argument_list; 138, 139; 139, string:b'ALPHA'; 140, if_statement; 140, 141; 140, 142; 141, identifier:store_as; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, augmented_assignment:+=; 144, 145; 144, 146; 145, identifier:command; 146, list:[b'STORE', store_as]; 146, 147; 146, 148; 147, string:b'STORE'; 148, identifier:store_as; 149, return_statement; 149, 150; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:self; 153, identifier:_execute; 154, argument_list; 154, 155; 155, identifier:command | def sort(self,
key,
by=None,
external=None,
offset=0,
limit=None,
order=None,
alpha=False,
store_as=None):
if order and order not in [b'ASC', b'DESC', 'ASC', 'DESC']:
raise ValueError('invalid sort order "{}"'.format(order))
command = [b'SORT', key]
if by:
command += [b'BY', by]
if external and isinstance(external, list):
for entry in external:
command += [b'GET', entry]
elif external:
command += [b'GET', external]
if limit:
command += [
b'LIMIT',
ascii(offset).encode('utf-8'),
ascii(limit).encode('utf-8')
]
if order:
command.append(order)
if alpha is True:
command.append(b'ALPHA')
if store_as:
command += [b'STORE', store_as]
return self._execute(command) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:zrange; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 13; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:start; 8, integer:0; 9, default_parameter; 9, 10; 9, 11; 10, identifier:stop; 11, unary_operator:-; 11, 12; 12, integer:1; 13, default_parameter; 13, 14; 13, 15; 14, identifier:with_scores; 15, False; 16, block; 16, 17; 16, 25; 16, 33; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:command; 20, list:[b'ZRANGE', key, start, stop]; 20, 21; 20, 22; 20, 23; 20, 24; 21, string:b'ZRANGE'; 22, identifier:key; 23, identifier:start; 24, identifier:stop; 25, if_statement; 25, 26; 25, 27; 26, identifier:with_scores; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, augmented_assignment:+=; 29, 30; 29, 31; 30, identifier:command; 31, list:['WITHSCORES']; 31, 32; 32, string:'WITHSCORES'; 33, return_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_execute; 38, argument_list; 38, 39; 39, identifier:command | def zrange(self, key, start=0, stop=-1, with_scores=False):
command = [b'ZRANGE', key, start, stop]
if with_scores:
command += ['WITHSCORES']
return self._execute(command) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:zrem; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, list_splat_pattern; 6, 7; 7, identifier:members; 8, block; 8, 9; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_execute; 14, argument_list; 14, 15; 15, binary_operator:+; 15, 16; 15, 19; 16, list:[b'ZREM', key]; 16, 17; 16, 18; 17, string:b'ZREM'; 18, identifier:key; 19, call; 19, 20; 19, 21; 20, identifier:list; 21, argument_list; 21, 22; 22, identifier:members | def zrem(self, key, *members):
return self._execute([b'ZREM', key] + list(members)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:zremrangebyscore; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:key; 6, identifier:min_score; 7, identifier:max_score; 8, block; 8, 9; 9, return_statement; 9, 10; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:_execute; 14, argument_list; 14, 15; 15, list:[b'ZREMRANGEBYSCORE', key, min_score, max_score]; 15, 16; 15, 17; 15, 18; 15, 19; 16, string:b'ZREMRANGEBYSCORE'; 17, identifier:key; 18, identifier:min_score; 19, identifier:max_score | def zremrangebyscore(self, key, min_score, max_score):
return self._execute([b'ZREMRANGEBYSCORE', key, min_score, max_score]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 16; 2, function_name:zrevrange; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 13; 4, identifier:self; 5, identifier:key; 6, default_parameter; 6, 7; 6, 8; 7, identifier:start; 8, integer:0; 9, default_parameter; 9, 10; 9, 11; 10, identifier:stop; 11, unary_operator:-; 11, 12; 12, integer:1; 13, default_parameter; 13, 14; 13, 15; 14, identifier:with_scores; 15, False; 16, block; 16, 17; 16, 25; 16, 33; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:command; 20, list:[b'ZREVRANGE', key, start, stop]; 20, 21; 20, 22; 20, 23; 20, 24; 21, string:b'ZREVRANGE'; 22, identifier:key; 23, identifier:start; 24, identifier:stop; 25, if_statement; 25, 26; 25, 27; 26, identifier:with_scores; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, augmented_assignment:+=; 29, 30; 29, 31; 30, identifier:command; 31, list:['WITHSCORES']; 31, 32; 32, string:'WITHSCORES'; 33, return_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_execute; 38, argument_list; 38, 39; 39, identifier:command | def zrevrange(self, key, start=0, stop=-1, with_scores=False):
command = [b'ZREVRANGE', key, start, stop]
if with_scores:
command += ['WITHSCORES']
return self._execute(command) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_sortObjects; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:orderby; 6, string:'created'; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 14; 9, 36; 9, 46; 9, 55; 9, 83; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:o; 13, list:[]; 14, for_statement; 14, 15; 14, 16; 14, 21; 15, identifier:m; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:kwargs; 19, identifier:values; 20, argument_list; 21, block; 21, 22; 22, for_statement; 22, 23; 22, 24; 22, 28; 23, identifier:l; 24, call; 24, 25; 24, 26; 25, identifier:iter; 26, argument_list; 26, 27; 27, identifier:m; 28, block; 28, 29; 29, expression_statement; 29, 30; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:o; 33, identifier:append; 34, argument_list; 34, 35; 35, identifier:l; 36, expression_statement; 36, 37; 37, assignment; 37, 38; 37, 39; 38, identifier:o; 39, call; 39, 40; 39, 41; 40, identifier:list; 41, argument_list; 41, 42; 42, call; 42, 43; 42, 44; 43, identifier:set; 44, argument_list; 44, 45; 45, identifier:o; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:sortfunc; 49, conditional_expression:if; 49, 50; 49, 51; 49, 54; 50, identifier:_sortByCreated; 51, comparison_operator:==; 51, 52; 51, 53; 52, identifier:orderby; 53, string:'created'; 54, identifier:_sortByModified; 55, if_statement; 55, 56; 55, 59; 55, 67; 56, attribute; 56, 57; 56, 58; 57, identifier:six; 58, identifier:PY2; 59, block; 59, 60; 60, expression_statement; 60, 61; 61, call; 61, 62; 61, 65; 62, attribute; 62, 63; 62, 64; 63, identifier:o; 64, identifier:sort; 65, argument_list; 65, 66; 66, identifier:sortfunc; 67, else_clause; 67, 68; 68, block; 68, 69; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 74; 71, attribute; 71, 72; 71, 73; 72, identifier:o; 73, identifier:sort; 74, argument_list; 74, 75; 75, keyword_argument; 75, 76; 75, 77; 76, identifier:key; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:functools; 80, identifier:cmp_to_key; 81, argument_list; 81, 82; 82, identifier:sortfunc; 83, return_statement; 83, 84; 84, identifier:o | def _sortObjects(orderby='created', **kwargs):
o = []
for m in kwargs.values():
for l in iter(m):
o.append(l)
o = list(set(o))
sortfunc = _sortByCreated if orderby == 'created' else _sortByModified
if six.PY2:
o.sort(sortfunc)
else:
o.sort(key=functools.cmp_to_key(sortfunc))
return o |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sortByCreated; 3, parameters; 3, 4; 3, 5; 4, identifier:a; 5, identifier:b; 6, block; 6, 7; 7, if_statement; 7, 8; 7, 15; 7, 18; 7, 30; 8, comparison_operator:<; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:a; 11, identifier:created; 12, attribute; 12, 13; 12, 14; 13, identifier:b; 14, identifier:created; 15, block; 15, 16; 16, return_statement; 16, 17; 17, integer:1; 18, elif_clause; 18, 19; 18, 26; 19, comparison_operator:>; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:a; 22, identifier:created; 23, attribute; 23, 24; 23, 25; 24, identifier:b; 25, identifier:created; 26, block; 26, 27; 27, return_statement; 27, 28; 28, unary_operator:-; 28, 29; 29, integer:1; 30, else_clause; 30, 31; 31, block; 31, 32; 32, return_statement; 32, 33; 33, integer:0 | def _sortByCreated(a, b):
if a.created < b.created:
return 1
elif a.created > b.created:
return -1
else:
return 0 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sortByModified; 3, parameters; 3, 4; 3, 5; 4, identifier:a; 5, identifier:b; 6, block; 6, 7; 7, if_statement; 7, 8; 7, 15; 7, 18; 7, 30; 8, comparison_operator:<; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:a; 11, identifier:modified; 12, attribute; 12, 13; 12, 14; 13, identifier:b; 14, identifier:modified; 15, block; 15, 16; 16, return_statement; 16, 17; 17, integer:1; 18, elif_clause; 18, 19; 18, 26; 19, comparison_operator:>; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:a; 22, identifier:modified; 23, attribute; 23, 24; 23, 25; 24, identifier:b; 25, identifier:modified; 26, block; 26, 27; 27, return_statement; 27, 28; 28, unary_operator:-; 28, 29; 29, integer:1; 30, else_clause; 30, 31; 31, block; 31, 32; 32, return_statement; 32, 33; 33, integer:0 | def _sortByModified(a, b):
if a.modified < b.modified:
return 1
elif a.modified > b.modified:
return -1
else:
return 0 |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 31; 2, function_name:wngram2idngram; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 3, 10; 3, 13; 3, 16; 3, 19; 3, 22; 3, 25; 3, 28; 4, identifier:input_file; 5, identifier:vocab_file; 6, identifier:output_file; 7, default_parameter; 7, 8; 7, 9; 8, identifier:buffersize; 9, integer:100; 10, default_parameter; 10, 11; 10, 12; 11, identifier:hashtablesize; 12, integer:2000000; 13, default_parameter; 13, 14; 13, 15; 14, identifier:files; 15, integer:20; 16, default_parameter; 16, 17; 16, 18; 17, identifier:compress; 18, False; 19, default_parameter; 19, 20; 19, 21; 20, identifier:verbosity; 21, integer:2; 22, default_parameter; 22, 23; 22, 24; 23, identifier:n; 24, integer:3; 25, default_parameter; 25, 26; 25, 27; 26, identifier:write_ascii; 27, False; 28, default_parameter; 28, 29; 28, 30; 29, identifier:fof_size; 30, integer:10; 31, block; 31, 32; 31, 55; 31, 67; 31, 79; 31, 91; 31, 103; 31, 115; 31, 127; 31, 137; 31, 147; 31, 158; 31, 259; 31, 268; 31, 284; 31, 298; 31, 322; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:cmd; 35, list:['wngram2idngram', '-vocab', os.path.abspath(vocab_file),
'-idngram', os.path.abspath(output_file)]; 35, 36; 35, 37; 35, 38; 35, 46; 35, 47; 36, string:'wngram2idngram'; 37, string:'-vocab'; 38, call; 38, 39; 38, 44; 39, attribute; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:os; 42, identifier:path; 43, identifier:abspath; 44, argument_list; 44, 45; 45, identifier:vocab_file; 46, string:'-idngram'; 47, call; 47, 48; 47, 53; 48, attribute; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:os; 51, identifier:path; 52, identifier:abspath; 53, argument_list; 53, 54; 54, identifier:output_file; 55, if_statement; 55, 56; 55, 57; 56, identifier:buffersize; 57, block; 57, 58; 58, expression_statement; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, identifier:cmd; 62, identifier:extend; 63, argument_list; 63, 64; 64, list:['-buffer', buffersize]; 64, 65; 64, 66; 65, string:'-buffer'; 66, identifier:buffersize; 67, if_statement; 67, 68; 67, 69; 68, identifier:hashtablesize; 69, block; 69, 70; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:cmd; 74, identifier:extend; 75, argument_list; 75, 76; 76, list:['-hash', hashtablesize]; 76, 77; 76, 78; 77, string:'-hash'; 78, identifier:hashtablesize; 79, if_statement; 79, 80; 79, 81; 80, identifier:files; 81, block; 81, 82; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:cmd; 86, identifier:extend; 87, argument_list; 87, 88; 88, list:['-files', files]; 88, 89; 88, 90; 89, string:'-files'; 90, identifier:files; 91, if_statement; 91, 92; 91, 93; 92, identifier:verbosity; 93, block; 93, 94; 94, expression_statement; 94, 95; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:cmd; 98, identifier:extend; 99, argument_list; 99, 100; 100, list:['-verbosity', verbosity]; 100, 101; 100, 102; 101, string:'-verbosity'; 102, identifier:verbosity; 103, if_statement; 103, 104; 103, 105; 104, identifier:n; 105, block; 105, 106; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:cmd; 110, identifier:extend; 111, argument_list; 111, 112; 112, list:['-n', n]; 112, 113; 112, 114; 113, string:'-n'; 114, identifier:n; 115, if_statement; 115, 116; 115, 117; 116, identifier:fof_size; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, call; 119, 120; 119, 123; 120, attribute; 120, 121; 120, 122; 121, identifier:cmd; 122, identifier:extend; 123, argument_list; 123, 124; 124, list:['-fof_size', fof_size]; 124, 125; 124, 126; 125, string:'-fof_size'; 126, identifier:fof_size; 127, if_statement; 127, 128; 127, 129; 128, identifier:compress; 129, block; 129, 130; 130, expression_statement; 130, 131; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:cmd; 134, identifier:append; 135, argument_list; 135, 136; 136, string:'-compress'; 137, if_statement; 137, 138; 137, 139; 138, identifier:write_ascii; 139, block; 139, 140; 140, expression_statement; 140, 141; 141, call; 141, 142; 141, 145; 142, attribute; 142, 143; 142, 144; 143, identifier:cmd; 144, identifier:append; 145, argument_list; 145, 146; 146, string:'-write_ascii'; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:cmd; 150, list_comprehension; 150, 151; 150, 155; 151, call; 151, 152; 151, 153; 152, identifier:str; 153, argument_list; 153, 154; 154, identifier:x; 155, for_in_clause; 155, 156; 155, 157; 156, identifier:x; 157, identifier:cmd; 158, with_statement; 158, 159; 158, 169; 159, with_clause; 159, 160; 160, with_item; 160, 161; 161, as_pattern; 161, 162; 161, 167; 162, call; 162, 163; 162, 166; 163, attribute; 163, 164; 163, 165; 164, identifier:tempfile; 165, identifier:SpooledTemporaryFile; 166, argument_list; 167, as_pattern_target; 167, 168; 168, identifier:output_f; 169, block; 169, 170; 169, 251; 170, with_statement; 170, 171; 170, 181; 171, with_clause; 171, 172; 172, with_item; 172, 173; 173, as_pattern; 173, 174; 173, 179; 174, call; 174, 175; 174, 178; 175, attribute; 175, 176; 175, 177; 176, identifier:tempfile; 177, identifier:SpooledTemporaryFile; 178, argument_list; 179, as_pattern_target; 179, 180; 180, identifier:input_f; 181, block; 181, 182; 181, 209; 181, 216; 182, expression_statement; 182, 183; 183, call; 183, 184; 183, 187; 184, attribute; 184, 185; 184, 186; 185, identifier:input_f; 186, identifier:write; 187, argument_list; 187, 188; 188, conditional_expression:if; 188, 189; 188, 195; 188, 208; 189, call; 189, 190; 189, 193; 190, attribute; 190, 191; 190, 192; 191, identifier:text; 192, identifier:encode; 193, argument_list; 193, 194; 194, string:'utf-8'; 195, boolean_operator:and; 195, 196; 195, 202; 196, comparison_operator:>=; 196, 197; 196, 200; 197, attribute; 197, 198; 197, 199; 198, identifier:sys; 199, identifier:version_info; 200, tuple; 200, 201; 201, integer:3; 202, comparison_operator:is; 202, 203; 202, 207; 203, call; 203, 204; 203, 205; 204, identifier:type; 205, argument_list; 205, 206; 206, identifier:text; 207, identifier:str; 208, identifier:text; 209, expression_statement; 209, 210; 210, call; 210, 211; 210, 214; 211, attribute; 211, 212; 211, 213; 212, identifier:input_f; 213, identifier:seek; 214, argument_list; 214, 215; 215, integer:0; 216, with_statement; 216, 217; 216, 225; 217, with_clause; 217, 218; 218, with_item; 218, 219; 219, as_pattern; 219, 220; 219, 223; 220, call; 220, 221; 220, 222; 221, identifier:output_to_debuglogger; 222, argument_list; 223, as_pattern_target; 223, 224; 224, identifier:err_f; 225, block; 225, 226; 226, with_statement; 226, 227; 226, 232; 227, with_clause; 227, 228; 228, with_item; 228, 229; 229, call; 229, 230; 229, 231; 230, identifier:do_in_tempdir; 231, argument_list; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, assignment; 234, 235; 234, 236; 235, identifier:exitcode; 236, call; 236, 237; 236, 240; 237, attribute; 237, 238; 237, 239; 238, identifier:subprocess; 239, identifier:call; 240, argument_list; 240, 241; 240, 242; 240, 245; 240, 248; 241, identifier:cmd; 242, keyword_argument; 242, 243; 242, 244; 243, identifier:stdin; 244, identifier:input_f; 245, keyword_argument; 245, 246; 245, 247; 246, identifier:stdout; 247, identifier:output_f; 248, keyword_argument; 248, 249; 248, 250; 249, identifier:stderr; 250, identifier:err_f; 251, expression_statement; 251, 252; 252, assignment; 252, 253; 252, 254; 253, identifier:output; 254, call; 254, 255; 254, 258; 255, attribute; 255, 256; 255, 257; 256, identifier:output_f; 257, identifier:read; 258, argument_list; 259, expression_statement; 259, 260; 260, assignment; 260, 261; 260, 262; 261, identifier:logger; 262, call; 262, 263; 262, 266; 263, attribute; 263, 264; 263, 265; 264, identifier:logging; 265, identifier:getLogger; 266, argument_list; 266, 267; 267, identifier:__name__; 268, expression_statement; 268, 269; 269, call; 269, 270; 269, 273; 270, attribute; 270, 271; 270, 272; 271, identifier:logger; 272, identifier:debug; 273, argument_list; 273, 274; 274, binary_operator:%; 274, 275; 274, 276; 275, string:"Command '%s' returned with exit code '%d'."; 276, tuple; 276, 277; 276, 283; 277, call; 277, 278; 277, 281; 278, attribute; 278, 279; 278, 280; 279, string:' '; 280, identifier:join; 281, argument_list; 281, 282; 282, identifier:cmd; 283, identifier:exitcode; 284, if_statement; 284, 285; 284, 288; 285, comparison_operator:!=; 285, 286; 285, 287; 286, identifier:exitcode; 287, integer:0; 288, block; 288, 289; 289, raise_statement; 289, 290; 290, call; 290, 291; 290, 292; 291, identifier:ConversionError; 292, argument_list; 292, 293; 293, binary_operator:%; 293, 294; 293, 295; 294, string:"'%r' returned with non-zero exit status '%s'"; 295, tuple; 295, 296; 295, 297; 296, identifier:cmd; 297, identifier:exitcode; 298, if_statement; 298, 299; 298, 312; 299, boolean_operator:and; 299, 300; 299, 306; 300, comparison_operator:>=; 300, 301; 300, 304; 301, attribute; 301, 302; 301, 303; 302, identifier:sys; 303, identifier:version_info; 304, tuple; 304, 305; 305, integer:3; 306, comparison_operator:is; 306, 307; 306, 311; 307, call; 307, 308; 307, 309; 308, identifier:type; 309, argument_list; 309, 310; 310, identifier:output; 311, identifier:bytes; 312, block; 312, 313; 313, expression_statement; 313, 314; 314, assignment; 314, 315; 314, 316; 315, identifier:output; 316, call; 316, 317; 316, 320; 317, attribute; 317, 318; 317, 319; 318, identifier:output; 319, identifier:decode; 320, argument_list; 320, 321; 321, string:'utf-8'; 322, return_statement; 322, 323; 323, call; 323, 324; 323, 327; 324, attribute; 324, 325; 324, 326; 325, identifier:output; 326, identifier:strip; 327, argument_list | def wngram2idngram(input_file, vocab_file, output_file, buffersize=100, hashtablesize=2000000, files=20, compress=False, verbosity=2, n=3, write_ascii=False, fof_size=10):
cmd = ['wngram2idngram', '-vocab', os.path.abspath(vocab_file),
'-idngram', os.path.abspath(output_file)]
if buffersize:
cmd.extend(['-buffer', buffersize])
if hashtablesize:
cmd.extend(['-hash', hashtablesize])
if files:
cmd.extend(['-files', files])
if verbosity:
cmd.extend(['-verbosity', verbosity])
if n:
cmd.extend(['-n', n])
if fof_size:
cmd.extend(['-fof_size', fof_size])
if compress:
cmd.append('-compress')
if write_ascii:
cmd.append('-write_ascii')
cmd = [str(x) for x in cmd]
with tempfile.SpooledTemporaryFile() as output_f:
with tempfile.SpooledTemporaryFile() as input_f:
input_f.write(text.encode('utf-8') if sys.version_info >= (3,) and type(text) is str else text)
input_f.seek(0)
with output_to_debuglogger() as err_f:
with do_in_tempdir():
exitcode = subprocess.call(cmd, stdin=input_f, stdout=output_f, stderr=err_f)
output = output_f.read()
logger = logging.getLogger(__name__)
logger.debug("Command '%s' returned with exit code '%d'." % (' '.join(cmd), exitcode))
if exitcode != 0:
raise ConversionError("'%r' returned with non-zero exit status '%s'" % (cmd, exitcode))
if sys.version_info >= (3,) and type(output) is bytes:
output = output.decode('utf-8')
return output.strip() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:get_top; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:stat; 6, identifier:n; 7, block; 7, 8; 8, return_statement; 8, 9; 9, subscript; 9, 10; 9, 29; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 12, 16; 12, 26; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:stats; 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:getattr; 23, argument_list; 23, 24; 23, 25; 24, identifier:x; 25, identifier:stat; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:reverse; 28, True; 29, slice; 29, 30; 29, 31; 30, colon; 31, identifier:n | def get_top(self, stat, n):
return sorted(self.stats, key=lambda x: getattr(x, stat), reverse=True)[:n] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:toposort; 3, parameters; 3, 4; 3, 5; 4, identifier:initialAtoms; 5, identifier:initialBonds; 6, block; 6, 7; 6, 11; 6, 17; 6, 21; 6, 27; 6, 31; 6, 35; 6, 51; 6, 63; 6, 69; 6, 74; 6, 142; 6, 152; 6, 164; 6, 178; 6, 180; 6, 185; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:atoms; 10, list:[]; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:a_append; 14, attribute; 14, 15; 14, 16; 15, identifier:atoms; 16, identifier:append; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:bonds; 20, list:[]; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:b_append; 24, attribute; 24, 25; 24, 26; 25, identifier:bonds; 26, identifier:append; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:ahash; 30, dictionary; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:bhash; 34, dictionary; 35, for_statement; 35, 36; 35, 37; 35, 42; 36, identifier:atom; 37, subscript; 37, 38; 37, 39; 38, identifier:initialAtoms; 39, slice; 39, 40; 39, 41; 40, integer:1; 41, colon; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 50; 45, subscript; 45, 46; 45, 47; 46, identifier:ahash; 47, attribute; 47, 48; 47, 49; 48, identifier:atom; 49, identifier:handle; 50, integer:1; 51, for_statement; 51, 52; 51, 53; 51, 54; 52, identifier:bond; 53, identifier:initialBonds; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 62; 57, subscript; 57, 58; 57, 59; 58, identifier:bhash; 59, attribute; 59, 60; 59, 61; 60, identifier:bond; 61, identifier:handle; 62, identifier:bond; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:next; 66, subscript; 66, 67; 66, 68; 67, identifier:initialAtoms; 68, integer:0; 69, expression_statement; 69, 70; 70, call; 70, 71; 70, 72; 71, identifier:a_append; 72, argument_list; 72, 73; 73, identifier:next; 74, while_statement; 74, 75; 74, 76; 75, identifier:ahash; 76, block; 76, 77; 77, for_statement; 77, 78; 77, 79; 77, 82; 77, 135; 78, identifier:atom; 79, attribute; 79, 80; 79, 81; 80, identifier:next; 81, identifier:oatoms; 82, block; 82, 83; 83, if_statement; 83, 84; 83, 92; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:ahash; 87, identifier:has_key; 88, argument_list; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:atom; 91, identifier:handle; 92, block; 92, 93; 92, 102; 92, 104; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 96; 95, identifier:bond; 96, call; 96, 97; 96, 100; 97, attribute; 97, 98; 97, 99; 98, identifier:next; 99, identifier:findbond; 100, argument_list; 100, 101; 101, identifier:atom; 102, assert_statement; 102, 103; 103, identifier:bond; 104, if_statement; 104, 105; 104, 113; 105, call; 105, 106; 105, 109; 106, attribute; 106, 107; 106, 108; 107, identifier:bhash; 108, identifier:has_key; 109, argument_list; 109, 110; 110, attribute; 110, 111; 110, 112; 111, identifier:bond; 112, identifier:handle; 113, block; 113, 114; 113, 119; 113, 124; 113, 130; 113, 134; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 117; 116, identifier:a_append; 117, argument_list; 117, 118; 118, identifier:atom; 119, expression_statement; 119, 120; 120, call; 120, 121; 120, 122; 121, identifier:b_append; 122, argument_list; 122, 123; 123, identifier:bond; 124, delete_statement; 124, 125; 125, subscript; 125, 126; 125, 127; 126, identifier:ahash; 127, attribute; 127, 128; 127, 129; 128, identifier:atom; 129, identifier:handle; 130, expression_statement; 130, 131; 131, assignment; 131, 132; 131, 133; 132, identifier:next; 133, identifier:atom; 134, break_statement; 135, else_clause; 135, 136; 136, block; 136, 137; 137, raise_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:RingException; 140, argument_list; 140, 141; 141, string:"Atoms are not in ring"; 142, assert_statement; 142, 143; 143, comparison_operator:==; 143, 144; 143, 148; 144, call; 144, 145; 144, 146; 145, identifier:len; 146, argument_list; 146, 147; 147, identifier:initialAtoms; 148, call; 148, 149; 148, 150; 149, identifier:len; 150, argument_list; 150, 151; 151, identifier:atoms; 152, assert_statement; 152, 153; 153, comparison_operator:==; 153, 154; 153, 158; 154, call; 154, 155; 154, 156; 155, identifier:len; 156, argument_list; 156, 157; 157, identifier:bonds; 158, binary_operator:-; 158, 159; 158, 163; 159, call; 159, 160; 159, 161; 160, identifier:len; 161, argument_list; 161, 162; 162, identifier:atoms; 163, integer:1; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:lastBond; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:atoms; 171, integer:0; 172, identifier:findbond; 173, argument_list; 173, 174; 174, subscript; 174, 175; 174, 176; 175, identifier:atoms; 176, unary_operator:-; 176, 177; 177, integer:1; 178, assert_statement; 178, 179; 179, identifier:lastBond; 180, expression_statement; 180, 181; 181, call; 181, 182; 181, 183; 182, identifier:b_append; 183, argument_list; 183, 184; 184, identifier:lastBond; 185, return_statement; 185, 186; 186, expression_list; 186, 187; 186, 188; 187, identifier:atoms; 188, identifier:bonds | def toposort(initialAtoms, initialBonds):
atoms = []
a_append = atoms.append
bonds = []
b_append = bonds.append
ahash = {}
bhash = {}
for atom in initialAtoms[1:]:
ahash[atom.handle] = 1
for bond in initialBonds:
bhash[bond.handle] = bond
next = initialAtoms[0]
a_append(next)
while ahash:
for atom in next.oatoms:
if ahash.has_key(atom.handle):
bond = next.findbond(atom)
assert bond
if bhash.has_key(bond.handle):
a_append(atom)
b_append(bond)
del ahash[atom.handle]
next = atom
break
else:
raise RingException("Atoms are not in ring")
assert len(initialAtoms) == len(atoms)
assert len(bonds) == len(atoms) - 1
lastBond = atoms[0].findbond(atoms[-1])
assert lastBond
b_append(lastBond)
return atoms, bonds |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:flip_uuid_parts; 3, parameters; 3, 4; 4, identifier:uuid; 5, block; 5, 6; 5, 15; 5, 31; 5, 40; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:flipped_uuid; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:uuid; 12, identifier:split; 13, argument_list; 13, 14; 14, string:'-'; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 24; 17, pattern_list; 17, 18; 17, 21; 18, subscript; 18, 19; 18, 20; 19, identifier:flipped_uuid; 20, integer:0; 21, subscript; 21, 22; 21, 23; 22, identifier:flipped_uuid; 23, integer:2; 24, expression_list; 24, 25; 24, 28; 25, subscript; 25, 26; 25, 27; 26, identifier:flipped_uuid; 27, integer:2; 28, subscript; 28, 29; 28, 30; 29, identifier:flipped_uuid; 30, integer:0; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:flipped_uuid; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, string:'-'; 37, identifier:join; 38, argument_list; 38, 39; 39, identifier:flipped_uuid; 40, return_statement; 40, 41; 41, identifier:flipped_uuid | def flip_uuid_parts(uuid):
flipped_uuid = uuid.split('-')
flipped_uuid[0], flipped_uuid[2] = flipped_uuid[2], flipped_uuid[0]
flipped_uuid = '-'.join(flipped_uuid)
return flipped_uuid |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:SortedSet; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:name; 6, default_parameter; 6, 7; 6, 8; 7, identifier:initial; 8, None; 9, block; 9, 10; 10, return_statement; 10, 11; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:types; 14, identifier:SortedSet; 15, argument_list; 15, 16; 15, 17; 15, 20; 16, identifier:name; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:api; 20, identifier:initial | def SortedSet(self, name, initial=None):
return types.SortedSet(name, self.api, initial) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:add; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:member; 6, identifier:score; 7, block; 7, 8; 8, return_statement; 8, 9; 9, call; 9, 10; 9, 15; 10, attribute; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:self; 13, identifier:client; 14, identifier:zadd; 15, argument_list; 15, 16; 15, 19; 15, 20; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:name; 19, identifier:member; 20, identifier:score | def add(self, member, score):
return self.client.zadd(self.name, member, score) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:deserialize; 3, parameters; 3, 4; 3, 5; 4, identifier:cls; 5, identifier:value; 6, block; 6, 7; 6, 16; 6, 26; 6, 36; 6, 47; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:parsed; 10, call; 10, 11; 10, 14; 11, attribute; 11, 12; 11, 13; 12, identifier:json; 13, identifier:loads; 14, argument_list; 14, 15; 15, identifier:value; 16, if_statement; 16, 17; 16, 20; 17, comparison_operator:not; 17, 18; 17, 19; 18, string:"name"; 19, identifier:parsed; 20, block; 20, 21; 21, raise_statement; 21, 22; 22, call; 22, 23; 22, 24; 23, identifier:ValueError; 24, argument_list; 24, 25; 25, string:"No peer name."; 26, if_statement; 26, 27; 26, 30; 27, comparison_operator:not; 27, 28; 27, 29; 28, string:"ip"; 29, identifier:parsed; 30, block; 30, 31; 31, raise_statement; 31, 32; 32, call; 32, 33; 32, 34; 33, identifier:ValueError; 34, argument_list; 34, 35; 35, string:"No peer IP."; 36, if_statement; 36, 37; 36, 40; 37, comparison_operator:not; 37, 38; 37, 39; 38, string:"port"; 39, identifier:parsed; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 46; 43, subscript; 43, 44; 43, 45; 44, identifier:parsed; 45, string:"port"; 46, identifier:DEFAULT_PEER_PORT; 47, return_statement; 47, 48; 48, call; 48, 49; 48, 50; 49, identifier:cls; 50, argument_list; 50, 51; 50, 54; 50, 57; 51, subscript; 51, 52; 51, 53; 52, identifier:parsed; 53, string:"name"; 54, subscript; 54, 55; 54, 56; 55, identifier:parsed; 56, string:"ip"; 57, subscript; 57, 58; 57, 59; 58, identifier:parsed; 59, string:"port" | def deserialize(cls, value):
parsed = json.loads(value)
if "name" not in parsed:
raise ValueError("No peer name.")
if "ip" not in parsed:
raise ValueError("No peer IP.")
if "port" not in parsed:
parsed["port"] = DEFAULT_PEER_PORT
return cls(parsed["name"], parsed["ip"], parsed["port"]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:apply_config; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:config; 6, block; 6, 7; 6, 19; 6, 37; 6, 45; 6, 57; 6, 63; 6, 73; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:host; 12, call; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:config; 15, identifier:get; 16, argument_list; 16, 17; 16, 18; 17, string:"host"; 18, string:"127.0.0.1"; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:configured_ports; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:config; 27, identifier:get; 28, argument_list; 28, 29; 28, 30; 29, string:"ports"; 30, list:[config.get("port")]; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:config; 34, identifier:get; 35, argument_list; 35, 36; 36, string:"port"; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:discovery; 42, subscript; 42, 43; 42, 44; 43, identifier:config; 44, string:"discovery"; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:metadata; 50, call; 50, 51; 50, 54; 51, attribute; 51, 52; 51, 53; 52, identifier:config; 53, identifier:get; 54, argument_list; 54, 55; 54, 56; 55, string:"metadata"; 56, dictionary; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:update_ports; 62, argument_list; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:self; 67, identifier:check_interval; 68, subscript; 68, 69; 68, 72; 69, subscript; 69, 70; 69, 71; 70, identifier:config; 71, string:"checks"; 72, string:"interval"; 73, expression_statement; 73, 74; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:update_checks; 78, argument_list; 78, 79; 79, subscript; 79, 80; 79, 81; 80, identifier:config; 81, string:"checks" | def apply_config(self, config):
self.host = config.get("host", "127.0.0.1")
self.configured_ports = config.get("ports", [config.get("port")])
self.discovery = config["discovery"]
self.metadata = config.get("metadata", {})
self.update_ports()
self.check_interval = config["checks"]["interval"]
self.update_checks(config["checks"]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_key; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:key; 6, None; 7, default_parameter; 7, 8; 7, 9; 8, identifier:keyfile; 9, None; 10, block; 10, 11; 10, 68; 11, if_statement; 11, 12; 11, 15; 12, comparison_operator:is; 12, 13; 12, 14; 13, identifier:key; 14, None; 15, block; 15, 16; 16, if_statement; 16, 17; 16, 20; 16, 54; 17, comparison_operator:is; 17, 18; 17, 19; 18, identifier:keyfile; 19, None; 20, block; 20, 21; 20, 30; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:key; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:environ; 27, identifier:get; 28, argument_list; 28, 29; 29, string:'CRYPTOYAML_SECRET'; 30, if_statement; 30, 31; 30, 34; 30, 43; 31, comparison_operator:is; 31, 32; 31, 33; 32, identifier:key; 33, None; 34, block; 34, 35; 35, raise_statement; 35, 36; 36, call; 36, 37; 36, 38; 37, identifier:MissingKeyException; 38, argument_list; 38, 39; 39, concatenated_string; 39, 40; 39, 41; 39, 42; 40, string:'''You must either provide a key value,'''; 41, string:''' a path to a key or its value via the environment variable '''; 42, string:''' CRYPTOYAML_SECRET'''; 43, else_clause; 43, 44; 44, block; 44, 45; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:key; 48, call; 48, 49; 48, 52; 49, attribute; 49, 50; 49, 51; 50, identifier:key; 51, identifier:encode; 52, argument_list; 52, 53; 53, string:'utf-8'; 54, else_clause; 54, 55; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:key; 59, call; 59, 60; 59, 67; 60, attribute; 60, 61; 60, 66; 61, call; 61, 62; 61, 63; 62, identifier:open; 63, argument_list; 63, 64; 63, 65; 64, identifier:keyfile; 65, string:'rb'; 66, identifier:read; 67, argument_list; 68, return_statement; 68, 69; 69, identifier:key | def get_key(key=None, keyfile=None):
if key is None:
if keyfile is None:
key = environ.get('CRYPTOYAML_SECRET')
if key is None:
raise MissingKeyException(
'''You must either provide a key value,'''
''' a path to a key or its value via the environment variable '''
''' CRYPTOYAML_SECRET'''
)
else:
key = key.encode('utf-8')
else:
key = open(keyfile, 'rb').read()
return key |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 27; 2, function_name:getList; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 3, 21; 3, 24; 4, identifier:self; 5, identifier:full_path; 6, default_parameter; 6, 7; 6, 8; 7, identifier:type; 8, integer:1; 9, default_parameter; 9, 10; 9, 11; 10, identifier:dept; 11, integer:0; 12, default_parameter; 12, 13; 12, 14; 13, identifier:sort; 14, string:'name'; 15, default_parameter; 15, 16; 15, 17; 16, identifier:order; 17, string:'asc'; 18, default_parameter; 18, 19; 18, 20; 19, identifier:startnum; 20, integer:0; 21, default_parameter; 21, 22; 21, 23; 22, identifier:pagingrow; 23, integer:1000; 24, default_parameter; 24, 25; 24, 26; 25, identifier:dummy; 26, integer:56184; 27, block; 27, 28; 27, 41; 27, 79; 27, 91; 28, if_statement; 28, 29; 28, 36; 29, comparison_operator:not; 29, 30; 29, 31; 30, identifier:type; 31, call; 31, 32; 31, 33; 32, identifier:range; 33, argument_list; 33, 34; 33, 35; 34, integer:1; 35, integer:6; 36, block; 36, 37; 36, 39; 37, print_statement; 37, 38; 38, string:"Error getList: `type` should be between 1 to 5"; 39, return_statement; 39, 40; 40, False; 41, expression_statement; 41, 42; 42, assignment; 42, 43; 42, 44; 43, identifier:data; 44, dictionary; 44, 45; 44, 48; 44, 51; 44, 54; 44, 57; 44, 60; 44, 63; 44, 66; 44, 71; 44, 76; 45, pair; 45, 46; 45, 47; 46, string:'orgresource'; 47, identifier:full_path; 48, pair; 48, 49; 48, 50; 49, string:'type'; 50, identifier:type; 51, pair; 51, 52; 51, 53; 52, string:'dept'; 53, identifier:dept; 54, pair; 54, 55; 54, 56; 55, string:'sort'; 56, identifier:sort; 57, pair; 57, 58; 57, 59; 58, string:'order'; 59, identifier:order; 60, pair; 60, 61; 60, 62; 61, string:'startnum'; 62, identifier:startnum; 63, pair; 63, 64; 63, 65; 64, string:'pagingrow'; 65, identifier:pagingrow; 66, pair; 66, 67; 66, 68; 67, string:'userid'; 68, attribute; 68, 69; 68, 70; 69, identifier:self; 70, identifier:user_id; 71, pair; 71, 72; 71, 73; 72, string:'useridx'; 73, attribute; 73, 74; 73, 75; 74, identifier:self; 75, identifier:useridx; 76, pair; 76, 77; 76, 78; 77, string:'dummy'; 78, identifier:dummy; 79, expression_statement; 79, 80; 80, assignment; 80, 81; 80, 84; 81, pattern_list; 81, 82; 81, 83; 82, identifier:s; 83, identifier:metadata; 84, call; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:POST; 88, argument_list; 88, 89; 88, 90; 89, string:'getList'; 90, identifier:data; 91, if_statement; 91, 92; 91, 95; 91, 98; 92, comparison_operator:is; 92, 93; 92, 94; 93, identifier:s; 94, True; 95, block; 95, 96; 96, return_statement; 96, 97; 97, identifier:metadata; 98, else_clause; 98, 99; 99, block; 99, 100; 99, 102; 100, print_statement; 100, 101; 101, identifier:metadata; 102, return_statement; 102, 103; 103, False | def getList(self, full_path, type = 1, dept = 0, sort = 'name', order = 'asc', startnum = 0, pagingrow = 1000, dummy = 56184):
if type not in range(1, 6):
print "Error getList: `type` should be between 1 to 5"
return False
data = {'orgresource': full_path,
'type': type,
'dept': dept,
'sort': sort,
'order': order,
'startnum': startnum,
'pagingrow': pagingrow,
'userid': self.user_id,
'useridx': self.useridx,
'dummy': dummy,
}
s, metadata = self.POST('getList', data)
if s is True:
return metadata
else:
print metadata
return False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:list_assignment_groups; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:course_id; 6, default_parameter; 6, 7; 6, 8; 7, identifier:exclude_assignment_submission_types; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:grading_period_id; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:include; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:override_assignment_dates; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:scope_assignments_to_student; 20, None; 21, block; 21, 22; 21, 26; 21, 30; 21, 34; 21, 40; 21, 65; 21, 88; 21, 99; 21, 110; 21, 121; 21, 142; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:path; 25, dictionary; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:data; 29, dictionary; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:params; 33, dictionary; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 39; 36, subscript; 36, 37; 36, 38; 37, identifier:path; 38, string:"course_id"; 39, identifier:course_id; 40, if_statement; 40, 41; 40, 44; 41, comparison_operator:is; 41, 42; 41, 43; 42, identifier:include; 43, None; 44, block; 44, 45; 44, 59; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_validate_enum; 50, argument_list; 50, 51; 50, 52; 51, identifier:include; 52, list:["assignments", "discussion_topic", "all_dates", "assignment_visibility", "overrides", "submission"]; 52, 53; 52, 54; 52, 55; 52, 56; 52, 57; 52, 58; 53, string:"assignments"; 54, string:"discussion_topic"; 55, string:"all_dates"; 56, string:"assignment_visibility"; 57, string:"overrides"; 58, string:"submission"; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 64; 61, subscript; 61, 62; 61, 63; 62, identifier:params; 63, string:"include"; 64, identifier:include; 65, if_statement; 65, 66; 65, 69; 66, comparison_operator:is; 66, 67; 66, 68; 67, identifier:exclude_assignment_submission_types; 68, None; 69, block; 69, 70; 69, 82; 70, expression_statement; 70, 71; 71, call; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:_validate_enum; 75, argument_list; 75, 76; 75, 77; 76, identifier:exclude_assignment_submission_types; 77, list:["online_quiz", "discussion_topic", "wiki_page", "external_tool"]; 77, 78; 77, 79; 77, 80; 77, 81; 78, string:"online_quiz"; 79, string:"discussion_topic"; 80, string:"wiki_page"; 81, string:"external_tool"; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:params; 86, string:"exclude_assignment_submission_types"; 87, identifier:exclude_assignment_submission_types; 88, if_statement; 88, 89; 88, 92; 89, comparison_operator:is; 89, 90; 89, 91; 90, identifier:override_assignment_dates; 91, None; 92, block; 92, 93; 93, expression_statement; 93, 94; 94, assignment; 94, 95; 94, 98; 95, subscript; 95, 96; 95, 97; 96, identifier:params; 97, string:"override_assignment_dates"; 98, identifier:override_assignment_dates; 99, if_statement; 99, 100; 99, 103; 100, comparison_operator:is; 100, 101; 100, 102; 101, identifier:grading_period_id; 102, None; 103, block; 103, 104; 104, expression_statement; 104, 105; 105, assignment; 105, 106; 105, 109; 106, subscript; 106, 107; 106, 108; 107, identifier:params; 108, string:"grading_period_id"; 109, identifier:grading_period_id; 110, if_statement; 110, 111; 110, 114; 111, comparison_operator:is; 111, 112; 111, 113; 112, identifier:scope_assignments_to_student; 113, None; 114, block; 114, 115; 115, expression_statement; 115, 116; 116, assignment; 116, 117; 116, 120; 117, subscript; 117, 118; 117, 119; 118, identifier:params; 119, string:"scope_assignments_to_student"; 120, identifier:scope_assignments_to_student; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 128; 123, attribute; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:self; 126, identifier:logger; 127, identifier:debug; 128, argument_list; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, string:"GET /api/v1/courses/{course_id}/assignment_groups with query params: {params} and form data: {data}"; 132, identifier:format; 133, argument_list; 133, 134; 133, 137; 133, 140; 134, keyword_argument; 134, 135; 134, 136; 135, identifier:params; 136, identifier:params; 137, keyword_argument; 137, 138; 137, 139; 138, identifier:data; 139, identifier:data; 140, dictionary_splat; 140, 141; 141, identifier:path; 142, return_statement; 142, 143; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:self; 146, identifier:generic_request; 147, argument_list; 147, 148; 147, 149; 147, 156; 147, 159; 147, 162; 148, string:"GET"; 149, call; 149, 150; 149, 153; 150, attribute; 150, 151; 150, 152; 151, string:"/api/v1/courses/{course_id}/assignment_groups"; 152, identifier:format; 153, argument_list; 153, 154; 154, dictionary_splat; 154, 155; 155, identifier:path; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:data; 158, identifier:data; 159, keyword_argument; 159, 160; 159, 161; 160, identifier:params; 161, identifier:params; 162, keyword_argument; 162, 163; 162, 164; 163, identifier:all_pages; 164, True | def list_assignment_groups(self, course_id, exclude_assignment_submission_types=None, grading_period_id=None, include=None, override_assignment_dates=None, scope_assignments_to_student=None):
path = {}
data = {}
params = {}
path["course_id"] = course_id
if include is not None:
self._validate_enum(include, ["assignments", "discussion_topic", "all_dates", "assignment_visibility", "overrides", "submission"])
params["include"] = include
if exclude_assignment_submission_types is not None:
self._validate_enum(exclude_assignment_submission_types, ["online_quiz", "discussion_topic", "wiki_page", "external_tool"])
params["exclude_assignment_submission_types"] = exclude_assignment_submission_types
if override_assignment_dates is not None:
params["override_assignment_dates"] = override_assignment_dates
if grading_period_id is not None:
params["grading_period_id"] = grading_period_id
if scope_assignments_to_student is not None:
params["scope_assignments_to_student"] = scope_assignments_to_student
self.logger.debug("GET /api/v1/courses/{course_id}/assignment_groups with query params: {params} and form data: {data}".format(params=params, data=data, **path))
return self.generic_request("GET", "/api/v1/courses/{course_id}/assignment_groups".format(**path), data=data, params=params, all_pages=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sorted_keys; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 39; 6, try_statement; 6, 7; 6, 16; 7, block; 7, 8; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:keys; 11, subscript; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_cache; 15, string:'sorted_keys'; 16, except_clause; 16, 17; 16, 18; 17, identifier:KeyError; 18, block; 18, 19; 19, expression_statement; 19, 20; 20, assignment; 20, 21; 20, 22; 21, identifier:keys; 22, assignment; 22, 23; 22, 28; 23, subscript; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:_cache; 27, string:'sorted_keys'; 28, call; 28, 29; 28, 30; 29, identifier:sorted; 30, argument_list; 30, 31; 30, 36; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:keys; 35, argument_list; 36, keyword_argument; 36, 37; 36, 38; 37, identifier:key; 38, identifier:parse_version; 39, return_statement; 39, 40; 40, identifier:keys | def _sorted_keys(self):
try:
keys = self._cache['sorted_keys']
except KeyError:
keys = self._cache['sorted_keys'] = sorted(self.keys(), key=parse_version)
return keys |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:query; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:self; 5, identifier:query; 6, default_parameter; 6, 7; 6, 8; 7, identifier:filters; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:columns; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:sort; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:start; 17, integer:0; 18, default_parameter; 18, 19; 18, 20; 19, identifier:rows; 20, integer:30; 21, block; 21, 22; 21, 32; 21, 65; 21, 85; 21, 127; 21, 144; 21, 152; 21, 166; 21, 176; 21, 182; 21, 186; 21, 212; 21, 216; 21, 225; 22, if_statement; 22, 23; 22, 25; 23, not_operator; 23, 24; 24, identifier:columns; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:columns; 29, list:["*", "score"]; 29, 30; 29, 31; 30, string:"*"; 31, string:"score"; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:fields; 35, dictionary; 35, 36; 35, 39; 35, 42; 35, 50; 35, 56; 35, 62; 36, pair; 36, 37; 36, 38; 37, string:"q"; 38, identifier:query; 39, pair; 39, 40; 39, 41; 40, string:"json.nl"; 41, string:"map"; 42, pair; 42, 43; 42, 44; 43, string:"fl"; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, string:","; 47, identifier:join; 48, argument_list; 48, 49; 49, identifier:columns; 50, pair; 50, 51; 50, 52; 51, string:"start"; 52, call; 52, 53; 52, 54; 53, identifier:str; 54, argument_list; 54, 55; 55, identifier:start; 56, pair; 56, 57; 56, 58; 57, string:"rows"; 58, call; 58, 59; 58, 60; 59, identifier:str; 60, argument_list; 60, 61; 61, identifier:rows; 62, pair; 62, 63; 62, 64; 63, string:"wt"; 64, string:"json"; 65, if_statement; 65, 66; 65, 74; 66, comparison_operator:>; 66, 67; 66, 73; 67, call; 67, 68; 67, 69; 68, identifier:len; 69, argument_list; 69, 70; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:endpoints; 73, integer:1; 74, block; 74, 75; 75, expression_statement; 75, 76; 76, assignment; 76, 77; 76, 80; 77, subscript; 77, 78; 77, 79; 78, identifier:fields; 79, string:"shards"; 80, call; 80, 81; 80, 84; 81, attribute; 81, 82; 81, 83; 82, identifier:self; 83, identifier:_get_shards; 84, argument_list; 85, if_statement; 85, 86; 85, 90; 86, not_operator; 86, 87; 87, comparison_operator:is; 87, 88; 87, 89; 88, identifier:filters; 89, None; 90, block; 90, 91; 90, 95; 90, 116; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:filter_list; 94, list:[]; 95, for_statement; 95, 96; 95, 99; 95, 104; 96, pattern_list; 96, 97; 96, 98; 97, identifier:filter_field; 98, identifier:value; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:filters; 102, identifier:items; 103, argument_list; 104, block; 104, 105; 105, expression_statement; 105, 106; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, identifier:filter_list; 109, identifier:append; 110, argument_list; 110, 111; 111, binary_operator:%; 111, 112; 111, 113; 112, string:"%s:%s"; 113, tuple; 113, 114; 113, 115; 114, identifier:filter_field; 115, identifier:value; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 121; 118, subscript; 118, 119; 118, 120; 119, identifier:fields; 120, string:"fq"; 121, call; 121, 122; 121, 125; 122, attribute; 122, 123; 122, 124; 123, string:" AND "; 124, identifier:join; 125, argument_list; 125, 126; 126, identifier:filter_list; 127, if_statement; 127, 128; 127, 132; 128, not_operator; 128, 129; 129, comparison_operator:is; 129, 130; 129, 131; 130, identifier:sort; 131, None; 132, block; 132, 133; 133, expression_statement; 133, 134; 134, assignment; 134, 135; 134, 138; 135, subscript; 135, 136; 135, 137; 136, identifier:fields; 137, string:"sort"; 138, call; 138, 139; 138, 142; 139, attribute; 139, 140; 139, 141; 140, string:","; 141, identifier:join; 142, argument_list; 142, 143; 143, identifier:sort; 144, assert_statement; 144, 145; 145, comparison_operator:in; 145, 146; 145, 149; 146, attribute; 146, 147; 146, 148; 147, identifier:self; 148, identifier:default_endpoint; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:endpoints; 152, expression_statement; 152, 153; 153, assignment; 153, 154; 153, 155; 154, identifier:request_url; 155, call; 155, 156; 155, 157; 156, identifier:_get_url; 157, argument_list; 157, 158; 157, 165; 158, subscript; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:endpoints; 162, attribute; 162, 163; 162, 164; 163, identifier:self; 164, identifier:default_endpoint; 165, string:"select"; 166, expression_statement; 166, 167; 167, assignment; 167, 168; 167, 169; 168, identifier:results; 169, call; 169, 170; 169, 173; 170, attribute; 170, 171; 170, 172; 171, identifier:self; 172, identifier:_send_solr_query; 173, argument_list; 173, 174; 173, 175; 174, identifier:request_url; 175, identifier:fields; 176, if_statement; 176, 177; 176, 179; 177, not_operator; 177, 178; 178, identifier:results; 179, block; 179, 180; 180, return_statement; 180, 181; 181, None; 182, assert_statement; 182, 183; 183, comparison_operator:in; 183, 184; 183, 185; 184, string:"responseHeader"; 185, identifier:results; 186, if_statement; 186, 187; 186, 201; 187, not_operator; 187, 188; 188, comparison_operator:==; 188, 189; 188, 200; 189, call; 189, 190; 189, 198; 190, attribute; 190, 191; 190, 197; 191, call; 191, 192; 191, 195; 192, attribute; 192, 193; 192, 194; 193, identifier:results; 194, identifier:get; 195, argument_list; 195, 196; 196, string:"responseHeader"; 197, identifier:get; 198, argument_list; 198, 199; 199, string:"status"; 200, integer:0; 201, block; 201, 202; 201, 210; 202, expression_statement; 202, 203; 203, call; 203, 204; 203, 207; 204, attribute; 204, 205; 204, 206; 205, identifier:logger; 206, identifier:error; 207, argument_list; 207, 208; 207, 209; 208, string:"Server error while retrieving results: %s"; 209, identifier:results; 210, return_statement; 210, 211; 211, None; 212, assert_statement; 212, 213; 213, comparison_operator:in; 213, 214; 213, 215; 214, string:"response"; 215, identifier:results; 216, expression_statement; 216, 217; 217, assignment; 217, 218; 217, 219; 218, identifier:result_obj; 219, call; 219, 220; 219, 223; 220, attribute; 220, 221; 220, 222; 221, identifier:self; 222, identifier:_parse_response; 223, argument_list; 223, 224; 224, identifier:results; 225, return_statement; 225, 226; 226, identifier:result_obj | def query(self, query, filters=None, columns=None, sort=None, start=0, rows=30):
if not columns:
columns = ["*", "score"]
fields = {"q": query,
"json.nl" :"map",
"fl": ",".join(columns),
"start": str(start),
"rows": str(rows),
"wt": "json"}
if len(self.endpoints) > 1:
fields["shards"] = self._get_shards()
if not filters is None:
filter_list = []
for filter_field, value in filters.items():
filter_list.append("%s:%s" % (filter_field, value))
fields["fq"] = " AND ".join(filter_list)
if not sort is None:
fields["sort"] = ",".join(sort)
assert self.default_endpoint in self.endpoints
request_url = _get_url(self.endpoints[self.default_endpoint], "select")
results = self._send_solr_query(request_url, fields)
if not results:
return None
assert "responseHeader" in results
if not results.get("responseHeader").get("status") == 0:
logger.error("Server error while retrieving results: %s", results)
return None
assert "response" in results
result_obj = self._parse_response(results)
return result_obj |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 21; 2, function_name:search_videohub; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 3, 15; 3, 18; 4, identifier:cls; 5, identifier:query; 6, default_parameter; 6, 7; 6, 8; 7, identifier:filters; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:status; 11, None; 12, default_parameter; 12, 13; 12, 14; 13, identifier:sort; 14, None; 15, default_parameter; 15, 16; 15, 17; 16, identifier:size; 17, None; 18, default_parameter; 18, 19; 18, 20; 19, identifier:page; 20, None; 21, block; 21, 22; 21, 33; 21, 45; 21, 52; 21, 67; 21, 94; 21, 109; 21, 128; 21, 147; 21, 167; 21, 180; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:url; 25, call; 25, 26; 25, 27; 26, identifier:getattr; 27, argument_list; 27, 28; 27, 29; 27, 30; 28, identifier:settings; 29, string:"VIDEOHUB_API_SEARCH_URL"; 30, attribute; 30, 31; 30, 32; 31, identifier:cls; 32, identifier:DEFAULT_VIDEOHUB_API_SEARCH_URL; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:headers; 36, dictionary; 36, 37; 36, 40; 37, pair; 37, 38; 37, 39; 38, string:"Content-Type"; 39, string:"application/json"; 40, pair; 40, 41; 40, 42; 41, string:"Authorization"; 42, attribute; 42, 43; 42, 44; 43, identifier:settings; 44, identifier:VIDEOHUB_API_TOKEN; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:payload; 48, dictionary; 48, 49; 49, pair; 49, 50; 49, 51; 50, string:"query"; 51, identifier:query; 52, if_statement; 52, 53; 52, 54; 53, identifier:filters; 54, block; 54, 55; 54, 61; 55, assert_statement; 55, 56; 56, call; 56, 57; 56, 58; 57, identifier:isinstance; 58, argument_list; 58, 59; 58, 60; 59, identifier:filters; 60, identifier:dict; 61, expression_statement; 61, 62; 62, assignment; 62, 63; 62, 66; 63, subscript; 63, 64; 63, 65; 64, identifier:payload; 65, string:"filters"; 66, identifier:filters; 67, if_statement; 67, 68; 67, 69; 68, identifier:status; 69, block; 69, 70; 69, 78; 69, 86; 70, assert_statement; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:isinstance; 73, argument_list; 73, 74; 73, 75; 74, identifier:status; 75, attribute; 75, 76; 75, 77; 76, identifier:six; 77, identifier:string_types; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 83; 80, attribute; 80, 81; 80, 82; 81, identifier:payload; 82, identifier:setdefault; 83, argument_list; 83, 84; 83, 85; 84, string:"filters"; 85, dictionary; 86, expression_statement; 86, 87; 87, assignment; 87, 88; 87, 93; 88, subscript; 88, 89; 88, 92; 89, subscript; 89, 90; 89, 91; 90, identifier:payload; 91, string:"filters"; 92, string:"status"; 93, identifier:status; 94, if_statement; 94, 95; 94, 96; 95, identifier:sort; 96, block; 96, 97; 96, 103; 97, assert_statement; 97, 98; 98, call; 98, 99; 98, 100; 99, identifier:isinstance; 100, argument_list; 100, 101; 100, 102; 101, identifier:sort; 102, identifier:dict; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 108; 105, subscript; 105, 106; 105, 107; 106, identifier:payload; 107, string:"sort"; 108, identifier:sort; 109, if_statement; 109, 110; 109, 111; 110, identifier:size; 111, block; 111, 112; 111, 122; 112, assert_statement; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:isinstance; 115, argument_list; 115, 116; 115, 117; 116, identifier:size; 117, tuple; 117, 118; 117, 121; 118, attribute; 118, 119; 118, 120; 119, identifier:six; 120, identifier:string_types; 121, identifier:int; 122, expression_statement; 122, 123; 123, assignment; 123, 124; 123, 127; 124, subscript; 124, 125; 124, 126; 125, identifier:payload; 126, string:"size"; 127, identifier:size; 128, if_statement; 128, 129; 128, 130; 129, identifier:page; 130, block; 130, 131; 130, 141; 131, assert_statement; 131, 132; 132, call; 132, 133; 132, 134; 133, identifier:isinstance; 134, argument_list; 134, 135; 134, 136; 135, identifier:page; 136, tuple; 136, 137; 136, 140; 137, attribute; 137, 138; 137, 139; 138, identifier:six; 139, identifier:string_types; 140, identifier:int; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, subscript; 143, 144; 143, 145; 144, identifier:payload; 145, string:"page"; 146, identifier:page; 147, expression_statement; 147, 148; 148, assignment; 148, 149; 148, 150; 149, identifier:res; 150, call; 150, 151; 150, 154; 151, attribute; 151, 152; 151, 153; 152, identifier:requests; 153, identifier:post; 154, argument_list; 154, 155; 154, 156; 154, 164; 155, identifier:url; 156, keyword_argument; 156, 157; 156, 158; 157, identifier:data; 158, call; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:json; 161, identifier:dumps; 162, argument_list; 162, 163; 163, identifier:payload; 164, keyword_argument; 164, 165; 164, 166; 165, identifier:headers; 166, identifier:headers; 167, if_statement; 167, 168; 167, 173; 168, comparison_operator:!=; 168, 169; 168, 172; 169, attribute; 169, 170; 169, 171; 170, identifier:res; 171, identifier:status_code; 172, integer:200; 173, block; 173, 174; 174, expression_statement; 174, 175; 175, call; 175, 176; 175, 179; 176, attribute; 176, 177; 176, 178; 177, identifier:res; 178, identifier:raise_for_status; 179, argument_list; 180, return_statement; 180, 181; 181, call; 181, 182; 181, 185; 182, attribute; 182, 183; 182, 184; 183, identifier:json; 184, identifier:loads; 185, argument_list; 185, 186; 186, attribute; 186, 187; 186, 188; 187, identifier:res; 188, identifier:content | def search_videohub(cls, query, filters=None, status=None, sort=None, size=None, page=None):
url = getattr(settings, "VIDEOHUB_API_SEARCH_URL", cls.DEFAULT_VIDEOHUB_API_SEARCH_URL)
headers = {
"Content-Type": "application/json",
"Authorization": settings.VIDEOHUB_API_TOKEN,
}
payload = {
"query": query,
}
if filters:
assert isinstance(filters, dict)
payload["filters"] = filters
if status:
assert isinstance(status, six.string_types)
payload.setdefault("filters", {})
payload["filters"]["status"] = status
if sort:
assert isinstance(sort, dict)
payload["sort"] = sort
if size:
assert isinstance(size, (six.string_types, int))
payload["size"] = size
if page:
assert isinstance(page, (six.string_types, int))
payload["page"] = page
res = requests.post(url, data=json.dumps(payload), headers=headers)
if res.status_code != 200:
res.raise_for_status()
return json.loads(res.content) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:insert; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:key; 6, identifier:value; 7, block; 7, 8; 7, 15; 7, 25; 8, expression_statement; 8, 9; 9, call; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:self; 12, identifier:_find_lte; 13, argument_list; 13, 14; 14, identifier:key; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:node; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:_create_node; 22, argument_list; 22, 23; 22, 24; 23, identifier:key; 24, identifier:value; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:_insert; 30, argument_list; 30, 31; 31, identifier:node | def insert(self, key, value):
self._find_lte(key)
node = self._create_node(key, value)
self._insert(node) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 3, 7; 4, identifier:self; 5, list_splat_pattern; 5, 6; 6, identifier:sorting; 7, dictionary_splat_pattern; 7, 8; 8, identifier:kwargs; 9, block; 9, 10; 9, 14; 9, 61; 9, 74; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:sorting_; 13, list:[]; 14, for_statement; 14, 15; 14, 18; 14, 19; 15, pattern_list; 15, 16; 15, 17; 16, identifier:name; 17, identifier:desc; 18, identifier:sorting; 19, block; 19, 20; 19, 37; 19, 43; 19, 54; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:field; 23, call; 23, 24; 23, 35; 24, attribute; 24, 25; 24, 34; 25, attribute; 25, 26; 25, 33; 26, attribute; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:meta; 31, identifier:model; 32, identifier:_meta; 33, identifier:fields; 34, identifier:get; 35, argument_list; 35, 36; 36, identifier:name; 37, if_statement; 37, 38; 37, 41; 38, comparison_operator:is; 38, 39; 38, 40; 39, identifier:field; 40, None; 41, block; 41, 42; 42, continue_statement; 43, if_statement; 43, 44; 43, 45; 44, identifier:desc; 45, block; 45, 46; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:field; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:field; 52, identifier:desc; 53, argument_list; 54, expression_statement; 54, 55; 55, call; 55, 56; 55, 59; 56, attribute; 56, 57; 56, 58; 57, identifier:sorting_; 58, identifier:append; 59, argument_list; 59, 60; 60, identifier:field; 61, if_statement; 61, 62; 61, 63; 62, identifier:sorting_; 63, block; 63, 64; 64, return_statement; 64, 65; 65, call; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:self; 69, identifier:collection; 70, identifier:order_by; 71, argument_list; 71, 72; 72, list_splat; 72, 73; 73, identifier:sorting_; 74, return_statement; 74, 75; 75, attribute; 75, 76; 75, 77; 76, identifier:self; 77, identifier:collection | def sort(self, *sorting, **kwargs):
sorting_ = []
for name, desc in sorting:
field = self.meta.model._meta.fields.get(name)
if field is None:
continue
if desc:
field = field.desc()
sorting_.append(field)
if sorting_:
return self.collection.order_by(*sorting_)
return self.collection |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:split; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:indices; 6, block; 6, 7; 7, return_statement; 7, 8; 8, list_comprehension; 8, 9; 8, 16; 9, call; 9, 10; 9, 11; 10, identifier:LogicalNetworkList; 11, argument_list; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:hg; 15, identifier:part; 16, for_in_clause; 16, 17; 16, 18; 17, identifier:part; 18, call; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:np; 21, identifier:split; 22, argument_list; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:__matrix; 26, identifier:indices | def split(self, indices):
return [LogicalNetworkList(self.hg, part) for part in np.split(self.__matrix, indices)] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 7; 2, function_name:movies_box_office; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, dictionary_splat_pattern; 5, 6; 6, identifier:kwargs; 7, block; 7, 8; 7, 17; 7, 27; 7, 34; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:path; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:self; 14, identifier:_get_path; 15, argument_list; 15, 16; 16, string:'movies_box_office'; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:response; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_GET; 24, argument_list; 24, 25; 24, 26; 25, identifier:path; 26, identifier:kwargs; 27, expression_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_set_attrs_to_values; 32, argument_list; 32, 33; 33, identifier:response; 34, return_statement; 34, 35; 35, identifier:response | def movies_box_office(self, **kwargs):
path = self._get_path('movies_box_office')
response = self._GET(path, kwargs)
self._set_attrs_to_values(response)
return response |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:get_parents; 3, parameters; 4, block; 4, 5; 4, 14; 4, 28; 4, 49; 5, expression_statement; 5, 6; 6, assignment; 6, 7; 6, 8; 7, identifier:distributions; 8, call; 8, 9; 8, 10; 9, identifier:get_installed_distributions; 10, argument_list; 10, 11; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:user_only; 13, identifier:ENABLE_USER_SITE; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:remaining; 17, set_comprehension; 17, 18; 17, 25; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:d; 22, identifier:project_name; 23, identifier:lower; 24, argument_list; 25, for_in_clause; 25, 26; 25, 27; 26, identifier:d; 27, identifier:distributions; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:requirements; 31, set_comprehension; 31, 32; 31, 39; 31, 42; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:r; 36, identifier:project_name; 37, identifier:lower; 38, argument_list; 39, for_in_clause; 39, 40; 39, 41; 40, identifier:d; 41, identifier:distributions; 42, for_in_clause; 42, 43; 42, 44; 43, identifier:r; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:d; 47, identifier:requires; 48, argument_list; 49, return_statement; 49, 50; 50, call; 50, 51; 50, 52; 51, identifier:get_realnames; 52, argument_list; 52, 53; 53, binary_operator:-; 53, 54; 53, 55; 54, identifier:remaining; 55, identifier:requirements | def get_parents():
distributions = get_installed_distributions(user_only=ENABLE_USER_SITE)
remaining = {d.project_name.lower() for d in distributions}
requirements = {r.project_name.lower() for d in distributions for
r in d.requires()}
return get_realnames(remaining - requirements) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_realnames; 3, parameters; 3, 4; 4, identifier:packages; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 20; 10, set_comprehension; 10, 11; 10, 17; 11, attribute; 11, 12; 11, 16; 12, call; 12, 13; 12, 14; 13, identifier:get_distribution; 14, argument_list; 14, 15; 15, identifier:p; 16, identifier:project_name; 17, for_in_clause; 17, 18; 17, 19; 18, identifier:p; 19, identifier:packages; 20, keyword_argument; 20, 21; 20, 22; 21, identifier:key; 22, lambda; 22, 23; 22, 25; 23, lambda_parameters; 23, 24; 24, identifier:n; 25, call; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:n; 28, identifier:lower; 29, argument_list | def get_realnames(packages):
return sorted({get_distribution(p).project_name for p in packages},
key=lambda n: n.lower()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:build_sort; 3, parameters; 4, block; 4, 5; 4, 7; 4, 18; 4, 30; 4, 43; 5, expression_statement; 5, 6; 6, string:'''Build sort query paramter from kwargs'''; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:sorts; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:request; 14, identifier:args; 15, identifier:getlist; 16, argument_list; 16, 17; 17, string:'sort'; 18, expression_statement; 18, 19; 19, assignment; 19, 20; 19, 21; 20, identifier:sorts; 21, conditional_expression:if; 21, 22; 21, 24; 21, 29; 22, list:[sorts]; 22, 23; 23, identifier:sorts; 24, call; 24, 25; 24, 26; 25, identifier:isinstance; 26, argument_list; 26, 27; 26, 28; 27, identifier:sorts; 28, identifier:basestring; 29, identifier:sorts; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:sorts; 33, list_comprehension; 33, 34; 33, 40; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:s; 37, identifier:split; 38, argument_list; 38, 39; 39, string:' '; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:s; 42, identifier:sorts; 43, return_statement; 43, 44; 44, list_comprehension; 44, 45; 44, 51; 44, 56; 45, dictionary; 45, 46; 46, pair; 46, 47; 46, 50; 47, subscript; 47, 48; 47, 49; 48, identifier:SORTS; 49, identifier:s; 50, identifier:d; 51, for_in_clause; 51, 52; 51, 55; 52, pattern_list; 52, 53; 52, 54; 53, identifier:s; 54, identifier:d; 55, identifier:sorts; 56, if_clause; 56, 57; 57, comparison_operator:in; 57, 58; 57, 59; 58, identifier:s; 59, identifier:SORTS | def build_sort():
'''Build sort query paramter from kwargs'''
sorts = request.args.getlist('sort')
sorts = [sorts] if isinstance(sorts, basestring) else sorts
sorts = [s.split(' ') for s in sorts]
return [{SORTS[s]: d} for s, d in sorts if s in SORTS] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:transactions; 5, block; 5, 6; 6, return_statement; 6, 7; 7, subscript; 7, 8; 7, 34; 8, call; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:transactions; 11, identifier:sort; 12, argument_list; 12, 13; 13, keyword_argument; 13, 14; 13, 15; 14, identifier:key; 15, lambda; 15, 16; 15, 18; 16, lambda_parameters; 16, 17; 17, identifier:x; 18, call; 18, 19; 18, 24; 19, attribute; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:datetime; 22, identifier:datetime; 23, identifier:strptime; 24, argument_list; 24, 25; 24, 33; 25, subscript; 25, 26; 25, 32; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:x; 29, identifier:split; 30, argument_list; 30, 31; 31, string:':'; 32, integer:0; 33, string:'%Y-%m-%d'; 34, slice; 34, 35; 35, colon | def sort(transactions):
return transactions.sort(key=lambda x: datetime.datetime.strptime(x.split(':')[0], '%Y-%m-%d'))[:] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:duplicates; 3, parameters; 3, 4; 3, 5; 4, identifier:base; 5, identifier:items; 6, block; 6, 7; 7, for_statement; 7, 8; 7, 9; 7, 10; 8, identifier:item; 9, identifier:items; 10, block; 10, 11; 11, if_statement; 11, 12; 11, 26; 12, boolean_operator:and; 12, 13; 12, 19; 13, call; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:item; 16, identifier:similarity; 17, argument_list; 17, 18; 18, identifier:base; 19, not_operator; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:item; 23, identifier:equality; 24, argument_list; 24, 25; 25, identifier:base; 26, block; 26, 27; 27, expression_statement; 27, 28; 28, yield; 28, 29; 29, identifier:item | def duplicates(base, items):
for item in items:
if item.similarity(base) and not item.equality(base):
yield item |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:sort; 3, parameters; 3, 4; 3, 5; 4, identifier:base; 5, identifier:items; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:sorted; 10, argument_list; 10, 11; 10, 12; 10, 17; 11, identifier:items; 12, keyword_argument; 12, 13; 12, 14; 13, identifier:key; 14, attribute; 14, 15; 14, 16; 15, identifier:base; 16, identifier:similarity; 17, keyword_argument; 17, 18; 17, 19; 18, identifier:reverse; 19, True | def sort(base, items):
return sorted(items, key=base.similarity, reverse=True) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:Subclasses; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:cls; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 18; 11, 48; 11, 57; 11, 82; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:l; 15, call; 15, 16; 15, 17; 16, identifier:list; 17, argument_list; 18, for_statement; 18, 19; 18, 22; 18, 26; 19, pattern_list; 19, 20; 19, 21; 20, identifier:attr; 21, identifier:value; 22, call; 22, 23; 22, 24; 23, identifier:get_all_attributes; 24, argument_list; 24, 25; 25, identifier:cls; 26, block; 26, 27; 27, try_statement; 27, 28; 27, 45; 28, block; 28, 29; 29, if_statement; 29, 30; 29, 35; 30, call; 30, 31; 30, 32; 31, identifier:issubclass; 32, argument_list; 32, 33; 32, 34; 33, identifier:value; 34, identifier:Constant; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:l; 40, identifier:append; 41, argument_list; 41, 42; 42, tuple; 42, 43; 42, 44; 43, identifier:attr; 44, identifier:value; 45, except_clause; 45, 46; 46, block; 46, 47; 47, pass_statement; 48, if_statement; 48, 49; 48, 52; 49, comparison_operator:is; 49, 50; 49, 51; 50, identifier:sort_by; 51, None; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:sort_by; 56, string:"__creation_index__"; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:l; 60, call; 60, 61; 60, 62; 61, identifier:list; 62, argument_list; 62, 63; 63, call; 63, 64; 63, 65; 64, identifier:sorted; 65, argument_list; 65, 66; 65, 67; 65, 79; 66, identifier:l; 67, keyword_argument; 67, 68; 67, 69; 68, identifier:key; 69, lambda; 69, 70; 69, 72; 70, lambda_parameters; 70, 71; 71, identifier:x; 72, call; 72, 73; 72, 74; 73, identifier:getattr; 74, argument_list; 74, 75; 74, 78; 75, subscript; 75, 76; 75, 77; 76, identifier:x; 77, integer:1; 78, identifier:sort_by; 79, keyword_argument; 79, 80; 79, 81; 80, identifier:reverse; 81, identifier:reverse; 82, return_statement; 82, 83; 83, identifier:l | def Subclasses(cls, sort_by=None, reverse=False):
l = list()
for attr, value in get_all_attributes(cls):
try:
if issubclass(value, Constant):
l.append((attr, value))
except:
pass
if sort_by is None:
sort_by = "__creation_index__"
l = list(
sorted(l, key=lambda x: getattr(x[1], sort_by), reverse=reverse))
return l |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:subclasses; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort_by; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:reverse; 10, False; 11, block; 11, 12; 11, 18; 11, 47; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:l; 15, call; 15, 16; 15, 17; 16, identifier:list; 17, argument_list; 18, for_statement; 18, 19; 18, 22; 18, 29; 19, pattern_list; 19, 20; 19, 21; 20, identifier:attr; 21, identifier:_; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:Subclasses; 26, argument_list; 26, 27; 26, 28; 27, identifier:sort_by; 28, identifier:reverse; 29, block; 29, 30; 29, 38; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:value; 33, call; 33, 34; 33, 35; 34, identifier:getattr; 35, argument_list; 35, 36; 35, 37; 36, identifier:self; 37, identifier:attr; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:l; 42, identifier:append; 43, argument_list; 43, 44; 44, tuple; 44, 45; 44, 46; 45, identifier:attr; 46, identifier:value; 47, return_statement; 47, 48; 48, identifier:l | def subclasses(self, sort_by=None, reverse=False):
l = list()
for attr, _ in self.Subclasses(sort_by, reverse):
value = getattr(self, attr)
l.append((attr, value))
return l |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:organize_dir; 3, parameters; 3, 4; 4, identifier:orig_dir; 5, block; 5, 6; 5, 8; 5, 24; 5, 33; 5, 46; 5, 53; 5, 109; 5, 116; 5, 122; 5, 342; 6, expression_statement; 6, 7; 7, string:'''scans through the given directory and organizes DICOMs that look similar into subdirectories
output directory is the ``orig_dir`` with ``-sorted`` appended to the end'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:tags; 11, list:[
(0x10,0x20),
(0x8,0x21),
(0x8,0x31),
(0x8,0x103e)
]; 11, 12; 11, 15; 11, 18; 11, 21; 12, tuple; 12, 13; 12, 14; 13, integer:0x10; 14, integer:0x20; 15, tuple; 15, 16; 15, 17; 16, integer:0x8; 17, integer:0x21; 18, tuple; 18, 19; 18, 20; 19, integer:0x8; 20, integer:0x31; 21, tuple; 21, 22; 21, 23; 22, integer:0x8; 23, integer:0x103e; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:orig_dir; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:orig_dir; 30, identifier:rstrip; 31, argument_list; 31, 32; 32, string:'/'; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:files; 36, call; 36, 37; 36, 38; 37, identifier:scan_dir; 38, argument_list; 38, 39; 38, 40; 38, 43; 39, identifier:orig_dir; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:tags; 42, identifier:tags; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:md5_hash; 45, True; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:dups; 49, call; 49, 50; 49, 51; 50, identifier:find_dups; 51, argument_list; 51, 52; 52, identifier:files; 53, for_statement; 53, 54; 53, 55; 53, 56; 54, identifier:dup; 55, identifier:dups; 56, block; 56, 57; 56, 68; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:nl; 61, identifier:notify; 62, argument_list; 62, 63; 63, binary_operator:%; 63, 64; 63, 65; 64, string:'Found duplicates of %s...'; 65, subscript; 65, 66; 65, 67; 66, identifier:dup; 67, integer:0; 68, for_statement; 68, 69; 68, 70; 68, 75; 69, identifier:each_dup; 70, subscript; 70, 71; 70, 72; 71, identifier:dup; 72, slice; 72, 73; 72, 74; 73, integer:1; 74, colon; 75, block; 75, 76; 75, 85; 75, 104; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:nl; 80, identifier:notify; 81, argument_list; 81, 82; 82, binary_operator:%; 82, 83; 82, 84; 83, string:'\tdeleting %s'; 84, identifier:each_dup; 85, try_statement; 85, 86; 85, 94; 86, block; 86, 87; 87, expression_statement; 87, 88; 88, call; 88, 89; 88, 92; 89, attribute; 89, 90; 89, 91; 90, identifier:os; 91, identifier:remove; 92, argument_list; 92, 93; 93, identifier:each_dup; 94, except_clause; 94, 95; 94, 96; 95, identifier:IOError; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, call; 98, 99; 98, 102; 99, attribute; 99, 100; 99, 101; 100, identifier:nl; 101, identifier:notify; 102, argument_list; 102, 103; 103, string:'\t[failed]'; 104, delete_statement; 104, 105; 105, parenthesized_expression; 105, 106; 106, subscript; 106, 107; 106, 108; 107, identifier:files; 108, identifier:each_dup; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 112; 111, identifier:clustered; 112, call; 112, 113; 112, 114; 113, identifier:cluster_files; 114, argument_list; 114, 115; 115, identifier:files; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 118, identifier:output_dir; 119, binary_operator:%; 119, 120; 119, 121; 120, string:'%s-sorted'; 121, identifier:orig_dir; 122, for_statement; 122, 123; 122, 124; 122, 125; 123, identifier:key; 124, identifier:clustered; 125, block; 125, 126; 125, 166; 125, 189; 125, 225; 125, 237; 125, 246; 126, if_statement; 126, 127; 126, 136; 127, comparison_operator:in; 127, 128; 127, 131; 128, tuple; 128, 129; 128, 130; 129, integer:0x8; 130, integer:0x31; 131, subscript; 131, 132; 131, 135; 132, subscript; 132, 133; 132, 134; 133, identifier:clustered; 134, identifier:key; 135, string:'info'; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 148; 139, subscript; 139, 140; 139, 145; 140, subscript; 140, 141; 140, 144; 141, subscript; 141, 142; 141, 143; 142, identifier:clustered; 143, identifier:key; 144, string:'info'; 145, tuple; 145, 146; 145, 147; 146, integer:0x8; 147, integer:0x31; 148, call; 148, 149; 148, 150; 149, identifier:str; 150, argument_list; 150, 151; 151, call; 151, 152; 151, 153; 152, identifier:int; 153, argument_list; 153, 154; 154, call; 154, 155; 154, 156; 155, identifier:float; 156, argument_list; 156, 157; 157, subscript; 157, 158; 157, 163; 158, subscript; 158, 159; 158, 162; 159, subscript; 159, 160; 159, 161; 160, identifier:clustered; 161, identifier:key; 162, string:'info'; 163, tuple; 163, 164; 163, 165; 164, integer:0x8; 165, integer:0x31; 166, for_statement; 166, 167; 166, 168; 166, 169; 167, identifier:t; 168, identifier:tags; 169, block; 169, 170; 170, if_statement; 170, 171; 170, 178; 171, comparison_operator:not; 171, 172; 171, 173; 172, identifier:t; 173, subscript; 173, 174; 173, 177; 174, subscript; 174, 175; 174, 176; 175, identifier:clustered; 176, identifier:key; 177, string:'info'; 178, block; 178, 179; 179, expression_statement; 179, 180; 180, assignment; 180, 181; 180, 188; 181, subscript; 181, 182; 181, 187; 182, subscript; 182, 183; 182, 186; 183, subscript; 183, 184; 183, 185; 184, identifier:clustered; 185, identifier:key; 186, string:'info'; 187, identifier:t; 188, string:'_'; 189, expression_statement; 189, 190; 190, assignment; 190, 191; 190, 192; 191, identifier:run_name; 192, binary_operator:+; 192, 193; 192, 215; 193, call; 193, 194; 193, 197; 194, attribute; 194, 195; 194, 196; 195, string:'-'; 196, identifier:join; 197, argument_list; 197, 198; 198, list_comprehension; 198, 199; 198, 212; 199, call; 199, 200; 199, 201; 200, identifier:scrub_fname; 201, argument_list; 201, 202; 202, call; 202, 203; 202, 204; 203, identifier:str; 204, argument_list; 204, 205; 205, subscript; 205, 206; 205, 211; 206, subscript; 206, 207; 206, 210; 207, subscript; 207, 208; 207, 209; 208, identifier:clustered; 209, identifier:key; 210, string:'info'; 211, identifier:x; 212, for_in_clause; 212, 213; 212, 214; 213, identifier:x; 214, identifier:tags; 215, binary_operator:%; 215, 216; 215, 217; 216, string:'-%d_images'; 217, call; 217, 218; 217, 219; 218, identifier:len; 219, argument_list; 219, 220; 220, subscript; 220, 221; 220, 224; 221, subscript; 221, 222; 221, 223; 222, identifier:clustered; 223, identifier:key; 224, string:'files'; 225, expression_statement; 225, 226; 226, assignment; 226, 227; 226, 228; 227, identifier:run_dir; 228, call; 228, 229; 228, 234; 229, attribute; 229, 230; 229, 233; 230, attribute; 230, 231; 230, 232; 231, identifier:os; 232, identifier:path; 233, identifier:join; 234, argument_list; 234, 235; 234, 236; 235, identifier:output_dir; 236, identifier:run_name; 237, expression_statement; 237, 238; 238, call; 238, 239; 238, 242; 239, attribute; 239, 240; 239, 241; 240, identifier:nl; 241, identifier:notify; 242, argument_list; 242, 243; 243, binary_operator:%; 243, 244; 243, 245; 244, string:'Moving files into %s'; 245, identifier:run_dir; 246, try_statement; 246, 247; 246, 266; 246, 278; 247, block; 247, 248; 248, if_statement; 248, 249; 248, 258; 249, not_operator; 249, 250; 250, call; 250, 251; 250, 256; 251, attribute; 251, 252; 251, 255; 252, attribute; 252, 253; 252, 254; 253, identifier:os; 254, identifier:path; 255, identifier:exists; 256, argument_list; 256, 257; 257, identifier:run_dir; 258, block; 258, 259; 259, expression_statement; 259, 260; 260, call; 260, 261; 260, 264; 261, attribute; 261, 262; 261, 263; 262, identifier:os; 263, identifier:makedirs; 264, argument_list; 264, 265; 265, identifier:run_dir; 266, except_clause; 266, 267; 266, 268; 267, identifier:IOError; 268, block; 268, 269; 269, expression_statement; 269, 270; 270, call; 270, 271; 270, 274; 271, attribute; 271, 272; 271, 273; 272, identifier:nl; 273, identifier:notify; 274, argument_list; 274, 275; 275, binary_operator:%; 275, 276; 275, 277; 276, string:'Error: failed to create directory %s'; 277, identifier:run_dir; 278, else_clause; 278, 279; 279, block; 279, 280; 280, for_statement; 280, 281; 280, 282; 280, 287; 281, identifier:f; 282, subscript; 282, 283; 282, 286; 283, subscript; 283, 284; 283, 285; 284, identifier:clustered; 285, identifier:key; 286, string:'files'; 287, block; 287, 288; 288, try_statement; 288, 289; 288, 336; 289, block; 289, 290; 289, 303; 289, 320; 290, expression_statement; 290, 291; 291, assignment; 291, 292; 291, 293; 292, identifier:dset_fname; 293, subscript; 293, 294; 293, 302; 294, call; 294, 295; 294, 300; 295, attribute; 295, 296; 295, 299; 296, attribute; 296, 297; 296, 298; 297, identifier:os; 298, identifier:path; 299, identifier:split; 300, argument_list; 300, 301; 301, identifier:f; 302, integer:1; 303, if_statement; 303, 304; 303, 309; 304, comparison_operator:==; 304, 305; 304, 308; 305, subscript; 305, 306; 305, 307; 306, identifier:dset_fname; 307, integer:0; 308, string:'.'; 309, block; 309, 310; 310, expression_statement; 310, 311; 311, assignment; 311, 312; 311, 313; 312, identifier:dset_fname; 313, binary_operator:+; 313, 314; 313, 315; 314, string:'_'; 315, subscript; 315, 316; 315, 317; 316, identifier:dset_fname; 317, slice; 317, 318; 317, 319; 318, integer:1; 319, colon; 320, expression_statement; 320, 321; 321, call; 321, 322; 321, 325; 322, attribute; 322, 323; 322, 324; 323, identifier:os; 324, identifier:rename; 325, argument_list; 325, 326; 325, 327; 326, identifier:f; 327, call; 327, 328; 327, 333; 328, attribute; 328, 329; 328, 332; 329, attribute; 329, 330; 329, 331; 330, identifier:os; 331, identifier:path; 332, identifier:join; 333, argument_list; 333, 334; 333, 335; 334, identifier:run_dir; 335, identifier:dset_fname; 336, except_clause; 336, 337; 336, 340; 337, tuple; 337, 338; 337, 339; 338, identifier:IOError; 339, identifier:OSError; 340, block; 340, 341; 341, pass_statement; 342, for_statement; 342, 343; 342, 347; 342, 356; 343, pattern_list; 343, 344; 343, 345; 343, 346; 344, identifier:r; 345, identifier:ds; 346, identifier:fs; 347, call; 347, 348; 347, 351; 348, attribute; 348, 349; 348, 350; 349, identifier:os; 350, identifier:walk; 351, argument_list; 351, 352; 351, 353; 352, identifier:output_dir; 353, keyword_argument; 353, 354; 353, 355; 354, identifier:topdown; 355, False; 356, block; 356, 357; 357, for_statement; 357, 358; 357, 359; 357, 360; 358, identifier:d; 359, identifier:ds; 360, block; 360, 361; 360, 373; 361, expression_statement; 361, 362; 362, assignment; 362, 363; 362, 364; 363, identifier:dname; 364, call; 364, 365; 364, 370; 365, attribute; 365, 366; 365, 369; 366, attribute; 366, 367; 366, 368; 367, identifier:os; 368, identifier:path; 369, identifier:join; 370, argument_list; 370, 371; 370, 372; 371, identifier:r; 372, identifier:d; 373, if_statement; 373, 374; 373, 385; 374, comparison_operator:==; 374, 375; 374, 384; 375, call; 375, 376; 375, 377; 376, identifier:len; 377, argument_list; 377, 378; 378, call; 378, 379; 378, 382; 379, attribute; 379, 380; 379, 381; 380, identifier:os; 381, identifier:listdir; 382, argument_list; 382, 383; 383, identifier:dname; 384, integer:0; 385, block; 385, 386; 386, expression_statement; 386, 387; 387, call; 387, 388; 387, 391; 388, attribute; 388, 389; 388, 390; 389, identifier:os; 390, identifier:remove; 391, argument_list; 391, 392; 392, identifier:dname | def organize_dir(orig_dir):
'''scans through the given directory and organizes DICOMs that look similar into subdirectories
output directory is the ``orig_dir`` with ``-sorted`` appended to the end'''
tags = [
(0x10,0x20),
(0x8,0x21),
(0x8,0x31),
(0x8,0x103e)
]
orig_dir = orig_dir.rstrip('/')
files = scan_dir(orig_dir,tags=tags,md5_hash=True)
dups = find_dups(files)
for dup in dups:
nl.notify('Found duplicates of %s...' % dup[0])
for each_dup in dup[1:]:
nl.notify('\tdeleting %s' % each_dup)
try:
os.remove(each_dup)
except IOError:
nl.notify('\t[failed]')
del(files[each_dup])
clustered = cluster_files(files)
output_dir = '%s-sorted' % orig_dir
for key in clustered:
if (0x8,0x31) in clustered[key]['info']:
clustered[key]['info'][(0x8,0x31)] = str(int(float(clustered[key]['info'][(0x8,0x31)])))
for t in tags:
if t not in clustered[key]['info']:
clustered[key]['info'][t] = '_'
run_name = '-'.join([scrub_fname(str(clustered[key]['info'][x])) for x in tags])+'-%d_images' %len(clustered[key]['files'])
run_dir = os.path.join(output_dir,run_name)
nl.notify('Moving files into %s' % run_dir)
try:
if not os.path.exists(run_dir):
os.makedirs(run_dir)
except IOError:
nl.notify('Error: failed to create directory %s' % run_dir)
else:
for f in clustered[key]['files']:
try:
dset_fname = os.path.split(f)[1]
if dset_fname[0]=='.':
dset_fname = '_' + dset_fname[1:]
os.rename(f,os.path.join(run_dir,dset_fname))
except (IOError, OSError):
pass
for r,ds,fs in os.walk(output_dir,topdown=False):
for d in ds:
dname = os.path.join(r,d)
if len(os.listdir(dname))==0:
os.remove(dname) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:reconstruct_files; 3, parameters; 3, 4; 4, identifier:input_dir; 5, block; 5, 6; 5, 8; 5, 17; 6, expression_statement; 6, 7; 7, string:'''sorts ``input_dir`` and tries to reconstruct the subdirectories found'''; 8, expression_statement; 8, 9; 9, assignment; 9, 10; 9, 11; 10, identifier:input_dir; 11, call; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:input_dir; 14, identifier:rstrip; 15, argument_list; 15, 16; 16, string:'/'; 17, with_statement; 17, 18; 17, 26; 18, with_clause; 18, 19; 19, with_item; 19, 20; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:nl; 23, identifier:notify; 24, argument_list; 24, 25; 25, string:'Attempting to organize/reconstruct directory'; 26, block; 26, 27; 26, 76; 26, 85; 26, 91; 27, for_statement; 27, 28; 27, 32; 27, 38; 28, pattern_list; 28, 29; 28, 30; 28, 31; 29, identifier:r; 30, identifier:ds; 31, identifier:fs; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:os; 35, identifier:walk; 36, argument_list; 36, 37; 37, identifier:input_dir; 38, block; 38, 39; 39, for_statement; 39, 40; 39, 41; 39, 42; 40, identifier:f; 41, identifier:fs; 42, block; 42, 43; 43, if_statement; 43, 44; 43, 49; 44, comparison_operator:==; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:f; 47, integer:0; 48, string:'.'; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:shutil; 54, identifier:move; 55, argument_list; 55, 56; 55, 65; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:os; 60, identifier:path; 61, identifier:join; 62, argument_list; 62, 63; 62, 64; 63, identifier:r; 64, identifier:f; 65, call; 65, 66; 65, 71; 66, attribute; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:os; 69, identifier:path; 70, identifier:join; 71, argument_list; 71, 72; 71, 73; 72, identifier:r; 73, binary_operator:+; 73, 74; 73, 75; 74, string:'i'; 75, identifier:f; 76, expression_statement; 76, 77; 77, call; 77, 78; 77, 83; 78, attribute; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:nl; 81, identifier:dicom; 82, identifier:organize_dir; 83, argument_list; 83, 84; 84, identifier:input_dir; 85, expression_statement; 85, 86; 86, assignment; 86, 87; 86, 88; 87, identifier:output_dir; 88, binary_operator:%; 88, 89; 88, 90; 89, string:'%s-sorted'; 90, identifier:input_dir; 91, if_statement; 91, 92; 91, 100; 91, 141; 92, call; 92, 93; 92, 98; 93, attribute; 93, 94; 93, 97; 94, attribute; 94, 95; 94, 96; 95, identifier:os; 96, identifier:path; 97, identifier:exists; 98, argument_list; 98, 99; 99, identifier:output_dir; 100, block; 100, 101; 101, with_statement; 101, 102; 101, 110; 102, with_clause; 102, 103; 103, with_item; 103, 104; 104, call; 104, 105; 104, 108; 105, attribute; 105, 106; 105, 107; 106, identifier:nl; 107, identifier:run_in; 108, argument_list; 108, 109; 109, identifier:output_dir; 110, block; 110, 111; 111, for_statement; 111, 112; 111, 113; 111, 119; 112, identifier:dset_dir; 113, call; 113, 114; 113, 117; 114, attribute; 114, 115; 114, 116; 115, identifier:os; 116, identifier:listdir; 117, argument_list; 117, 118; 118, string:'.'; 119, block; 119, 120; 120, with_statement; 120, 121; 120, 131; 121, with_clause; 121, 122; 122, with_item; 122, 123; 123, call; 123, 124; 123, 127; 124, attribute; 124, 125; 124, 126; 125, identifier:nl; 126, identifier:notify; 127, argument_list; 127, 128; 128, binary_operator:%; 128, 129; 128, 130; 129, string:'creating dataset from %s'; 130, identifier:dset_dir; 131, block; 131, 132; 132, expression_statement; 132, 133; 133, call; 133, 134; 133, 139; 134, attribute; 134, 135; 134, 138; 135, attribute; 135, 136; 135, 137; 136, identifier:nl; 137, identifier:dicom; 138, identifier:create_dset; 139, argument_list; 139, 140; 140, identifier:dset_dir; 141, else_clause; 141, 142; 142, block; 142, 143; 143, expression_statement; 143, 144; 144, call; 144, 145; 144, 148; 145, attribute; 145, 146; 145, 147; 146, identifier:nl; 147, identifier:notify; 148, argument_list; 148, 149; 148, 152; 149, binary_operator:%; 149, 150; 149, 151; 150, string:'Warning: failed to auto-organize directory %s'; 151, identifier:input_dir; 152, keyword_argument; 152, 153; 152, 154; 153, identifier:level; 154, attribute; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:nl; 157, identifier:level; 158, identifier:warning | def reconstruct_files(input_dir):
'''sorts ``input_dir`` and tries to reconstruct the subdirectories found'''
input_dir = input_dir.rstrip('/')
with nl.notify('Attempting to organize/reconstruct directory'):
for r,ds,fs in os.walk(input_dir):
for f in fs:
if f[0]=='.':
shutil.move(os.path.join(r,f),os.path.join(r,'i'+f))
nl.dicom.organize_dir(input_dir)
output_dir = '%s-sorted' % input_dir
if os.path.exists(output_dir):
with nl.run_in(output_dir):
for dset_dir in os.listdir('.'):
with nl.notify('creating dataset from %s' % dset_dir):
nl.dicom.create_dset(dset_dir)
else:
nl.notify('Warning: failed to auto-organize directory %s' % input_dir,level=nl.level.warning) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:lint; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:targets; 6, block; 6, 7; 6, 13; 6, 23; 6, 45; 6, 57; 6, 67; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:LinterRunner; 11, identifier:targets; 12, identifier:targets; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:linters; 16, call; 16, 17; 16, 22; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:_config; 21, identifier:get_linter_classes; 22, argument_list; 23, with_statement; 23, 24; 23, 32; 24, with_clause; 24, 25; 25, with_item; 25, 26; 26, as_pattern; 26, 27; 26, 30; 27, call; 27, 28; 27, 29; 28, identifier:Pool; 29, argument_list; 30, as_pattern_target; 30, 31; 31, identifier:pool; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, assignment; 34, 35; 34, 36; 35, identifier:out_err_none; 36, call; 36, 37; 36, 40; 37, attribute; 37, 38; 37, 39; 38, identifier:pool; 39, identifier:map; 40, argument_list; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:LinterRunner; 43, identifier:run; 44, identifier:linters; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:out_err; 48, list_comprehension; 48, 49; 48, 50; 48, 53; 49, identifier:item; 50, for_in_clause; 50, 51; 50, 52; 51, identifier:item; 52, identifier:out_err_none; 53, if_clause; 53, 54; 54, comparison_operator:is; 54, 55; 54, 56; 55, identifier:item; 56, None; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 62; 59, pattern_list; 59, 60; 59, 61; 60, identifier:stdout; 61, identifier:stderr; 62, call; 62, 63; 62, 64; 63, identifier:zip; 64, argument_list; 64, 65; 65, list_splat; 65, 66; 66, identifier:out_err; 67, return_statement; 67, 68; 68, expression_list; 68, 69; 68, 78; 69, call; 69, 70; 69, 71; 70, identifier:sorted; 71, argument_list; 71, 72; 72, call; 72, 73; 72, 76; 73, attribute; 73, 74; 73, 75; 74, identifier:chain; 75, identifier:from_iterable; 76, argument_list; 76, 77; 77, identifier:stdout; 78, call; 78, 79; 78, 82; 79, attribute; 79, 80; 79, 81; 80, identifier:chain; 81, identifier:from_iterable; 82, argument_list; 82, 83; 83, identifier:stderr | def lint(self, targets):
LinterRunner.targets = targets
linters = self._config.get_linter_classes()
with Pool() as pool:
out_err_none = pool.map(LinterRunner.run, linters)
out_err = [item for item in out_err_none if item is not None]
stdout, stderr = zip(*out_err)
return sorted(chain.from_iterable(stdout)), chain.from_iterable(stderr) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:_linear_interp; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:curve; 5, identifier:test_x; 6, default_parameter; 6, 7; 6, 8; 7, identifier:round_result; 8, False; 9, block; 9, 10; 9, 14; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:index; 13, integer:0; 14, for_statement; 14, 15; 14, 16; 14, 25; 14, 146; 15, identifier:index; 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:curve; 24, integer:1; 25, block; 25, 26; 25, 42; 26, if_statement; 26, 27; 26, 40; 27, comparison_operator:==; 27, 28; 27, 33; 28, subscript; 28, 29; 28, 32; 29, subscript; 29, 30; 29, 31; 30, identifier:curve; 31, identifier:index; 32, integer:0; 33, subscript; 33, 34; 33, 39; 34, subscript; 34, 35; 34, 36; 35, identifier:curve; 36, binary_operator:+; 36, 37; 36, 38; 37, identifier:index; 38, integer:1; 39, integer:0; 40, block; 40, 41; 41, continue_statement; 42, if_statement; 42, 43; 42, 57; 43, comparison_operator:<=; 43, 44; 43, 49; 43, 50; 44, subscript; 44, 45; 44, 48; 45, subscript; 45, 46; 45, 47; 46, identifier:curve; 47, identifier:index; 48, integer:0; 49, identifier:test_x; 50, subscript; 50, 51; 50, 56; 51, subscript; 51, 52; 51, 53; 52, identifier:curve; 53, binary_operator:+; 53, 54; 53, 55; 54, identifier:index; 55, integer:1; 56, integer:0; 57, block; 57, 58; 57, 91; 57, 108; 57, 117; 58, expression_statement; 58, 59; 59, assignment; 59, 60; 59, 61; 60, identifier:slope; 61, parenthesized_expression; 61, 62; 62, binary_operator:/; 62, 63; 62, 77; 63, parenthesized_expression; 63, 64; 64, binary_operator:-; 64, 65; 64, 72; 65, subscript; 65, 66; 65, 71; 66, subscript; 66, 67; 66, 68; 67, identifier:curve; 68, binary_operator:+; 68, 69; 68, 70; 69, identifier:index; 70, integer:1; 71, integer:1; 72, subscript; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:curve; 75, identifier:index; 76, integer:1; 77, parenthesized_expression; 77, 78; 78, binary_operator:-; 78, 79; 78, 86; 79, subscript; 79, 80; 79, 85; 80, subscript; 80, 81; 80, 82; 81, identifier:curve; 82, binary_operator:+; 82, 83; 82, 84; 83, identifier:index; 84, integer:1; 85, integer:0; 86, subscript; 86, 87; 86, 90; 87, subscript; 87, 88; 87, 89; 88, identifier:curve; 89, identifier:index; 90, integer:0; 91, expression_statement; 91, 92; 92, assignment; 92, 93; 92, 94; 93, identifier:y_intercept; 94, binary_operator:-; 94, 95; 94, 100; 95, subscript; 95, 96; 95, 99; 96, subscript; 96, 97; 96, 98; 97, identifier:curve; 98, identifier:index; 99, integer:1; 100, parenthesized_expression; 100, 101; 101, binary_operator:*; 101, 102; 101, 103; 102, identifier:slope; 103, subscript; 103, 104; 103, 107; 104, subscript; 104, 105; 104, 106; 105, identifier:curve; 106, identifier:index; 107, integer:0; 108, expression_statement; 108, 109; 109, assignment; 109, 110; 109, 111; 110, identifier:result; 111, binary_operator:+; 111, 112; 111, 116; 112, parenthesized_expression; 112, 113; 113, binary_operator:*; 113, 114; 113, 115; 114, identifier:slope; 115, identifier:test_x; 116, identifier:y_intercept; 117, if_statement; 117, 118; 117, 119; 117, 128; 118, identifier:round_result; 119, block; 119, 120; 120, return_statement; 120, 121; 121, call; 121, 122; 121, 123; 122, identifier:int; 123, argument_list; 123, 124; 124, call; 124, 125; 124, 126; 125, identifier:round; 126, argument_list; 126, 127; 127, identifier:result; 128, else_clause; 128, 129; 129, block; 129, 130; 130, if_statement; 130, 131; 130, 136; 130, 142; 131, call; 131, 132; 131, 135; 132, attribute; 132, 133; 132, 134; 133, identifier:result; 134, identifier:is_integer; 135, argument_list; 136, block; 136, 137; 137, return_statement; 137, 138; 138, call; 138, 139; 138, 140; 139, identifier:int; 140, argument_list; 140, 141; 141, identifier:result; 142, else_clause; 142, 143; 143, block; 143, 144; 144, return_statement; 144, 145; 145, identifier:result; 146, else_clause; 146, 147; 147, block; 147, 148; 148, raise_statement; 148, 149; 149, identifier:ProbabilityUndefinedError | def _linear_interp(curve, test_x, round_result=False):
index = 0
for index in range(len(curve) - 1):
if curve[index][0] == curve[index + 1][0]:
continue
if curve[index][0] <= test_x <= curve[index + 1][0]:
slope = ((curve[index + 1][1] - curve[index][1]) /
(curve[index + 1][0] - curve[index][0]))
y_intercept = curve[index][1] - (slope * curve[index][0])
result = (slope * test_x) + y_intercept
if round_result:
return int(round(result))
else:
if result.is_integer():
return int(result)
else:
return result
else:
raise ProbabilityUndefinedError |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:bound_weights; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:weights; 5, default_parameter; 5, 6; 5, 7; 6, identifier:minimum; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:maximum; 10, None; 11, block; 11, 12; 11, 19; 11, 92; 11, 128; 11, 166; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:bounded_weights; 15, subscript; 15, 16; 15, 17; 16, identifier:weights; 17, slice; 17, 18; 18, colon; 19, if_statement; 19, 20; 19, 27; 19, 50; 19, 69; 19, 88; 20, boolean_operator:and; 20, 21; 20, 24; 21, comparison_operator:is; 21, 22; 21, 23; 22, identifier:minimum; 23, None; 24, comparison_operator:is; 24, 25; 24, 26; 25, identifier:maximum; 26, None; 27, block; 27, 28; 27, 35; 28, if_statement; 28, 29; 28, 32; 29, comparison_operator:<; 29, 30; 29, 31; 30, identifier:maximum; 31, identifier:minimum; 32, block; 32, 33; 33, raise_statement; 33, 34; 34, identifier:ValueError; 35, expression_statement; 35, 36; 36, assignment; 36, 37; 36, 38; 37, identifier:bounded_weights; 38, list_comprehension; 38, 39; 38, 40; 38, 43; 39, identifier:bw; 40, for_in_clause; 40, 41; 40, 42; 41, identifier:bw; 42, identifier:bounded_weights; 43, if_clause; 43, 44; 44, comparison_operator:<=; 44, 45; 44, 46; 44, 49; 45, identifier:minimum; 46, subscript; 46, 47; 46, 48; 47, identifier:bw; 48, integer:0; 49, identifier:maximum; 50, elif_clause; 50, 51; 50, 54; 51, comparison_operator:is; 51, 52; 51, 53; 52, identifier:minimum; 53, None; 54, block; 54, 55; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:bounded_weights; 58, list_comprehension; 58, 59; 58, 60; 58, 63; 59, identifier:bw; 60, for_in_clause; 60, 61; 60, 62; 61, identifier:bw; 62, identifier:bounded_weights; 63, if_clause; 63, 64; 64, comparison_operator:<=; 64, 65; 64, 66; 65, identifier:minimum; 66, subscript; 66, 67; 66, 68; 67, identifier:bw; 68, integer:0; 69, elif_clause; 69, 70; 69, 73; 70, comparison_operator:is; 70, 71; 70, 72; 71, identifier:maximum; 72, None; 73, block; 73, 74; 74, expression_statement; 74, 75; 75, assignment; 75, 76; 75, 77; 76, identifier:bounded_weights; 77, list_comprehension; 77, 78; 77, 79; 77, 82; 78, identifier:bw; 79, for_in_clause; 79, 80; 79, 81; 80, identifier:bw; 81, identifier:bounded_weights; 82, if_clause; 82, 83; 83, comparison_operator:<=; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:bw; 86, integer:0; 87, identifier:maximum; 88, else_clause; 88, 89; 89, block; 89, 90; 90, return_statement; 90, 91; 91, identifier:bounded_weights; 92, if_statement; 92, 93; 92, 113; 93, parenthesized_expression; 93, 94; 94, boolean_operator:and; 94, 95; 94, 106; 95, comparison_operator:>; 95, 96; 95, 101; 96, subscript; 96, 97; 96, 100; 97, subscript; 97, 98; 97, 99; 98, identifier:bounded_weights; 99, integer:0; 100, integer:0; 101, subscript; 101, 102; 101, 105; 102, subscript; 102, 103; 102, 104; 103, identifier:weights; 104, integer:0; 105, integer:0; 106, comparison_operator:!=; 106, 107; 106, 112; 107, subscript; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:bounded_weights; 110, integer:0; 111, integer:0; 112, identifier:minimum; 113, block; 113, 114; 114, expression_statement; 114, 115; 115, call; 115, 116; 115, 119; 116, attribute; 116, 117; 116, 118; 117, identifier:bounded_weights; 118, identifier:insert; 119, argument_list; 119, 120; 119, 121; 120, integer:0; 121, tuple; 121, 122; 121, 123; 122, identifier:minimum; 123, call; 123, 124; 123, 125; 124, identifier:_linear_interp; 125, argument_list; 125, 126; 125, 127; 126, identifier:weights; 127, identifier:minimum; 128, if_statement; 128, 129; 128, 152; 129, parenthesized_expression; 129, 130; 130, boolean_operator:and; 130, 131; 130, 144; 131, comparison_operator:<; 131, 132; 131, 138; 132, subscript; 132, 133; 132, 137; 133, subscript; 133, 134; 133, 135; 134, identifier:bounded_weights; 135, unary_operator:-; 135, 136; 136, integer:1; 137, integer:0; 138, subscript; 138, 139; 138, 143; 139, subscript; 139, 140; 139, 141; 140, identifier:weights; 141, unary_operator:-; 141, 142; 142, integer:1; 143, integer:0; 144, comparison_operator:!=; 144, 145; 144, 151; 145, subscript; 145, 146; 145, 150; 146, subscript; 146, 147; 146, 148; 147, identifier:bounded_weights; 148, unary_operator:-; 148, 149; 149, integer:1; 150, integer:0; 151, identifier:maximum; 152, block; 152, 153; 153, expression_statement; 153, 154; 154, call; 154, 155; 154, 158; 155, attribute; 155, 156; 155, 157; 156, identifier:bounded_weights; 157, identifier:append; 158, argument_list; 158, 159; 159, tuple; 159, 160; 159, 161; 160, identifier:maximum; 161, call; 161, 162; 161, 163; 162, identifier:_linear_interp; 163, argument_list; 163, 164; 163, 165; 164, identifier:weights; 165, identifier:maximum; 166, return_statement; 166, 167; 167, identifier:bounded_weights | def bound_weights(weights, minimum=None, maximum=None):
bounded_weights = weights[:]
if minimum is not None and maximum is not None:
if maximum < minimum:
raise ValueError
bounded_weights = [bw for bw in bounded_weights
if minimum <= bw[0] <= maximum]
elif minimum is not None:
bounded_weights = [bw for bw in bounded_weights
if minimum <= bw[0]]
elif maximum is not None:
bounded_weights = [bw for bw in bounded_weights
if bw[0] <= maximum]
else:
return bounded_weights
if (bounded_weights[0][0] > weights[0][0] and
bounded_weights[0][0] != minimum):
bounded_weights.insert(0, (minimum, _linear_interp(weights, minimum)))
if (bounded_weights[-1][0] < weights[-1][0] and
bounded_weights[-1][0] != maximum):
bounded_weights.append((maximum, _linear_interp(weights, maximum)))
return bounded_weights |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:weighted_rand; 3, parameters; 3, 4; 3, 5; 4, identifier:weights; 5, default_parameter; 5, 6; 5, 7; 6, identifier:round_result; 7, False; 8, block; 8, 9; 8, 23; 8, 38; 8, 46; 8, 55; 8, 59; 8, 72; 8, 76; 9, if_statement; 9, 10; 9, 16; 10, comparison_operator:==; 10, 11; 10, 15; 11, call; 11, 12; 11, 13; 12, identifier:len; 13, argument_list; 13, 14; 14, identifier:weights; 15, integer:1; 16, block; 16, 17; 17, return_statement; 17, 18; 18, subscript; 18, 19; 18, 22; 19, subscript; 19, 20; 19, 21; 20, identifier:weights; 21, integer:0; 22, integer:0; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:weights; 26, call; 26, 27; 26, 28; 27, identifier:sorted; 28, argument_list; 28, 29; 28, 30; 29, identifier:weights; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:key; 32, lambda; 32, 33; 32, 35; 33, lambda_parameters; 33, 34; 34, identifier:w; 35, subscript; 35, 36; 35, 37; 36, identifier:w; 37, integer:0; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:x_min; 41, subscript; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:weights; 44, integer:0; 45, integer:0; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:x_max; 49, subscript; 49, 50; 49, 54; 50, subscript; 50, 51; 50, 52; 51, identifier:weights; 52, unary_operator:-; 52, 53; 53, integer:1; 54, integer:0; 55, expression_statement; 55, 56; 56, assignment; 56, 57; 56, 58; 57, identifier:y_min; 58, integer:0; 59, expression_statement; 59, 60; 60, assignment; 60, 61; 60, 62; 61, identifier:y_max; 62, call; 62, 63; 62, 64; 63, identifier:max; 64, argument_list; 64, 65; 65, list_comprehension; 65, 66; 65, 69; 66, subscript; 66, 67; 66, 68; 67, identifier:point; 68, integer:1; 69, for_in_clause; 69, 70; 69, 71; 70, identifier:point; 71, identifier:weights; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:attempt_count; 75, integer:0; 76, while_statement; 76, 77; 76, 80; 76, 129; 77, comparison_operator:<; 77, 78; 77, 79; 78, identifier:attempt_count; 79, integer:500000; 80, block; 80, 81; 80, 99; 80, 125; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:sample; 84, tuple; 84, 85; 84, 92; 85, call; 85, 86; 85, 89; 86, attribute; 86, 87; 86, 88; 87, identifier:random; 88, identifier:uniform; 89, argument_list; 89, 90; 89, 91; 90, identifier:x_min; 91, identifier:x_max; 92, call; 92, 93; 92, 96; 93, attribute; 93, 94; 93, 95; 94, identifier:random; 95, identifier:uniform; 96, argument_list; 96, 97; 96, 98; 97, identifier:y_min; 98, identifier:y_max; 99, if_statement; 99, 100; 99, 105; 100, call; 100, 101; 100, 102; 101, identifier:_point_under_curve; 102, argument_list; 102, 103; 102, 104; 103, identifier:weights; 104, identifier:sample; 105, block; 105, 106; 106, if_statement; 106, 107; 106, 108; 106, 119; 107, identifier:round_result; 108, block; 108, 109; 109, return_statement; 109, 110; 110, call; 110, 111; 110, 112; 111, identifier:int; 112, argument_list; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:round; 115, argument_list; 115, 116; 116, subscript; 116, 117; 116, 118; 117, identifier:sample; 118, integer:0; 119, else_clause; 119, 120; 120, block; 120, 121; 121, return_statement; 121, 122; 122, subscript; 122, 123; 122, 124; 123, identifier:sample; 124, integer:0; 125, expression_statement; 125, 126; 126, augmented_assignment:+=; 126, 127; 126, 128; 127, identifier:attempt_count; 128, integer:1; 129, else_clause; 129, 130; 130, block; 130, 131; 130, 141; 131, expression_statement; 131, 132; 132, call; 132, 133; 132, 136; 133, attribute; 133, 134; 133, 135; 134, identifier:warnings; 135, identifier:warn; 136, argument_list; 136, 137; 137, concatenated_string; 137, 138; 137, 139; 137, 140; 138, string:'Point not being found in weighted_rand() after 500000 '; 139, string:'attempts, defaulting to a random weight point. '; 140, string:'If this happens often, it is probably a bug.'; 141, return_statement; 141, 142; 142, subscript; 142, 143; 142, 149; 143, call; 143, 144; 143, 147; 144, attribute; 144, 145; 144, 146; 145, identifier:random; 146, identifier:choice; 147, argument_list; 147, 148; 148, identifier:weights; 149, integer:0 | def weighted_rand(weights, round_result=False):
if len(weights) == 1:
return weights[0][0]
weights = sorted(weights, key=lambda w: w[0])
x_min = weights[0][0]
x_max = weights[-1][0]
y_min = 0
y_max = max([point[1] for point in weights])
attempt_count = 0
while attempt_count < 500000:
sample = (random.uniform(x_min, x_max), random.uniform(y_min, y_max))
if _point_under_curve(weights, sample):
if round_result:
return int(round(sample[0]))
else:
return sample[0]
attempt_count += 1
else:
warnings.warn(
'Point not being found in weighted_rand() after 500000 '
'attempts, defaulting to a random weight point. '
'If this happens often, it is probably a bug.')
return random.choice(weights)[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:_cmp_key; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:obj; 7, None; 8, block; 8, 9; 8, 17; 8, 31; 8, 45; 9, if_statement; 9, 10; 9, 12; 10, not_operator; 10, 11; 11, identifier:obj; 12, block; 12, 13; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:obj; 16, identifier:self; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:line_nr; 20, conditional_expression:if; 20, 21; 20, 27; 20, 30; 21, call; 21, 22; 21, 23; 22, identifier:int; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:obj; 26, identifier:line_nr; 27, attribute; 27, 28; 27, 29; 28, identifier:obj; 29, identifier:line_nr; 30, integer:0; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:col; 34, conditional_expression:if; 34, 35; 34, 41; 34, 44; 35, call; 35, 36; 35, 37; 36, identifier:int; 37, argument_list; 37, 38; 38, attribute; 38, 39; 38, 40; 39, identifier:obj; 40, identifier:col; 41, attribute; 41, 42; 41, 43; 42, identifier:obj; 43, identifier:col; 44, integer:0; 45, return_statement; 45, 46; 46, tuple; 46, 47; 46, 50; 46, 51; 46, 52; 47, attribute; 47, 48; 47, 49; 48, identifier:obj; 49, identifier:path; 50, identifier:line_nr; 51, identifier:col; 52, attribute; 52, 53; 52, 54; 53, identifier:obj; 54, identifier:msg | def _cmp_key(self, obj=None):
if not obj:
obj = self
line_nr = int(obj.line_nr) if obj.line_nr else 0
col = int(obj.col) if obj.col else 0
return (obj.path, line_nr, col, obj.msg) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_create_output_from_match; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:match_result; 6, block; 6, 7; 6, 13; 6, 22; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:full_path; 10, subscript; 10, 11; 10, 12; 11, identifier:match_result; 12, string:'full_path'; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:path; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:self; 19, identifier:_get_relative_path; 20, argument_list; 20, 21; 21, identifier:full_path; 22, return_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:LinterOutput; 25, argument_list; 25, 26; 25, 29; 25, 30; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:name; 29, identifier:path; 30, subscript; 30, 31; 30, 32; 31, identifier:match_result; 32, string:'msg' | def _create_output_from_match(self, match_result):
full_path = match_result['full_path']
path = self._get_relative_path(full_path)
return LinterOutput(self.name, path, match_result['msg']) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:get_cached_filename; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 7; 4, identifier:self; 5, identifier:filename; 6, identifier:extention; 7, default_parameter; 7, 8; 7, 9; 8, identifier:settings_list; 9, None; 10, block; 10, 11; 10, 26; 11, expression_statement; 11, 12; 12, assignment; 12, 13; 12, 14; 13, identifier:cached_name; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, string:"_"; 17, identifier:join; 18, argument_list; 18, 19; 19, list:[filename, self.get_hash()]; 19, 20; 19, 21; 20, identifier:filename; 21, call; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:get_hash; 25, argument_list; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, string:"."; 30, identifier:join; 31, argument_list; 31, 32; 32, list:[cached_name, extention]; 32, 33; 32, 34; 33, identifier:cached_name; 34, identifier:extention | def get_cached_filename(self, filename, extention, settings_list=None):
cached_name = "_".join([filename, self.get_hash()])
return ".".join([cached_name, extention]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 10; 2, function_name:sort_func; 3, parameters; 3, 4; 3, 7; 4, default_parameter; 4, 5; 4, 6; 5, identifier:variant; 6, identifier:VARIANT1; 7, default_parameter; 7, 8; 7, 9; 8, identifier:case_sensitive; 9, False; 10, block; 10, 11; 11, return_statement; 11, 12; 12, lambda; 12, 13; 12, 15; 13, lambda_parameters; 13, 14; 14, identifier:x; 15, call; 15, 16; 15, 17; 16, identifier:normalize; 17, argument_list; 17, 18; 17, 19; 17, 22; 18, identifier:x; 19, keyword_argument; 19, 20; 19, 21; 20, identifier:variant; 21, identifier:variant; 22, keyword_argument; 22, 23; 22, 24; 23, identifier:case_sensitive; 24, identifier:case_sensitive | def sort_func(variant=VARIANT1, case_sensitive=False):
return lambda x: normalize(
x, variant=variant, case_sensitive=case_sensitive) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_notify_reader_writes; 3, parameters; 3, 4; 4, identifier:writeto; 5, block; 5, 6; 5, 10; 5, 43; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:satisfied; 9, list:[]; 10, for_statement; 10, 11; 10, 12; 10, 13; 11, identifier:var; 12, identifier:writeto; 13, block; 13, 14; 14, if_statement; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:var; 17, identifier:readable; 18, block; 18, 19; 19, for_statement; 19, 20; 19, 21; 19, 24; 20, identifier:reader; 21, attribute; 21, 22; 21, 23; 22, identifier:var; 23, identifier:readers; 24, block; 24, 25; 24, 31; 25, expression_statement; 25, 26; 26, call; 26, 27; 26, 30; 27, attribute; 27, 28; 27, 29; 28, identifier:reader; 29, identifier:notify_read_ready; 30, argument_list; 31, if_statement; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:reader; 34, identifier:satisfied; 35, block; 35, 36; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:satisfied; 40, identifier:append; 41, argument_list; 41, 42; 42, identifier:reader; 43, return_statement; 43, 44; 44, call; 44, 45; 44, 48; 45, attribute; 45, 46; 45, 47; 46, identifier:Closure; 47, identifier:sort; 48, argument_list; 48, 49; 49, identifier:satisfied | def _notify_reader_writes(writeto):
satisfied = []
for var in writeto:
if var.readable:
for reader in var.readers:
reader.notify_read_ready()
if reader.satisfied:
satisfied.append(reader)
return Closure.sort(satisfied) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:getFilePathsWithExtensionsInDirectory; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:dirTree; 5, identifier:patterns; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, True; 9, block; 9, 10; 9, 14; 9, 63; 9, 72; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:filePaths; 13, list:[]; 14, for_statement; 14, 15; 14, 19; 14, 25; 15, pattern_list; 15, 16; 15, 17; 15, 18; 16, identifier:root; 17, identifier:dirs; 18, identifier:files; 19, call; 19, 20; 19, 23; 20, attribute; 20, 21; 20, 22; 21, identifier:os; 22, identifier:walk; 23, argument_list; 23, 24; 24, identifier:dirTree; 25, block; 25, 26; 26, for_statement; 26, 27; 26, 28; 26, 29; 27, identifier:filePath; 28, identifier:files; 29, block; 29, 30; 30, for_statement; 30, 31; 30, 32; 30, 33; 31, identifier:pattern; 32, identifier:patterns; 33, block; 33, 34; 34, if_statement; 34, 35; 34, 42; 35, call; 35, 36; 35, 39; 36, attribute; 36, 37; 36, 38; 37, identifier:fnmatch; 38, identifier:fnmatch; 39, argument_list; 39, 40; 39, 41; 40, identifier:filePath; 41, identifier:pattern; 42, block; 42, 43; 42, 55; 42, 62; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:fullPath; 46, call; 46, 47; 46, 52; 47, attribute; 47, 48; 47, 51; 48, attribute; 48, 49; 48, 50; 49, identifier:os; 50, identifier:path; 51, identifier:join; 52, argument_list; 52, 53; 52, 54; 53, identifier:root; 54, identifier:filePath; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 60; 57, attribute; 57, 58; 57, 59; 58, identifier:filePaths; 59, identifier:append; 60, argument_list; 60, 61; 61, identifier:fullPath; 62, break_statement; 63, if_statement; 63, 64; 63, 65; 64, identifier:sort; 65, block; 65, 66; 66, expression_statement; 66, 67; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:filePaths; 70, identifier:sort; 71, argument_list; 72, return_statement; 72, 73; 73, identifier:filePaths | def getFilePathsWithExtensionsInDirectory(dirTree, patterns, sort=True):
filePaths = []
for root, dirs, files in os.walk(dirTree):
for filePath in files:
for pattern in patterns:
if fnmatch.fnmatch(filePath, pattern):
fullPath = os.path.join(root, filePath)
filePaths.append(fullPath)
break
if sort:
filePaths.sort()
return filePaths |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:shellsort; 3, parameters; 3, 4; 4, identifier:inlist; 5, block; 5, 6; 5, 13; 5, 22; 5, 29; 5, 35; 5, 130; 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:inlist; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:svec; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:copy; 19, identifier:deepcopy; 20, argument_list; 20, 21; 21, identifier:inlist; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:ivec; 25, call; 25, 26; 25, 27; 26, identifier:range; 27, argument_list; 27, 28; 28, identifier:n; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:gap; 32, binary_operator:/; 32, 33; 32, 34; 33, identifier:n; 34, integer:2; 35, while_statement; 35, 36; 35, 39; 36, comparison_operator:>; 36, 37; 36, 38; 37, identifier:gap; 38, integer:0; 39, block; 39, 40; 39, 124; 40, for_statement; 40, 41; 40, 42; 40, 47; 41, identifier:i; 42, call; 42, 43; 42, 44; 43, identifier:range; 44, argument_list; 44, 45; 44, 46; 45, identifier:gap; 46, identifier:n; 47, block; 47, 48; 48, for_statement; 48, 49; 48, 50; 48, 60; 49, identifier:j; 50, call; 50, 51; 50, 52; 51, identifier:range; 52, argument_list; 52, 53; 52, 56; 52, 58; 53, binary_operator:-; 53, 54; 53, 55; 54, identifier:i; 55, identifier:gap; 56, unary_operator:-; 56, 57; 57, integer:1; 58, unary_operator:-; 58, 59; 59, identifier:gap; 60, block; 60, 61; 61, while_statement; 61, 62; 61, 75; 62, boolean_operator:and; 62, 63; 62, 66; 63, comparison_operator:>=; 63, 64; 63, 65; 64, identifier:j; 65, integer:0; 66, comparison_operator:>; 66, 67; 66, 70; 67, subscript; 67, 68; 67, 69; 68, identifier:svec; 69, identifier:j; 70, subscript; 70, 71; 70, 72; 71, identifier:svec; 72, binary_operator:+; 72, 73; 72, 74; 73, identifier:j; 74, identifier:gap; 75, block; 75, 76; 75, 82; 75, 92; 75, 100; 75, 106; 75, 116; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 78, identifier:temp; 79, subscript; 79, 80; 79, 81; 80, identifier:svec; 81, identifier:j; 82, expression_statement; 82, 83; 83, assignment; 83, 84; 83, 87; 84, subscript; 84, 85; 84, 86; 85, identifier:svec; 86, identifier:j; 87, subscript; 87, 88; 87, 89; 88, identifier:svec; 89, binary_operator:+; 89, 90; 89, 91; 90, identifier:j; 91, identifier:gap; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 99; 94, subscript; 94, 95; 94, 96; 95, identifier:svec; 96, binary_operator:+; 96, 97; 96, 98; 97, identifier:j; 98, identifier:gap; 99, identifier:temp; 100, expression_statement; 100, 101; 101, assignment; 101, 102; 101, 103; 102, identifier:itemp; 103, subscript; 103, 104; 103, 105; 104, identifier:ivec; 105, identifier:j; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 111; 108, subscript; 108, 109; 108, 110; 109, identifier:ivec; 110, identifier:j; 111, subscript; 111, 112; 111, 113; 112, identifier:ivec; 113, binary_operator:+; 113, 114; 113, 115; 114, identifier:j; 115, identifier:gap; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 123; 118, subscript; 118, 119; 118, 120; 119, identifier:ivec; 120, binary_operator:+; 120, 121; 120, 122; 121, identifier:j; 122, identifier:gap; 123, identifier:itemp; 124, expression_statement; 124, 125; 125, assignment; 125, 126; 125, 127; 126, identifier:gap; 127, binary_operator:/; 127, 128; 127, 129; 128, identifier:gap; 129, integer:2; 130, return_statement; 130, 131; 131, expression_list; 131, 132; 131, 133; 132, identifier:svec; 133, identifier:ivec | def shellsort(inlist):
n = len(inlist)
svec = copy.deepcopy(inlist)
ivec = range(n)
gap = n / 2
while gap > 0:
for i in range(gap, n):
for j in range(i - gap, -1, -gap):
while j >= 0 and svec[j] > svec[j + gap]:
temp = svec[j]
svec[j] = svec[j + gap]
svec[j + gap] = temp
itemp = ivec[j]
ivec[j] = ivec[j + gap]
ivec[j + gap] = itemp
gap = gap / 2
return svec, ivec |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:rankdata; 3, parameters; 3, 4; 4, identifier:inlist; 5, block; 5, 6; 5, 13; 5, 22; 5, 26; 5, 30; 5, 37; 5, 114; 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:inlist; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 18; 15, pattern_list; 15, 16; 15, 17; 16, identifier:svec; 17, identifier:ivec; 18, call; 18, 19; 18, 20; 19, identifier:shellsort; 20, argument_list; 20, 21; 21, identifier:inlist; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:sumranks; 25, integer:0; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:dupcount; 29, integer:0; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:newlist; 33, binary_operator:*; 33, 34; 33, 36; 34, list:[0]; 34, 35; 35, integer:0; 36, identifier:n; 37, for_statement; 37, 38; 37, 39; 37, 43; 38, identifier:i; 39, call; 39, 40; 39, 41; 40, identifier:range; 41, argument_list; 41, 42; 42, identifier:n; 43, block; 43, 44; 43, 50; 43, 56; 44, expression_statement; 44, 45; 45, assignment; 45, 46; 45, 47; 46, identifier:sumranks; 47, binary_operator:+; 47, 48; 47, 49; 48, identifier:sumranks; 49, identifier:i; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 53; 52, identifier:dupcount; 53, binary_operator:+; 53, 54; 53, 55; 54, identifier:dupcount; 55, integer:1; 56, if_statement; 56, 57; 56, 72; 57, boolean_operator:or; 57, 58; 57, 63; 58, comparison_operator:==; 58, 59; 58, 60; 59, identifier:i; 60, binary_operator:-; 60, 61; 60, 62; 61, identifier:n; 62, integer:1; 63, comparison_operator:!=; 63, 64; 63, 67; 64, subscript; 64, 65; 64, 66; 65, identifier:svec; 66, identifier:i; 67, subscript; 67, 68; 67, 69; 68, identifier:svec; 69, binary_operator:+; 69, 70; 69, 71; 70, identifier:i; 71, integer:1; 72, block; 72, 73; 72, 84; 72, 106; 72, 110; 73, expression_statement; 73, 74; 74, assignment; 74, 75; 74, 76; 75, identifier:averank; 76, binary_operator:+; 76, 77; 76, 83; 77, binary_operator:/; 77, 78; 77, 79; 78, identifier:sumranks; 79, call; 79, 80; 79, 81; 80, identifier:float; 81, argument_list; 81, 82; 82, identifier:dupcount; 83, integer:1; 84, for_statement; 84, 85; 84, 86; 84, 97; 85, identifier:j; 86, call; 86, 87; 86, 88; 87, identifier:range; 88, argument_list; 88, 89; 88, 94; 89, binary_operator:+; 89, 90; 89, 93; 90, binary_operator:-; 90, 91; 90, 92; 91, identifier:i; 92, identifier:dupcount; 93, integer:1; 94, binary_operator:+; 94, 95; 94, 96; 95, identifier:i; 96, integer:1; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, assignment; 99, 100; 99, 105; 100, subscript; 100, 101; 100, 102; 101, identifier:newlist; 102, subscript; 102, 103; 102, 104; 103, identifier:ivec; 104, identifier:j; 105, identifier:averank; 106, expression_statement; 106, 107; 107, assignment; 107, 108; 107, 109; 108, identifier:sumranks; 109, integer:0; 110, expression_statement; 110, 111; 111, assignment; 111, 112; 111, 113; 112, identifier:dupcount; 113, integer:0; 114, return_statement; 114, 115; 115, identifier:newlist | def rankdata(inlist):
n = len(inlist)
svec, ivec = shellsort(inlist)
sumranks = 0
dupcount = 0
newlist = [0] * n
for i in range(n):
sumranks = sumranks + i
dupcount = dupcount + 1
if i == n - 1 or svec[i] != svec[i + 1]:
averank = sumranks / float(dupcount) + 1
for j in range(i - dupcount + 1, i + 1):
newlist[ivec[j]] = averank
sumranks = 0
dupcount = 0
return newlist |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 12; 2, function_name:to_json; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 4, identifier:self; 5, keyword_separator; 6, default_parameter; 6, 7; 6, 8; 7, identifier:indent; 8, None; 9, default_parameter; 9, 10; 9, 11; 10, identifier:sort_keys; 11, False; 12, block; 12, 13; 13, return_statement; 13, 14; 14, call; 14, 15; 14, 18; 15, attribute; 15, 16; 15, 17; 16, identifier:json; 17, identifier:dumps; 18, argument_list; 18, 19; 18, 39; 18, 42; 18, 45; 19, dictionary_comprehension; 19, 20; 19, 23; 19, 35; 20, pair; 20, 21; 20, 22; 21, identifier:k; 22, identifier:v; 23, for_in_clause; 23, 24; 23, 27; 24, pattern_list; 24, 25; 24, 26; 25, identifier:k; 26, identifier:v; 27, call; 27, 28; 27, 34; 28, attribute; 28, 29; 28, 33; 29, call; 29, 30; 29, 31; 30, identifier:dict; 31, argument_list; 31, 32; 32, identifier:self; 33, identifier:items; 34, argument_list; 35, if_clause; 35, 36; 36, comparison_operator:is; 36, 37; 36, 38; 37, identifier:v; 38, None; 39, keyword_argument; 39, 40; 39, 41; 40, identifier:indent; 41, identifier:indent; 42, keyword_argument; 42, 43; 42, 44; 43, identifier:sort_keys; 44, identifier:sort_keys; 45, keyword_argument; 45, 46; 45, 47; 46, identifier:default; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:_try_dict | def to_json(self, *, indent=None, sort_keys = False):
return json.dumps({k: v for k, v in dict(self).items() if v is not None}, indent=indent, sort_keys=sort_keys,
default=self._try_dict) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:get_sort_field; 3, parameters; 3, 4; 3, 5; 4, identifier:attr; 5, identifier:model; 6, block; 6, 7; 7, try_statement; 7, 8; 7, 21; 8, block; 8, 9; 9, if_statement; 9, 10; 9, 18; 10, call; 10, 11; 10, 16; 11, attribute; 11, 12; 11, 15; 12, attribute; 12, 13; 12, 14; 13, identifier:model; 14, identifier:_meta; 15, identifier:get_field; 16, argument_list; 16, 17; 17, identifier:attr; 18, block; 18, 19; 19, return_statement; 19, 20; 20, identifier:attr; 21, except_clause; 21, 22; 21, 23; 22, identifier:FieldDoesNotExist; 23, block; 23, 24; 23, 57; 24, if_statement; 24, 25; 24, 30; 25, call; 25, 26; 25, 27; 26, identifier:isinstance; 27, argument_list; 27, 28; 27, 29; 28, identifier:attr; 29, identifier:basestring; 30, block; 30, 31; 30, 40; 31, expression_statement; 31, 32; 32, assignment; 32, 33; 32, 34; 33, identifier:val; 34, call; 34, 35; 34, 36; 35, identifier:getattr; 36, argument_list; 36, 37; 36, 38; 36, 39; 37, identifier:model; 38, identifier:attr; 39, None; 40, if_statement; 40, 41; 40, 48; 41, boolean_operator:and; 41, 42; 41, 43; 42, identifier:val; 43, call; 43, 44; 43, 45; 44, identifier:hasattr; 45, argument_list; 45, 46; 45, 47; 46, identifier:val; 47, string:'sort_field'; 48, block; 48, 49; 49, return_statement; 49, 50; 50, attribute; 50, 51; 50, 56; 51, call; 51, 52; 51, 53; 52, identifier:getattr; 53, argument_list; 53, 54; 53, 55; 54, identifier:model; 55, identifier:attr; 56, identifier:sort_field; 57, return_statement; 57, 58; 58, None | def get_sort_field(attr, model):
try:
if model._meta.get_field(attr):
return attr
except FieldDoesNotExist:
if isinstance(attr, basestring):
val = getattr(model, attr, None)
if val and hasattr(val, 'sort_field'):
return getattr(model, attr).sort_field
return None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sorted_query_paths; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:list; 9, argument_list; 9, 10; 10, call; 10, 11; 10, 12; 11, identifier:reversed; 12, argument_list; 12, 13; 13, call; 13, 14; 13, 15; 14, identifier:sorted; 15, generator_expression; 15, 16; 15, 19; 16, subscript; 16, 17; 16, 18; 17, identifier:p; 18, integer:0; 19, for_in_clause; 19, 20; 19, 21; 20, identifier:p; 21, call; 21, 22; 21, 29; 22, attribute; 22, 23; 22, 28; 23, attribute; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:self; 26, identifier:namespace; 27, identifier:alias_to_query_paths; 28, identifier:get; 29, argument_list; 29, 30; 30, attribute; 30, 31; 30, 32; 31, identifier:self; 32, identifier:name | def sorted_query_paths(self):
return list(reversed(sorted(p[0] for p in self.namespace.alias_to_query_paths.get(self.name)))) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:add_arguments; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:actions; 6, block; 6, 7; 6, 22; 7, expression_statement; 7, 8; 8, assignment; 8, 9; 8, 10; 9, identifier:actions; 10, call; 10, 11; 10, 12; 11, identifier:sorted; 12, argument_list; 12, 13; 12, 14; 13, identifier:actions; 14, keyword_argument; 14, 15; 14, 16; 15, identifier:key; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:operator; 19, identifier:attrgetter; 20, argument_list; 20, 21; 21, string:'option_strings'; 22, expression_statement; 22, 23; 23, call; 23, 24; 23, 31; 24, attribute; 24, 25; 24, 30; 25, call; 25, 26; 25, 27; 26, identifier:super; 27, argument_list; 27, 28; 27, 29; 28, identifier:SortedHelpFormatter; 29, identifier:self; 30, identifier:add_arguments; 31, argument_list; 31, 32; 32, identifier:actions | def add_arguments(self, actions):
actions = sorted(
actions, key=operator.attrgetter('option_strings'))
super(SortedHelpFormatter, self).add_arguments(actions) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_iter_indented_subactions; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:action; 6, block; 6, 7; 7, try_statement; 7, 8; 7, 15; 7, 19; 8, block; 8, 9; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:get_subactions; 12, attribute; 12, 13; 12, 14; 13, identifier:action; 14, identifier:_get_subactions; 15, except_clause; 15, 16; 15, 17; 16, identifier:AttributeError; 17, block; 17, 18; 18, pass_statement; 19, else_clause; 19, 20; 20, block; 20, 21; 20, 27; 20, 67; 21, expression_statement; 21, 22; 22, call; 22, 23; 22, 26; 23, attribute; 23, 24; 23, 25; 24, identifier:self; 25, identifier:_indent; 26, argument_list; 27, if_statement; 27, 28; 27, 35; 27, 56; 28, call; 28, 29; 28, 30; 29, identifier:isinstance; 30, argument_list; 30, 31; 30, 32; 31, identifier:action; 32, attribute; 32, 33; 32, 34; 33, identifier:argparse; 34, identifier:_SubParsersAction; 35, block; 35, 36; 36, for_statement; 36, 37; 36, 38; 36, 52; 37, identifier:subaction; 38, call; 38, 39; 38, 40; 39, identifier:sorted; 40, argument_list; 40, 41; 40, 44; 41, call; 41, 42; 41, 43; 42, identifier:get_subactions; 43, argument_list; 44, keyword_argument; 44, 45; 44, 46; 45, identifier:key; 46, lambda; 46, 47; 46, 49; 47, lambda_parameters; 47, 48; 48, identifier:x; 49, attribute; 49, 50; 49, 51; 50, identifier:x; 51, identifier:dest; 52, block; 52, 53; 53, expression_statement; 53, 54; 54, yield; 54, 55; 55, identifier:subaction; 56, else_clause; 56, 57; 57, block; 57, 58; 58, for_statement; 58, 59; 58, 60; 58, 63; 59, identifier:subaction; 60, call; 60, 61; 60, 62; 61, identifier:get_subactions; 62, argument_list; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, yield; 65, 66; 66, identifier:subaction; 67, expression_statement; 67, 68; 68, call; 68, 69; 68, 72; 69, attribute; 69, 70; 69, 71; 70, identifier:self; 71, identifier:_dedent; 72, argument_list | def _iter_indented_subactions(self, action):
try:
get_subactions = action._get_subactions
except AttributeError:
pass
else:
self._indent()
if isinstance(action, argparse._SubParsersAction):
for subaction in sorted(
get_subactions(), key=lambda x: x.dest):
yield subaction
else:
for subaction in get_subactions():
yield subaction
self._dedent() |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_sort2sql; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:sort; 6, block; 6, 7; 6, 13; 7, if_statement; 7, 8; 7, 10; 8, not_operator; 8, 9; 9, identifier:sort; 10, block; 10, 11; 11, return_statement; 11, 12; 12, string:""; 13, return_statement; 13, 14; 14, binary_operator:+; 14, 15; 14, 16; 15, identifier:SQL_ORDERBY; 16, call; 16, 17; 16, 18; 17, identifier:sql_list; 18, argument_list; 18, 19; 19, list_comprehension; 19, 20; 19, 37; 20, binary_operator:+; 20, 21; 20, 27; 21, call; 21, 22; 21, 23; 22, identifier:quote_column; 23, argument_list; 23, 24; 24, attribute; 24, 25; 24, 26; 25, identifier:o; 26, identifier:field; 27, parenthesized_expression; 27, 28; 28, conditional_expression:if; 28, 29; 28, 30; 28, 36; 29, string:" DESC"; 30, comparison_operator:==; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:o; 33, identifier:sort; 34, unary_operator:-; 34, 35; 35, integer:1; 36, string:""; 37, for_in_clause; 37, 38; 37, 39; 38, identifier:o; 39, identifier:sort | def _sort2sql(self, sort):
if not sort:
return ""
return SQL_ORDERBY + sql_list([quote_column(o.field) + (" DESC" if o.sort == -1 else "") for o in sort]) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:optimize_batch; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:batchsize; 7, integer:10; 8, default_parameter; 8, 9; 8, 10; 9, identifier:returns; 10, string:'best'; 11, default_parameter; 11, 12; 11, 13; 12, identifier:paralell; 13, True; 14, block; 14, 15; 14, 27; 14, 51; 14, 88; 14, 103; 15, if_statement; 15, 16; 15, 21; 16, comparison_operator:not; 16, 17; 16, 18; 17, identifier:returns; 18, tuple; 18, 19; 18, 20; 19, string:'best'; 20, string:'all'; 21, block; 21, 22; 22, raise_statement; 22, 23; 23, call; 23, 24; 23, 25; 24, identifier:ValueError; 25, argument_list; 25, 26; 26, string:'returns must be either "best" or "all"'; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:starts; 30, list_comprehension; 30, 31; 30, 45; 31, binary_operator:*; 31, 32; 31, 44; 32, call; 32, 33; 32, 38; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:np; 36, identifier:random; 37, identifier:rand; 38, argument_list; 38, 39; 39, binary_operator:*; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:self; 42, identifier:m; 43, integer:2; 44, integer:10; 45, for_in_clause; 45, 46; 45, 47; 46, identifier:i; 47, call; 47, 48; 47, 49; 48, identifier:range; 49, argument_list; 49, 50; 50, identifier:batchsize; 51, if_statement; 51, 52; 51, 53; 51, 76; 52, identifier:paralell; 53, block; 53, 54; 54, with_statement; 54, 55; 54, 63; 55, with_clause; 55, 56; 56, with_item; 56, 57; 57, as_pattern; 57, 58; 57, 61; 58, call; 58, 59; 58, 60; 59, identifier:Pool; 60, argument_list; 61, as_pattern_target; 61, 62; 62, identifier:p; 63, block; 63, 64; 64, expression_statement; 64, 65; 65, assignment; 65, 66; 65, 67; 66, identifier:results; 67, call; 67, 68; 67, 71; 68, attribute; 68, 69; 68, 70; 69, identifier:p; 70, identifier:map; 71, argument_list; 71, 72; 71, 75; 72, attribute; 72, 73; 72, 74; 73, identifier:self; 74, identifier:optimize; 75, identifier:starts; 76, else_clause; 76, 77; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, assignment; 79, 80; 79, 81; 80, identifier:results; 81, call; 81, 82; 81, 83; 82, identifier:map; 83, argument_list; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:optimize; 87, identifier:starts; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:results; 91, call; 91, 92; 91, 93; 92, identifier:sorted; 93, argument_list; 93, 94; 93, 95; 94, identifier:results; 95, keyword_argument; 95, 96; 95, 97; 96, identifier:key; 97, lambda; 97, 98; 97, 100; 98, lambda_parameters; 98, 99; 99, identifier:x; 100, attribute; 100, 101; 100, 102; 101, identifier:x; 102, identifier:stress; 103, return_statement; 103, 104; 104, conditional_expression:if; 104, 105; 104, 106; 104, 109; 105, identifier:results; 106, comparison_operator:==; 106, 107; 106, 108; 107, identifier:returns; 108, string:'all'; 109, subscript; 109, 110; 109, 111; 110, identifier:results; 111, integer:0 | def optimize_batch(self, batchsize=10, returns='best', paralell=True):
if returns not in ('best', 'all'):
raise ValueError('returns must be either "best" or "all"')
starts = [np.random.rand(self.m * 2) * 10 for i in range(batchsize)]
if paralell:
with Pool() as p:
results = p.map(self.optimize, starts)
else:
results = map(self.optimize, starts)
results = sorted(results, key=lambda x: x.stress)
return results if returns == 'all' else results[0] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:list_gewesten; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, integer:1; 8, block; 8, 9; 8, 11; 8, 81; 8, 117; 8, 128; 9, expression_statement; 9, 10; 10, string:'''
List all `gewesten` in Belgium.
:param integer sort: What field to sort on.
:rtype: A :class`list` of class: `Gewest`.
'''; 11, function_definition; 11, 12; 11, 13; 11, 14; 12, function_name:creator; 13, parameters; 14, block; 14, 15; 14, 26; 14, 30; 14, 65; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:res; 18, call; 18, 19; 18, 20; 19, identifier:crab_gateway_request; 20, argument_list; 20, 21; 20, 24; 20, 25; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:client; 24, string:'ListGewesten'; 25, identifier:sort; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:tmp; 29, dictionary; 30, for_statement; 30, 31; 30, 32; 30, 35; 31, identifier:r; 32, attribute; 32, 33; 32, 34; 33, identifier:res; 34, identifier:GewestItem; 35, block; 35, 36; 35, 51; 36, if_statement; 36, 37; 36, 42; 37, comparison_operator:not; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:r; 40, identifier:GewestId; 41, identifier:tmp; 42, block; 42, 43; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 50; 45, subscript; 45, 46; 45, 47; 46, identifier:tmp; 47, attribute; 47, 48; 47, 49; 48, identifier:r; 49, identifier:GewestId; 50, dictionary; 51, expression_statement; 51, 52; 52, assignment; 52, 53; 52, 62; 53, subscript; 53, 54; 53, 59; 54, subscript; 54, 55; 54, 56; 55, identifier:tmp; 56, attribute; 56, 57; 56, 58; 57, identifier:r; 58, identifier:GewestId; 59, attribute; 59, 60; 59, 61; 60, identifier:r; 61, identifier:TaalCodeGewestNaam; 62, attribute; 62, 63; 62, 64; 63, identifier:r; 64, identifier:GewestNaam; 65, return_statement; 65, 66; 66, list_comprehension; 66, 67; 66, 72; 67, call; 67, 68; 67, 69; 68, identifier:Gewest; 69, argument_list; 69, 70; 69, 71; 70, identifier:k; 71, identifier:v; 72, for_in_clause; 72, 73; 72, 76; 73, pattern_list; 73, 74; 73, 75; 74, identifier:k; 75, identifier:v; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:tmp; 79, identifier:items; 80, argument_list; 81, if_statement; 81, 82; 81, 89; 81, 109; 82, attribute; 82, 83; 82, 88; 83, subscript; 83, 84; 83, 87; 84, attribute; 84, 85; 84, 86; 85, identifier:self; 86, identifier:caches; 87, string:'permanent'; 88, identifier:is_configured; 89, block; 89, 90; 89, 95; 90, expression_statement; 90, 91; 91, assignment; 91, 92; 91, 93; 91, 94; 92, identifier:key; 93, ERROR; 94, identifier:ListGewesten; 95, expression_statement; 95, 96; 96, assignment; 96, 97; 96, 98; 97, identifier:gewesten; 98, call; 98, 99; 98, 106; 99, attribute; 99, 100; 99, 105; 100, subscript; 100, 101; 100, 104; 101, attribute; 101, 102; 101, 103; 102, identifier:self; 103, identifier:caches; 104, string:'permanent'; 105, identifier:get_or_create; 106, argument_list; 106, 107; 106, 108; 107, identifier:key; 108, identifier:creator; 109, else_clause; 109, 110; 110, block; 110, 111; 111, expression_statement; 111, 112; 112, assignment; 112, 113; 112, 114; 113, identifier:gewesten; 114, call; 114, 115; 114, 116; 115, identifier:creator; 116, argument_list; 117, for_statement; 117, 118; 117, 119; 117, 120; 118, identifier:g; 119, identifier:gewesten; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 126; 123, attribute; 123, 124; 123, 125; 124, identifier:g; 125, identifier:set_gateway; 126, argument_list; 126, 127; 127, identifier:self; 128, return_statement; 128, 129; 129, identifier:gewesten | def list_gewesten(self, sort=1):
'''
List all `gewesten` in Belgium.
:param integer sort: What field to sort on.
:rtype: A :class`list` of class: `Gewest`.
'''
def creator():
res = crab_gateway_request(self.client, 'ListGewesten', sort)
tmp = {}
for r in res.GewestItem:
if r.GewestId not in tmp:
tmp[r.GewestId] = {}
tmp[r.GewestId][r.TaalCodeGewestNaam] = r.GewestNaam
return[
Gewest(
k,
v
)for k, v in tmp.items()
]
if self.caches['permanent'].is_configured:
key = 'ListGewesten
gewesten = self.caches['permanent'].get_or_create(key, creator)
else:
gewesten = creator()
for g in gewesten:
g.set_gateway(self)
return gewesten |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:list_provincies; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:gewest; 7, integer:2; 8, block; 8, 9; 8, 11; 8, 26; 8, 58; 8, 94; 8, 105; 9, expression_statement; 9, 10; 10, string:'''
List all `provincies` in a `gewest`.
:param gewest: The :class:`Gewest` for which the \
`provincies` are wanted.
:param integer sort: What field to sort on.
:rtype: A :class:`list` of :class:`Provincie`.
'''; 11, try_statement; 11, 12; 11, 19; 12, block; 12, 13; 13, expression_statement; 13, 14; 14, assignment; 14, 15; 14, 16; 15, identifier:gewest_id; 16, attribute; 16, 17; 16, 18; 17, identifier:gewest; 18, identifier:id; 19, except_clause; 19, 20; 19, 21; 20, identifier:AttributeError; 21, block; 21, 22; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:gewest_id; 25, identifier:gewest; 26, function_definition; 26, 27; 26, 28; 26, 29; 27, function_name:creator; 28, parameters; 29, block; 29, 30; 30, return_statement; 30, 31; 31, list_comprehension; 31, 32; 31, 47; 31, 52; 32, call; 32, 33; 32, 34; 33, identifier:Provincie; 34, argument_list; 34, 35; 34, 38; 34, 41; 35, subscript; 35, 36; 35, 37; 36, identifier:p; 37, integer:0; 38, subscript; 38, 39; 38, 40; 39, identifier:p; 40, integer:1; 41, call; 41, 42; 41, 43; 42, identifier:Gewest; 43, argument_list; 43, 44; 44, subscript; 44, 45; 44, 46; 45, identifier:p; 46, integer:2; 47, for_in_clause; 47, 48; 47, 49; 48, identifier:p; 49, attribute; 49, 50; 49, 51; 50, identifier:self; 51, identifier:provincies; 52, if_clause; 52, 53; 53, comparison_operator:==; 53, 54; 53, 57; 54, subscript; 54, 55; 54, 56; 55, identifier:p; 56, integer:2; 57, identifier:gewest_id; 58, if_statement; 58, 59; 58, 66; 58, 86; 59, attribute; 59, 60; 59, 65; 60, subscript; 60, 61; 60, 64; 61, attribute; 61, 62; 61, 63; 62, identifier:self; 63, identifier:caches; 64, string:'permanent'; 65, identifier:is_configured; 66, block; 66, 67; 66, 72; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 70; 68, 71; 69, identifier:key; 70, ERROR; 71, identifier:ListProvinciesByGewestId; 72, expression_statement; 72, 73; 73, assignment; 73, 74; 73, 75; 74, identifier:provincies; 75, call; 75, 76; 75, 83; 76, attribute; 76, 77; 76, 82; 77, subscript; 77, 78; 77, 81; 78, attribute; 78, 79; 78, 80; 79, identifier:self; 80, identifier:caches; 81, string:'permanent'; 82, identifier:get_or_create; 83, argument_list; 83, 84; 83, 85; 84, identifier:key; 85, identifier:creator; 86, else_clause; 86, 87; 87, block; 87, 88; 88, expression_statement; 88, 89; 89, assignment; 89, 90; 89, 91; 90, identifier:provincies; 91, call; 91, 92; 91, 93; 92, identifier:creator; 93, argument_list; 94, for_statement; 94, 95; 94, 96; 94, 97; 95, identifier:p; 96, identifier:provincies; 97, block; 97, 98; 98, expression_statement; 98, 99; 99, call; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:p; 102, identifier:set_gateway; 103, argument_list; 103, 104; 104, identifier:self; 105, return_statement; 105, 106; 106, identifier:provincies | def list_provincies(self, gewest=2):
'''
List all `provincies` in a `gewest`.
:param gewest: The :class:`Gewest` for which the \
`provincies` are wanted.
:param integer sort: What field to sort on.
:rtype: A :class:`list` of :class:`Provincie`.
'''
try:
gewest_id = gewest.id
except AttributeError:
gewest_id = gewest
def creator():
return [Provincie(p[0], p[1], Gewest(p[2])) for p in self.provincies if p[2] == gewest_id]
if self.caches['permanent'].is_configured:
key = 'ListProvinciesByGewestId
provincies = self.caches['permanent'].get_or_create(key, creator)
else:
provincies = creator()
for p in provincies:
p.set_gateway(self)
return provincies |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 11; 2, function_name:list_gemeenten; 3, parameters; 3, 4; 3, 5; 3, 8; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:gewest; 7, integer:2; 8, default_parameter; 8, 9; 8, 10; 9, identifier:sort; 10, integer:1; 11, block; 11, 12; 11, 14; 11, 38; 11, 44; 11, 88; 11, 124; 11, 135; 12, expression_statement; 12, 13; 13, string:'''
List all `gemeenten` in a `gewest`.
:param gewest: The :class:`Gewest` for which the \
`gemeenten` are wanted.
:param integer sort: What field to sort on.
:rtype: A :class:`list` of :class:`Gemeente`.
'''; 14, try_statement; 14, 15; 14, 22; 15, block; 15, 16; 16, expression_statement; 16, 17; 17, assignment; 17, 18; 17, 19; 18, identifier:gewest_id; 19, attribute; 19, 20; 19, 21; 20, identifier:gewest; 21, identifier:id; 22, except_clause; 22, 23; 22, 24; 23, identifier:AttributeError; 24, block; 24, 25; 24, 29; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:gewest_id; 28, identifier:gewest; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:gewest; 32, call; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:self; 35, identifier:get_gewest_by_id; 36, argument_list; 36, 37; 37, identifier:gewest_id; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:gewest; 42, identifier:clear_gateway; 43, argument_list; 44, function_definition; 44, 45; 44, 46; 44, 47; 45, function_name:creator; 46, parameters; 47, block; 47, 48; 47, 60; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:res; 51, call; 51, 52; 51, 53; 52, identifier:crab_gateway_request; 53, argument_list; 53, 54; 53, 57; 53, 58; 53, 59; 54, attribute; 54, 55; 54, 56; 55, identifier:self; 56, identifier:client; 57, string:'ListGemeentenByGewestId'; 58, identifier:gewest_id; 59, identifier:sort; 60, return_statement; 60, 61; 61, list_comprehension; 61, 62; 61, 75; 61, 80; 62, call; 62, 63; 62, 64; 63, identifier:Gemeente; 64, argument_list; 64, 65; 64, 68; 64, 71; 64, 74; 65, attribute; 65, 66; 65, 67; 66, identifier:r; 67, identifier:GemeenteId; 68, attribute; 68, 69; 68, 70; 69, identifier:r; 70, identifier:GemeenteNaam; 71, attribute; 71, 72; 71, 73; 72, identifier:r; 73, identifier:NISGemeenteCode; 74, identifier:gewest; 75, for_in_clause; 75, 76; 75, 77; 76, identifier:r; 77, attribute; 77, 78; 77, 79; 78, identifier:res; 79, identifier:GemeenteItem; 80, if_clause; 80, 81; 81, comparison_operator:==; 81, 82; 81, 85; 82, attribute; 82, 83; 82, 84; 83, identifier:r; 84, identifier:TaalCode; 85, attribute; 85, 86; 85, 87; 86, identifier:r; 87, identifier:TaalCodeGemeenteNaam; 88, if_statement; 88, 89; 88, 96; 88, 116; 89, attribute; 89, 90; 89, 95; 90, subscript; 90, 91; 90, 94; 91, attribute; 91, 92; 91, 93; 92, identifier:self; 93, identifier:caches; 94, string:'permanent'; 95, identifier:is_configured; 96, block; 96, 97; 96, 102; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 98, 101; 99, identifier:key; 100, ERROR; 101, identifier:ListGemeentenByGewestId; 102, expression_statement; 102, 103; 103, assignment; 103, 104; 103, 105; 104, identifier:gemeenten; 105, call; 105, 106; 105, 113; 106, attribute; 106, 107; 106, 112; 107, subscript; 107, 108; 107, 111; 108, attribute; 108, 109; 108, 110; 109, identifier:self; 110, identifier:caches; 111, string:'permanent'; 112, identifier:get_or_create; 113, argument_list; 113, 114; 113, 115; 114, identifier:key; 115, identifier:creator; 116, else_clause; 116, 117; 117, block; 117, 118; 118, expression_statement; 118, 119; 119, assignment; 119, 120; 119, 121; 120, identifier:gemeenten; 121, call; 121, 122; 121, 123; 122, identifier:creator; 123, argument_list; 124, for_statement; 124, 125; 124, 126; 124, 127; 125, identifier:g; 126, identifier:gemeenten; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, call; 129, 130; 129, 133; 130, attribute; 130, 131; 130, 132; 131, identifier:g; 132, identifier:set_gateway; 133, argument_list; 133, 134; 134, identifier:self; 135, return_statement; 135, 136; 136, identifier:gemeenten | def list_gemeenten(self, gewest=2, sort=1):
'''
List all `gemeenten` in a `gewest`.
:param gewest: The :class:`Gewest` for which the \
`gemeenten` are wanted.
:param integer sort: What field to sort on.
:rtype: A :class:`list` of :class:`Gemeente`.
'''
try:
gewest_id = gewest.id
except AttributeError:
gewest_id = gewest
gewest = self.get_gewest_by_id(gewest_id)
gewest.clear_gateway()
def creator():
res = crab_gateway_request(
self.client, 'ListGemeentenByGewestId', gewest_id, sort
)
return[
Gemeente(
r.GemeenteId,
r.GemeenteNaam,
r.NISGemeenteCode,
gewest
)for r in res.GemeenteItem if r.TaalCode == r.TaalCodeGemeenteNaam
]
if self.caches['permanent'].is_configured:
key = 'ListGemeentenByGewestId
gemeenten = self.caches['permanent'].get_or_create(key, creator)
else:
gemeenten = creator()
for g in gemeenten:
g.set_gateway(self)
return gemeenten |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:list_gemeenten; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, integer:1; 8, block; 8, 9; 8, 11; 8, 67; 8, 103; 8, 114; 9, expression_statement; 9, 10; 10, string:'''
List all `gemeenten` in Vlaanderen.
:param integer sort: What field to sort on.
:rtype: A :class:`list` of :class:`Gemeente`.
'''; 11, function_definition; 11, 12; 11, 13; 11, 14; 12, function_name:creator; 13, parameters; 14, block; 14, 15; 14, 23; 14, 29; 14, 38; 14, 51; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:url; 18, binary_operator:+; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:self; 21, identifier:base_url; 22, string:'/municipality'; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:h; 26, attribute; 26, 27; 26, 28; 27, identifier:self; 28, identifier:base_headers; 29, expression_statement; 29, 30; 30, assignment; 30, 31; 30, 32; 31, identifier:p; 32, dictionary; 32, 33; 33, pair; 33, 34; 33, 35; 34, string:'orderbyCode'; 35, comparison_operator:==; 35, 36; 35, 37; 36, identifier:sort; 37, integer:1; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:res; 41, call; 41, 42; 41, 50; 42, attribute; 42, 43; 42, 49; 43, call; 43, 44; 43, 45; 44, identifier:capakey_rest_gateway_request; 45, argument_list; 45, 46; 45, 47; 45, 48; 46, identifier:url; 47, identifier:h; 48, identifier:p; 49, identifier:json; 50, argument_list; 51, return_statement; 51, 52; 52, list_comprehension; 52, 53; 52, 62; 53, call; 53, 54; 53, 55; 54, identifier:Gemeente; 55, argument_list; 55, 56; 55, 59; 56, subscript; 56, 57; 56, 58; 57, identifier:r; 58, string:'municipalityCode'; 59, subscript; 59, 60; 59, 61; 60, identifier:r; 61, string:'municipalityName'; 62, for_in_clause; 62, 63; 62, 64; 63, identifier:r; 64, subscript; 64, 65; 64, 66; 65, identifier:res; 66, string:'municipalities'; 67, if_statement; 67, 68; 67, 75; 67, 95; 68, attribute; 68, 69; 68, 74; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:caches; 73, string:'permanent'; 74, identifier:is_configured; 75, block; 75, 76; 75, 81; 76, expression_statement; 76, 77; 77, assignment; 77, 78; 77, 79; 77, 80; 78, identifier:key; 79, ERROR; 80, identifier:list_gemeenten_rest; 81, expression_statement; 81, 82; 82, assignment; 82, 83; 82, 84; 83, identifier:gemeente; 84, call; 84, 85; 84, 92; 85, attribute; 85, 86; 85, 91; 86, subscript; 86, 87; 86, 90; 87, attribute; 87, 88; 87, 89; 88, identifier:self; 89, identifier:caches; 90, string:'permanent'; 91, identifier:get_or_create; 92, argument_list; 92, 93; 92, 94; 93, identifier:key; 94, identifier:creator; 95, else_clause; 95, 96; 96, block; 96, 97; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:gemeente; 100, call; 100, 101; 100, 102; 101, identifier:creator; 102, argument_list; 103, for_statement; 103, 104; 103, 105; 103, 106; 104, identifier:g; 105, identifier:gemeente; 106, block; 106, 107; 107, expression_statement; 107, 108; 108, call; 108, 109; 108, 112; 109, attribute; 109, 110; 109, 111; 110, identifier:g; 111, identifier:set_gateway; 112, argument_list; 112, 113; 113, identifier:self; 114, return_statement; 114, 115; 115, identifier:gemeente | def list_gemeenten(self, sort=1):
'''
List all `gemeenten` in Vlaanderen.
:param integer sort: What field to sort on.
:rtype: A :class:`list` of :class:`Gemeente`.
'''
def creator():
url = self.base_url + '/municipality'
h = self.base_headers
p = {
'orderbyCode': sort == 1
}
res = capakey_rest_gateway_request(url, h, p).json()
return [
Gemeente(r['municipalityCode'], r['municipalityName'])
for r in res['municipalities']
]
if self.caches['permanent'].is_configured:
key = 'list_gemeenten_rest
gemeente = self.caches['permanent'].get_or_create(key, creator)
else:
gemeente = creator()
for g in gemeente:
g.set_gateway(self)
return gemeente |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:list_kadastrale_afdelingen; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 8; 5, 39; 5, 74; 6, expression_statement; 6, 7; 7, string:'''
List all `kadastrale afdelingen` in Flanders.
:param integer sort: Field to sort on.
:rtype: A :class:`list` of :class:`Afdeling`.
'''; 8, function_definition; 8, 9; 8, 10; 8, 11; 9, function_name:creator; 10, parameters; 11, block; 11, 12; 11, 20; 11, 24; 11, 37; 12, expression_statement; 12, 13; 13, assignment; 13, 14; 13, 15; 14, identifier:gemeentes; 15, call; 15, 16; 15, 19; 16, attribute; 16, 17; 16, 18; 17, identifier:self; 18, identifier:list_gemeenten; 19, argument_list; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:res; 23, list:[]; 24, for_statement; 24, 25; 24, 26; 24, 27; 25, identifier:g; 26, identifier:gemeentes; 27, block; 27, 28; 28, expression_statement; 28, 29; 29, augmented_assignment:+=; 29, 30; 29, 31; 30, identifier:res; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:list_kadastrale_afdelingen_by_gemeente; 35, argument_list; 35, 36; 36, identifier:g; 37, return_statement; 37, 38; 38, identifier:res; 39, if_statement; 39, 40; 39, 47; 39, 66; 40, attribute; 40, 41; 40, 46; 41, subscript; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:self; 44, identifier:caches; 45, string:'permanent'; 46, identifier:is_configured; 47, block; 47, 48; 47, 52; 48, expression_statement; 48, 49; 49, assignment; 49, 50; 49, 51; 50, identifier:key; 51, string:'list_afdelingen_rest'; 52, expression_statement; 52, 53; 53, assignment; 53, 54; 53, 55; 54, identifier:afdelingen; 55, call; 55, 56; 55, 63; 56, attribute; 56, 57; 56, 62; 57, subscript; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:caches; 61, string:'permanent'; 62, identifier:get_or_create; 63, argument_list; 63, 64; 63, 65; 64, identifier:key; 65, identifier:creator; 66, else_clause; 66, 67; 67, block; 67, 68; 68, expression_statement; 68, 69; 69, assignment; 69, 70; 69, 71; 70, identifier:afdelingen; 71, call; 71, 72; 71, 73; 72, identifier:creator; 73, argument_list; 74, return_statement; 74, 75; 75, identifier:afdelingen | def list_kadastrale_afdelingen(self):
'''
List all `kadastrale afdelingen` in Flanders.
:param integer sort: Field to sort on.
:rtype: A :class:`list` of :class:`Afdeling`.
'''
def creator():
gemeentes = self.list_gemeenten()
res = []
for g in gemeentes:
res += self.list_kadastrale_afdelingen_by_gemeente(g)
return res
if self.caches['permanent'].is_configured:
key = 'list_afdelingen_rest'
afdelingen = self.caches['permanent'].get_or_create(key, creator)
else:
afdelingen = creator()
return afdelingen |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:list_kadastrale_afdelingen_by_gemeente; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:gemeente; 6, default_parameter; 6, 7; 6, 8; 7, identifier:sort; 8, integer:1; 9, block; 9, 10; 9, 12; 9, 36; 9, 42; 9, 107; 9, 143; 9, 154; 10, expression_statement; 10, 11; 11, string:'''
List all `kadastrale afdelingen` in a `gemeente`.
:param gemeente: The :class:`Gemeente` for which the \
`afdelingen` are wanted.
:param integer sort: Field to sort on.
:rtype: A :class:`list` of :class:`Afdeling`.
'''; 12, try_statement; 12, 13; 12, 20; 13, block; 13, 14; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:gid; 17, attribute; 17, 18; 17, 19; 18, identifier:gemeente; 19, identifier:id; 20, except_clause; 20, 21; 20, 22; 21, identifier:AttributeError; 22, block; 22, 23; 22, 27; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:gid; 26, identifier:gemeente; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:gemeente; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:get_gemeente_by_id; 34, argument_list; 34, 35; 35, identifier:gid; 36, expression_statement; 36, 37; 37, call; 37, 38; 37, 41; 38, attribute; 38, 39; 38, 40; 39, identifier:gemeente; 40, identifier:clear_gateway; 41, argument_list; 42, function_definition; 42, 43; 42, 44; 42, 45; 43, function_name:creator; 44, parameters; 45, block; 45, 46; 45, 56; 45, 62; 45, 71; 45, 84; 46, expression_statement; 46, 47; 47, assignment; 47, 48; 47, 49; 48, identifier:url; 49, binary_operator:+; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:self; 52, identifier:base_url; 53, binary_operator:%; 53, 54; 53, 55; 54, string:'/municipality/%s/department'; 55, identifier:gid; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:h; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:base_headers; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:p; 65, dictionary; 65, 66; 66, pair; 66, 67; 66, 68; 67, string:'orderbyCode'; 68, comparison_operator:==; 68, 69; 68, 70; 69, identifier:sort; 70, integer:1; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 74; 73, identifier:res; 74, call; 74, 75; 74, 83; 75, attribute; 75, 76; 75, 82; 76, call; 76, 77; 76, 78; 77, identifier:capakey_rest_gateway_request; 78, argument_list; 78, 79; 78, 80; 78, 81; 79, identifier:url; 80, identifier:h; 81, identifier:p; 82, identifier:json; 83, argument_list; 84, return_statement; 84, 85; 85, list_comprehension; 85, 86; 85, 102; 86, call; 86, 87; 86, 88; 87, identifier:Afdeling; 88, argument_list; 88, 89; 88, 94; 88, 99; 89, keyword_argument; 89, 90; 89, 91; 90, identifier:id; 91, subscript; 91, 92; 91, 93; 92, identifier:r; 93, string:'departmentCode'; 94, keyword_argument; 94, 95; 94, 96; 95, identifier:naam; 96, subscript; 96, 97; 96, 98; 97, identifier:r; 98, string:'departmentName'; 99, keyword_argument; 99, 100; 99, 101; 100, identifier:gemeente; 101, identifier:gemeente; 102, for_in_clause; 102, 103; 102, 104; 103, identifier:r; 104, subscript; 104, 105; 104, 106; 105, identifier:res; 106, string:'departments'; 107, if_statement; 107, 108; 107, 115; 107, 135; 108, attribute; 108, 109; 108, 114; 109, subscript; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:caches; 113, string:'permanent'; 114, identifier:is_configured; 115, block; 115, 116; 115, 121; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 117, 120; 118, identifier:key; 119, ERROR; 120, identifier:list_kadastrale_afdelingen_by_gemeente_rest; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:afdelingen; 124, call; 124, 125; 124, 132; 125, attribute; 125, 126; 125, 131; 126, subscript; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:caches; 130, string:'permanent'; 131, identifier:get_or_create; 132, argument_list; 132, 133; 132, 134; 133, identifier:key; 134, identifier:creator; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:afdelingen; 140, call; 140, 141; 140, 142; 141, identifier:creator; 142, argument_list; 143, for_statement; 143, 144; 143, 145; 143, 146; 144, identifier:a; 145, identifier:afdelingen; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:a; 151, identifier:set_gateway; 152, argument_list; 152, 153; 153, identifier:self; 154, return_statement; 154, 155; 155, identifier:afdelingen | def list_kadastrale_afdelingen_by_gemeente(self, gemeente, sort=1):
'''
List all `kadastrale afdelingen` in a `gemeente`.
:param gemeente: The :class:`Gemeente` for which the \
`afdelingen` are wanted.
:param integer sort: Field to sort on.
:rtype: A :class:`list` of :class:`Afdeling`.
'''
try:
gid = gemeente.id
except AttributeError:
gid = gemeente
gemeente = self.get_gemeente_by_id(gid)
gemeente.clear_gateway()
def creator():
url = self.base_url + '/municipality/%s/department' % gid
h = self.base_headers
p = {
'orderbyCode': sort == 1
}
res = capakey_rest_gateway_request(url, h, p).json()
return [
Afdeling(
id=r['departmentCode'],
naam=r['departmentName'],
gemeente=gemeente
) for r in res['departments']]
if self.caches['permanent'].is_configured:
key = 'list_kadastrale_afdelingen_by_gemeente_rest
afdelingen = self.caches['permanent'].get_or_create(key, creator)
else:
afdelingen = creator()
for a in afdelingen:
a.set_gateway(self)
return afdelingen |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:list_percelen_by_sectie; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:sectie; 6, block; 6, 7; 6, 9; 6, 15; 6, 23; 6, 33; 6, 39; 6, 107; 6, 143; 6, 154; 7, expression_statement; 7, 8; 8, string:'''
List all percelen in a `sectie`.
:param sectie: The :class:`Sectie` for which the percelen are wanted.
:param integer sort: Field to sort on.
:rtype: A :class:`list` of :class:`Perceel`.
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:sid; 12, attribute; 12, 13; 12, 14; 13, identifier:sectie; 14, identifier:id; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:aid; 18, attribute; 18, 19; 18, 22; 19, attribute; 19, 20; 19, 21; 20, identifier:sectie; 21, identifier:afdeling; 22, identifier:id; 23, expression_statement; 23, 24; 24, assignment; 24, 25; 24, 26; 25, identifier:gid; 26, attribute; 26, 27; 26, 32; 27, attribute; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:sectie; 30, identifier:afdeling; 31, identifier:gemeente; 32, identifier:id; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:sectie; 37, identifier:clear_gateway; 38, argument_list; 39, function_definition; 39, 40; 39, 41; 39, 42; 40, function_name:creator; 41, parameters; 42, block; 42, 43; 42, 56; 42, 62; 42, 69; 42, 82; 43, expression_statement; 43, 44; 44, assignment; 44, 45; 44, 46; 45, identifier:url; 46, binary_operator:+; 46, 47; 46, 50; 47, attribute; 47, 48; 47, 49; 48, identifier:self; 49, identifier:base_url; 50, binary_operator:%; 50, 51; 50, 52; 51, string:'/municipality/%s/department/%s/section/%s/parcel'; 52, tuple; 52, 53; 52, 54; 52, 55; 53, identifier:gid; 54, identifier:aid; 55, identifier:sid; 56, expression_statement; 56, 57; 57, assignment; 57, 58; 57, 59; 58, identifier:h; 59, attribute; 59, 60; 59, 61; 60, identifier:self; 61, identifier:base_headers; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:p; 65, dictionary; 65, 66; 66, pair; 66, 67; 66, 68; 67, string:'data'; 68, string:'adp'; 69, expression_statement; 69, 70; 70, assignment; 70, 71; 70, 72; 71, identifier:res; 72, call; 72, 73; 72, 81; 73, attribute; 73, 74; 73, 80; 74, call; 74, 75; 74, 76; 75, identifier:capakey_rest_gateway_request; 76, argument_list; 76, 77; 76, 78; 76, 79; 77, identifier:url; 78, identifier:h; 79, identifier:p; 80, identifier:json; 81, argument_list; 82, return_statement; 82, 83; 83, list_comprehension; 83, 84; 83, 102; 84, call; 84, 85; 84, 86; 85, identifier:Perceel; 86, argument_list; 86, 87; 86, 90; 86, 91; 86, 94; 87, subscript; 87, 88; 87, 89; 88, identifier:r; 89, string:'perceelnummer'; 90, identifier:sectie; 91, subscript; 91, 92; 91, 93; 92, identifier:r; 93, string:'capakey'; 94, call; 94, 95; 94, 98; 95, attribute; 95, 96; 95, 97; 96, identifier:self; 97, identifier:parse_percid; 98, argument_list; 98, 99; 99, subscript; 99, 100; 99, 101; 100, identifier:r; 101, string:'capakey'; 102, for_in_clause; 102, 103; 102, 104; 103, identifier:r; 104, subscript; 104, 105; 104, 106; 105, identifier:res; 106, string:'parcels'; 107, if_statement; 107, 108; 107, 115; 107, 135; 108, attribute; 108, 109; 108, 114; 109, subscript; 109, 110; 109, 113; 110, attribute; 110, 111; 110, 112; 111, identifier:self; 112, identifier:caches; 113, string:'short'; 114, identifier:is_configured; 115, block; 115, 116; 115, 121; 116, expression_statement; 116, 117; 117, assignment; 117, 118; 117, 119; 117, 120; 118, identifier:key; 119, ERROR; 120, identifier:list_percelen_by_sectie_rest; 121, expression_statement; 121, 122; 122, assignment; 122, 123; 122, 124; 123, identifier:percelen; 124, call; 124, 125; 124, 132; 125, attribute; 125, 126; 125, 131; 126, subscript; 126, 127; 126, 130; 127, attribute; 127, 128; 127, 129; 128, identifier:self; 129, identifier:caches; 130, string:'short'; 131, identifier:get_or_create; 132, argument_list; 132, 133; 132, 134; 133, identifier:key; 134, identifier:creator; 135, else_clause; 135, 136; 136, block; 136, 137; 137, expression_statement; 137, 138; 138, assignment; 138, 139; 138, 140; 139, identifier:percelen; 140, call; 140, 141; 140, 142; 141, identifier:creator; 142, argument_list; 143, for_statement; 143, 144; 143, 145; 143, 146; 144, identifier:p; 145, identifier:percelen; 146, block; 146, 147; 147, expression_statement; 147, 148; 148, call; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:p; 151, identifier:set_gateway; 152, argument_list; 152, 153; 153, identifier:self; 154, return_statement; 154, 155; 155, identifier:percelen | def list_percelen_by_sectie(self, sectie):
'''
List all percelen in a `sectie`.
:param sectie: The :class:`Sectie` for which the percelen are wanted.
:param integer sort: Field to sort on.
:rtype: A :class:`list` of :class:`Perceel`.
'''
sid = sectie.id
aid = sectie.afdeling.id
gid = sectie.afdeling.gemeente.id
sectie.clear_gateway()
def creator():
url = self.base_url + '/municipality/%s/department/%s/section/%s/parcel' % (gid, aid, sid)
h = self.base_headers
p = {
'data': 'adp'
}
res = capakey_rest_gateway_request(url, h, p).json()
return [
Perceel(
r['perceelnummer'],
sectie,
r['capakey'],
self.parse_percid(r['capakey']),
) for r in res['parcels']
]
if self.caches['short'].is_configured:
key = 'list_percelen_by_sectie_rest
percelen = self.caches['short'].get_or_create(key, creator)
else:
percelen = creator()
for p in percelen:
p.set_gateway(self)
return percelen |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 14; 2, function_name:get_urls; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:order; 7, string:"total_clicks desc"; 8, default_parameter; 8, 9; 8, 10; 9, identifier:offset; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:count; 13, None; 14, block; 14, 15; 14, 26; 15, expression_statement; 15, 16; 16, assignment; 16, 17; 16, 18; 17, identifier:req_data; 18, list:[ None, order, fmt_paging(offset, count) ]; 18, 19; 18, 20; 18, 21; 19, None; 20, identifier:order; 21, call; 21, 22; 21, 23; 22, identifier:fmt_paging; 23, argument_list; 23, 24; 23, 25; 24, identifier:offset; 25, identifier:count; 26, return_statement; 26, 27; 27, call; 27, 28; 27, 31; 28, attribute; 28, 29; 28, 30; 29, identifier:self; 30, identifier:request; 31, argument_list; 31, 32; 31, 33; 32, string:"query:Message_Url"; 33, identifier:req_data | def get_urls(self, order="total_clicks desc", offset=None, count=None):
req_data = [ None, order, fmt_paging(offset, count) ]
return self.request("query:Message_Url", req_data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:get_message_urls; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:message_id; 6, default_parameter; 6, 7; 6, 8; 7, identifier:order; 8, string:"total_clicks desc"; 9, block; 9, 10; 9, 23; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:req_data; 13, list:[ { "message_id": str(message_id) }, order, None ]; 13, 14; 13, 21; 13, 22; 14, dictionary; 14, 15; 15, pair; 15, 16; 15, 17; 16, string:"message_id"; 17, call; 17, 18; 17, 19; 18, identifier:str; 19, argument_list; 19, 20; 20, identifier:message_id; 21, identifier:order; 22, None; 23, return_statement; 23, 24; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:request; 28, argument_list; 28, 29; 28, 30; 29, string:"query:Message_Url"; 30, identifier:req_data | def get_message_urls(self, message_id, order="total_clicks desc"):
req_data = [ { "message_id": str(message_id) }, order, None ]
return self.request("query:Message_Url", req_data) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 29; 2, function_name:trade_history; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 3, 26; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:from_; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:count; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:from_id; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:end_id; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:order; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:since; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:end; 25, None; 26, default_parameter; 26, 27; 26, 28; 27, identifier:pair; 28, None; 29, block; 29, 30; 30, return_statement; 30, 31; 31, call; 31, 32; 31, 35; 32, attribute; 32, 33; 32, 34; 33, identifier:self; 34, identifier:_trade_api_call; 35, argument_list; 35, 36; 35, 37; 35, 40; 35, 43; 35, 46; 35, 49; 35, 52; 35, 55; 35, 58; 36, string:'TradeHistory'; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:from_; 39, identifier:from_; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:count; 42, identifier:count; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:from_id; 45, identifier:from_id; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:end_id; 48, identifier:end_id; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:order; 51, identifier:order; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:since; 54, identifier:since; 55, keyword_argument; 55, 56; 55, 57; 56, identifier:end; 57, identifier:end; 58, keyword_argument; 58, 59; 58, 60; 59, identifier:pair; 60, identifier:pair | def trade_history(
self, from_=None, count=None, from_id=None, end_id=None,
order=None, since=None, end=None, pair=None
):
return self._trade_api_call(
'TradeHistory', from_=from_, count=count, from_id=from_id, end_id=end_id,
order=order, since=since, end=end, pair=pair
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 26; 2, function_name:trans_history; 3, parameters; 3, 4; 3, 5; 3, 8; 3, 11; 3, 14; 3, 17; 3, 20; 3, 23; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:from_; 7, None; 8, default_parameter; 8, 9; 8, 10; 9, identifier:count; 10, None; 11, default_parameter; 11, 12; 11, 13; 12, identifier:from_id; 13, None; 14, default_parameter; 14, 15; 14, 16; 15, identifier:end_id; 16, None; 17, default_parameter; 17, 18; 17, 19; 18, identifier:order; 19, None; 20, default_parameter; 20, 21; 20, 22; 21, identifier:since; 22, None; 23, default_parameter; 23, 24; 23, 25; 24, identifier:end; 25, None; 26, block; 26, 27; 27, return_statement; 27, 28; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:self; 31, identifier:_trade_api_call; 32, argument_list; 32, 33; 32, 34; 32, 37; 32, 40; 32, 43; 32, 46; 32, 49; 32, 52; 33, string:'TransHistory'; 34, keyword_argument; 34, 35; 34, 36; 35, identifier:from_; 36, identifier:from_; 37, keyword_argument; 37, 38; 37, 39; 38, identifier:count; 39, identifier:count; 40, keyword_argument; 40, 41; 40, 42; 41, identifier:from_id; 42, identifier:from_id; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:end_id; 45, identifier:end_id; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:order; 48, identifier:order; 49, keyword_argument; 49, 50; 49, 51; 50, identifier:since; 51, identifier:since; 52, keyword_argument; 52, 53; 52, 54; 53, identifier:end; 54, identifier:end | def trans_history(
self, from_=None, count=None, from_id=None, end_id=None,
order=None, since=None, end=None
):
return self._trade_api_call(
'TransHistory', from_=from_, count=count, from_id=from_id, end_id=end_id,
order=order, since=since, end=end
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_atom_type_symbol; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:cls; 5, identifier:calc; 6, dictionary_splat_pattern; 6, 7; 7, identifier:kwargs; 8, block; 8, 9; 8, 17; 8, 25; 8, 36; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:parameters; 12, attribute; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:calc; 15, identifier:out; 16, identifier:output; 17, expression_statement; 17, 18; 18, assignment; 18, 19; 18, 20; 19, identifier:dictionary; 20, call; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:parameters; 23, identifier:get_dict; 24, argument_list; 25, if_statement; 25, 26; 25, 33; 26, comparison_operator:not; 26, 27; 26, 28; 27, string:'basis_set'; 28, call; 28, 29; 28, 32; 29, attribute; 29, 30; 29, 31; 30, identifier:dictionary; 31, identifier:keys; 32, argument_list; 33, block; 33, 34; 34, return_statement; 34, 35; 35, None; 36, return_statement; 36, 37; 37, call; 37, 38; 37, 39; 38, identifier:sorted; 39, argument_list; 39, 40; 40, call; 40, 41; 40, 46; 41, attribute; 41, 42; 41, 45; 42, subscript; 42, 43; 42, 44; 43, identifier:dictionary; 44, string:'basis_set'; 45, identifier:keys; 46, argument_list | def get_atom_type_symbol(cls,calc,**kwargs):
parameters = calc.out.output
dictionary = parameters.get_dict()
if 'basis_set' not in dictionary.keys():
return None
return sorted(dictionary['basis_set'].keys()) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_url; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 19; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:prefix; 9, boolean_operator:or; 9, 10; 9, 18; 10, boolean_operator:and; 10, 11; 10, 17; 11, parenthesized_expression; 11, 12; 12, comparison_operator:==; 12, 13; 12, 16; 13, attribute; 13, 14; 13, 15; 14, identifier:self; 15, identifier:sort_direction; 16, string:"asc"; 17, string:"-"; 18, string:""; 19, return_statement; 19, 20; 20, call; 20, 21; 20, 26; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:self; 24, identifier:table; 25, identifier:get_url; 26, argument_list; 26, 27; 27, keyword_argument; 27, 28; 27, 29; 28, identifier:order_by; 29, binary_operator:+; 29, 30; 29, 31; 30, identifier:prefix; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:name | def sort_url(self):
prefix = (self.sort_direction == "asc") and "-" or ""
return self.table.get_url(order_by=prefix + self.name) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:append; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:newconfig; 6, block; 6, 7; 6, 52; 6, 102; 6, 115; 6, 136; 7, for_statement; 7, 8; 7, 9; 7, 21; 8, identifier:attr_name; 9, tuple; 9, 10; 9, 11; 9, 12; 9, 13; 9, 14; 9, 15; 9, 16; 9, 17; 9, 18; 9, 19; 9, 20; 10, string:'title'; 11, string:'body'; 12, string:'author'; 13, string:'date'; 14, string:'strip'; 15, string:'strip_id_or_class'; 16, string:'strip_image_src'; 17, string:'single_page_link'; 18, string:'single_page_link_in_feed'; 19, string:'next_page_link'; 20, string:'http_header'; 21, block; 21, 22; 21, 30; 21, 45; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:current_set; 25, call; 25, 26; 25, 27; 26, identifier:getattr; 27, argument_list; 27, 28; 27, 29; 28, identifier:self; 29, identifier:attr_name; 30, for_statement; 30, 31; 30, 32; 30, 37; 31, identifier:val; 32, call; 32, 33; 32, 34; 33, identifier:getattr; 34, argument_list; 34, 35; 34, 36; 35, identifier:newconfig; 36, identifier:attr_name; 37, block; 37, 38; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, identifier:current_set; 42, identifier:add; 43, argument_list; 43, 44; 44, identifier:val; 45, expression_statement; 45, 46; 46, call; 46, 47; 46, 48; 47, identifier:setattr; 48, argument_list; 48, 49; 48, 50; 48, 51; 49, identifier:self; 50, identifier:attr_name; 51, identifier:current_set; 52, for_statement; 52, 53; 52, 54; 52, 59; 53, identifier:attr_name; 54, tuple; 54, 55; 54, 56; 54, 57; 54, 58; 55, string:'parser'; 56, string:'tidy'; 57, string:'prune'; 58, string:'autodetect_on_failure'; 59, block; 59, 60; 60, if_statement; 60, 61; 60, 68; 61, comparison_operator:is; 61, 62; 61, 67; 62, call; 62, 63; 62, 64; 63, identifier:getattr; 64, argument_list; 64, 65; 64, 66; 65, identifier:self; 66, identifier:attr_name; 67, None; 68, block; 68, 69; 69, if_statement; 69, 70; 69, 77; 69, 89; 70, comparison_operator:is; 70, 71; 70, 76; 71, call; 71, 72; 71, 73; 72, identifier:getattr; 73, argument_list; 73, 74; 73, 75; 74, identifier:newconfig; 75, identifier:attr_name; 76, None; 77, block; 77, 78; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:setattr; 81, argument_list; 81, 82; 81, 83; 81, 84; 82, identifier:self; 83, identifier:attr_name; 84, subscript; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:defaults; 88, identifier:attr_name; 89, else_clause; 89, 90; 90, block; 90, 91; 91, expression_statement; 91, 92; 92, call; 92, 93; 92, 94; 93, identifier:setattr; 94, argument_list; 94, 95; 94, 96; 94, 97; 95, identifier:self; 96, identifier:attr_name; 97, call; 97, 98; 97, 99; 98, identifier:getattr; 99, argument_list; 99, 100; 99, 101; 100, identifier:newconfig; 101, identifier:attr_name; 102, if_statement; 102, 103; 102, 108; 103, comparison_operator:==; 103, 104; 103, 107; 104, attribute; 104, 105; 104, 106; 105, identifier:self; 106, identifier:parser; 107, string:'libxml'; 108, block; 108, 109; 109, expression_statement; 109, 110; 110, assignment; 110, 111; 110, 114; 111, attribute; 111, 112; 111, 113; 112, identifier:self; 113, identifier:parser; 114, string:'lxml'; 115, for_statement; 115, 116; 115, 117; 115, 120; 116, identifier:attr_name; 117, tuple; 117, 118; 117, 119; 118, string:'find_string'; 119, string:'replace_string'; 120, block; 120, 121; 121, expression_statement; 121, 122; 122, call; 122, 123; 122, 130; 123, attribute; 123, 124; 123, 129; 124, call; 124, 125; 124, 126; 125, identifier:getattr; 126, argument_list; 126, 127; 126, 128; 127, identifier:self; 128, identifier:attr_name; 129, identifier:extend; 130, argument_list; 130, 131; 131, call; 131, 132; 131, 133; 132, identifier:getattr; 133, argument_list; 133, 134; 133, 135; 134, identifier:newconfig; 135, identifier:attr_name; 136, if_statement; 136, 137; 136, 140; 136, 155; 137, attribute; 137, 138; 137, 139; 138, identifier:self; 139, identifier:find_string; 140, block; 140, 141; 141, expression_statement; 141, 142; 142, assignment; 142, 143; 142, 146; 143, attribute; 143, 144; 143, 145; 144, identifier:self; 145, identifier:replace_patterns; 146, call; 146, 147; 146, 148; 147, identifier:zip; 148, argument_list; 148, 149; 148, 152; 149, attribute; 149, 150; 149, 151; 150, identifier:self; 151, identifier:find_string; 152, attribute; 152, 153; 152, 154; 153, identifier:self; 154, identifier:replace_string; 155, else_clause; 155, 156; 156, block; 156, 157; 157, expression_statement; 157, 158; 158, assignment; 158, 159; 158, 162; 159, attribute; 159, 160; 159, 161; 160, identifier:self; 161, identifier:replace_patterns; 162, None | def append(self, newconfig):
for attr_name in (
'title', 'body', 'author', 'date',
'strip', 'strip_id_or_class', 'strip_image_src',
'single_page_link', 'single_page_link_in_feed',
'next_page_link', 'http_header'
):
current_set = getattr(self, attr_name)
for val in getattr(newconfig, attr_name):
current_set.add(val)
setattr(self, attr_name, current_set)
for attr_name in (
'parser', 'tidy', 'prune', 'autodetect_on_failure'
):
if getattr(self, attr_name) is None:
if getattr(newconfig, attr_name) is None:
setattr(self, attr_name, self.defaults[attr_name])
else:
setattr(self, attr_name, getattr(newconfig, attr_name))
if self.parser == 'libxml':
self.parser = 'lxml'
for attr_name in ('find_string', 'replace_string', ):
getattr(self, attr_name).extend(getattr(newconfig, attr_name))
if self.find_string:
self.replace_patterns = zip(
self.find_string, self.replace_string)
else:
self.replace_patterns = None |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:__exportUsers; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:self; 5, identifier:sort; 6, default_parameter; 6, 7; 6, 8; 7, identifier:limit; 8, integer:0; 9, block; 9, 10; 9, 14; 9, 23; 9, 34; 9, 38; 9, 81; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:position; 13, integer:1; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:dataUsers; 17, call; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:self; 20, identifier:getSortedUsers; 21, argument_list; 21, 22; 22, identifier:sort; 23, if_statement; 23, 24; 23, 25; 24, identifier:limit; 25, block; 25, 26; 26, expression_statement; 26, 27; 27, assignment; 27, 28; 27, 29; 28, identifier:dataUsers; 29, subscript; 29, 30; 29, 31; 30, identifier:dataUsers; 31, slice; 31, 32; 31, 33; 32, colon; 33, identifier:limit; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:exportedUsers; 37, list:[]; 38, for_statement; 38, 39; 38, 40; 38, 41; 39, identifier:u; 40, identifier:dataUsers; 41, block; 41, 42; 41, 50; 41, 56; 41, 63; 41, 77; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:userExported; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:u; 48, identifier:export; 49, argument_list; 50, expression_statement; 50, 51; 51, assignment; 51, 52; 51, 55; 52, subscript; 52, 53; 52, 54; 53, identifier:userExported; 54, string:"position"; 55, identifier:position; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:exportedUsers; 60, identifier:append; 61, argument_list; 61, 62; 62, identifier:userExported; 63, if_statement; 63, 64; 63, 70; 64, comparison_operator:<; 64, 65; 64, 66; 65, identifier:position; 66, call; 66, 67; 66, 68; 67, identifier:len; 68, argument_list; 68, 69; 69, identifier:dataUsers; 70, block; 70, 71; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, subscript; 73, 74; 73, 75; 74, identifier:userExported; 75, string:"comma"; 76, True; 77, expression_statement; 77, 78; 78, augmented_assignment:+=; 78, 79; 78, 80; 79, identifier:position; 80, integer:1; 81, return_statement; 81, 82; 82, identifier:exportedUsers | def __exportUsers(self, sort, limit=0):
position = 1
dataUsers = self.getSortedUsers(sort)
if limit:
dataUsers = dataUsers[:limit]
exportedUsers = []
for u in dataUsers:
userExported = u.export()
userExported["position"] = position
exportedUsers.append(userExported)
if position < len(dataUsers):
userExported["comma"] = True
position += 1
return exportedUsers |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 4; 2, function_name:zset_example; 3, parameters; 4, block; 4, 5; 4, 10; 4, 15; 4, 21; 4, 27; 4, 40; 4, 62; 4, 71; 4, 78; 4, 85; 4, 92; 4, 101; 4, 106; 4, 113; 5, import_from_statement; 5, 6; 5, 8; 6, dotted_name; 6, 7; 7, identifier:uuid; 8, dotted_name; 8, 9; 9, identifier:uuid4; 10, import_from_statement; 10, 11; 10, 13; 11, dotted_name; 11, 12; 12, identifier:redis; 13, dotted_name; 13, 14; 14, identifier:StrictRedis; 15, import_from_statement; 15, 16; 15, 19; 16, dotted_name; 16, 17; 16, 18; 17, identifier:zato; 18, identifier:redis_paginator; 19, dotted_name; 19, 20; 20, identifier:ZSetPaginator; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:conn; 24, call; 24, 25; 24, 26; 25, identifier:StrictRedis; 26, argument_list; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:key; 30, call; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, string:'paginator:{}'; 33, identifier:format; 34, argument_list; 34, 35; 35, attribute; 35, 36; 35, 39; 36, call; 36, 37; 36, 38; 37, identifier:uuid4; 38, argument_list; 39, identifier:hex; 40, for_statement; 40, 41; 40, 42; 40, 47; 41, identifier:x; 42, call; 42, 43; 42, 44; 43, identifier:range; 44, argument_list; 44, 45; 44, 46; 45, integer:1; 46, integer:18; 47, block; 47, 48; 48, expression_statement; 48, 49; 49, call; 49, 50; 49, 53; 50, attribute; 50, 51; 50, 52; 51, identifier:conn; 52, identifier:zadd; 53, argument_list; 53, 54; 53, 55; 53, 56; 54, identifier:key; 55, identifier:x; 56, call; 56, 57; 56, 58; 57, identifier:chr; 58, argument_list; 58, 59; 59, binary_operator:+; 59, 60; 59, 61; 60, integer:96; 61, identifier:x; 62, expression_statement; 62, 63; 63, assignment; 63, 64; 63, 65; 64, identifier:p; 65, call; 65, 66; 65, 67; 66, identifier:ZSetPaginator; 67, argument_list; 67, 68; 67, 69; 67, 70; 68, identifier:conn; 69, identifier:key; 70, integer:6; 71, expression_statement; 71, 72; 72, call; 72, 73; 72, 74; 73, identifier:print; 74, argument_list; 74, 75; 75, attribute; 75, 76; 75, 77; 76, identifier:p; 77, identifier:count; 78, expression_statement; 78, 79; 79, call; 79, 80; 79, 81; 80, identifier:print; 81, argument_list; 81, 82; 82, attribute; 82, 83; 82, 84; 83, identifier:p; 84, identifier:num_pages; 85, expression_statement; 85, 86; 86, call; 86, 87; 86, 88; 87, identifier:print; 88, argument_list; 88, 89; 89, attribute; 89, 90; 89, 91; 90, identifier:p; 91, identifier:page_range; 92, expression_statement; 92, 93; 93, assignment; 93, 94; 93, 95; 94, identifier:page; 95, call; 95, 96; 95, 99; 96, attribute; 96, 97; 96, 98; 97, identifier:p; 98, identifier:page; 99, argument_list; 99, 100; 100, integer:3; 101, expression_statement; 101, 102; 102, call; 102, 103; 102, 104; 103, identifier:print; 104, argument_list; 104, 105; 105, identifier:page; 106, expression_statement; 106, 107; 107, call; 107, 108; 107, 109; 108, identifier:print; 109, argument_list; 109, 110; 110, attribute; 110, 111; 110, 112; 111, identifier:page; 112, identifier:object_list; 113, expression_statement; 113, 114; 114, call; 114, 115; 114, 118; 115, attribute; 115, 116; 115, 117; 116, identifier:conn; 117, identifier:delete; 118, argument_list; 118, 119; 119, identifier:key | def zset_example():
from uuid import uuid4
from redis import StrictRedis
from zato.redis_paginator import ZSetPaginator
conn = StrictRedis()
key = 'paginator:{}'.format(uuid4().hex)
for x in range(1, 18):
conn.zadd(key, x, chr(96 + x))
p = ZSetPaginator(conn, key, 6)
print(p.count)
print(p.num_pages)
print(p.page_range)
page = p.page(3)
print(page)
print(page.object_list)
conn.delete(key) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:paths_by_depth; 3, parameters; 3, 4; 4, identifier:paths; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 11; 9, 26; 10, identifier:paths; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:key; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:path; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:path; 19, identifier:count; 20, argument_list; 20, 21; 21, attribute; 21, 22; 21, 25; 22, attribute; 22, 23; 22, 24; 23, identifier:os; 24, identifier:path; 25, identifier:sep; 26, keyword_argument; 26, 27; 26, 28; 27, identifier:reverse; 28, True | def paths_by_depth(paths):
return sorted(
paths,
key=lambda path: path.count(os.path.sep),
reverse=True
) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:normalize_date; 3, parameters; 3, 4; 4, identifier:date; 5, block; 5, 6; 5, 8; 5, 117; 6, expression_statement; 6, 7; 7, string:'''normalize the specified date to milliseconds since the epoch
If it is a string, it is assumed to be some sort of datetime such as
"2015-12-27" or "2015-12-27T11:01:20.954". If date is a naive datetime,
it is assumed to be UTC.
If numeric arguments are beyond 5138-11-16 (100,000,000,000 seconds
after epoch), they are interpreted as milliseconds since the epoch.
'''; 8, if_statement; 8, 9; 8, 14; 8, 16; 8, 32; 8, 101; 9, call; 9, 10; 9, 11; 10, identifier:isinstance; 11, argument_list; 11, 12; 11, 13; 12, identifier:date; 13, identifier:datetime; 14, block; 14, 15; 15, pass_statement; 16, elif_clause; 16, 17; 16, 20; 17, comparison_operator:==; 17, 18; 17, 19; 18, identifier:date; 19, string:"now"; 20, block; 20, 21; 21, expression_statement; 21, 22; 22, assignment; 22, 23; 22, 24; 23, identifier:date; 24, call; 24, 25; 24, 28; 25, attribute; 25, 26; 25, 27; 26, identifier:datetime; 27, identifier:now; 28, argument_list; 28, 29; 29, attribute; 29, 30; 29, 31; 30, identifier:pytz; 31, identifier:UTC; 32, elif_clause; 32, 33; 32, 42; 33, call; 33, 34; 33, 35; 34, identifier:isinstance; 35, argument_list; 35, 36; 35, 37; 36, identifier:date; 37, tuple; 37, 38; 37, 39; 37, 40; 37, 41; 38, identifier:basestring; 39, identifier:int; 40, identifier:float; 41, identifier:long; 42, block; 42, 43; 43, try_statement; 43, 44; 43, 75; 44, block; 44, 45; 44, 52; 44, 63; 45, expression_statement; 45, 46; 46, assignment; 46, 47; 46, 48; 47, identifier:ts; 48, call; 48, 49; 48, 50; 49, identifier:float; 50, argument_list; 50, 51; 51, identifier:date; 52, if_statement; 52, 53; 52, 56; 53, comparison_operator:>; 53, 54; 53, 55; 54, identifier:ts; 55, identifier:MAX_TS_SECONDS; 56, block; 56, 57; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:ts; 60, binary_operator:/; 60, 61; 60, 62; 61, identifier:ts; 62, float:1000.0; 63, expression_statement; 63, 64; 64, assignment; 64, 65; 64, 66; 65, identifier:date; 66, call; 66, 67; 66, 70; 67, attribute; 67, 68; 67, 69; 68, identifier:datetime; 69, identifier:utcfromtimestamp; 70, argument_list; 70, 71; 71, call; 71, 72; 71, 73; 72, identifier:float; 73, argument_list; 73, 74; 74, identifier:ts; 75, except_clause; 75, 76; 75, 77; 76, identifier:ValueError; 77, block; 77, 78; 78, try_statement; 78, 79; 78, 87; 79, block; 79, 80; 80, expression_statement; 80, 81; 81, assignment; 81, 82; 81, 83; 82, identifier:date; 83, call; 83, 84; 83, 85; 84, identifier:dateparse; 85, argument_list; 85, 86; 86, identifier:date; 87, except_clause; 87, 88; 87, 92; 88, as_pattern; 88, 89; 88, 90; 89, identifier:ValueError; 90, as_pattern_target; 90, 91; 91, identifier:e; 92, block; 92, 93; 93, raise_statement; 93, 94; 94, call; 94, 95; 94, 96; 95, identifier:InvalidDatalakeMetadata; 96, argument_list; 96, 97; 97, call; 97, 98; 97, 99; 98, identifier:str; 99, argument_list; 99, 100; 100, identifier:e; 101, else_clause; 101, 102; 102, block; 102, 103; 102, 112; 103, expression_statement; 103, 104; 104, assignment; 104, 105; 104, 106; 105, identifier:msg; 106, call; 106, 107; 106, 110; 107, attribute; 107, 108; 107, 109; 108, string:'could not parse a date from {!r}'; 109, identifier:format; 110, argument_list; 110, 111; 111, identifier:date; 112, raise_statement; 112, 113; 113, call; 113, 114; 113, 115; 114, identifier:InvalidDatalakeMetadata; 115, argument_list; 115, 116; 116, identifier:msg; 117, return_statement; 117, 118; 118, call; 118, 119; 118, 122; 119, attribute; 119, 120; 119, 121; 120, identifier:Metadata; 121, identifier:_from_datetime; 122, argument_list; 122, 123; 123, identifier:date | def normalize_date(date):
'''normalize the specified date to milliseconds since the epoch
If it is a string, it is assumed to be some sort of datetime such as
"2015-12-27" or "2015-12-27T11:01:20.954". If date is a naive datetime,
it is assumed to be UTC.
If numeric arguments are beyond 5138-11-16 (100,000,000,000 seconds
after epoch), they are interpreted as milliseconds since the epoch.
'''
if isinstance(date, datetime):
pass
elif date == "now":
date = datetime.now(pytz.UTC)
elif isinstance(date, (basestring, int, float, long)):
try:
ts = float(date)
if ts > MAX_TS_SECONDS:
ts = ts / 1000.0
date = datetime.utcfromtimestamp(float(ts))
except ValueError:
try:
date = dateparse(date)
except ValueError as e:
raise InvalidDatalakeMetadata(str(e))
else:
msg = 'could not parse a date from {!r}'.format(date)
raise InvalidDatalakeMetadata(msg)
return Metadata._from_datetime(date) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:format_float; 3, parameters; 3, 4; 3, 5; 4, identifier:x; 5, identifier:max_width; 6, block; 6, 7; 6, 9; 6, 28; 6, 37; 6, 46; 7, expression_statement; 7, 8; 8, string:'''format_float will ensure that a number's decimal part is truncated to
fit within some bounds, unless the whole part is wider than max_width,
which is a problem you need to sort out yourself.
'''; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:whole_width; 12, binary_operator:+; 12, 13; 12, 27; 13, call; 13, 14; 13, 15; 14, identifier:int; 15, argument_list; 15, 16; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:math; 19, identifier:log10; 20, argument_list; 20, 21; 21, binary_operator:+; 21, 22; 21, 26; 22, call; 22, 23; 22, 24; 23, identifier:abs; 24, argument_list; 24, 25; 25, identifier:x; 26, integer:1; 27, integer:1; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:sign_width; 31, conditional_expression:if; 31, 32; 31, 33; 31, 36; 32, integer:1; 33, comparison_operator:<; 33, 34; 33, 35; 34, identifier:x; 35, integer:0; 36, integer:0; 37, expression_statement; 37, 38; 38, assignment; 38, 39; 38, 40; 39, identifier:decimal_point_width; 40, conditional_expression:if; 40, 41; 40, 42; 40, 45; 41, integer:1; 42, comparison_operator:>=; 42, 43; 42, 44; 43, identifier:max_width; 44, identifier:whole_width; 45, integer:0; 46, return_statement; 46, 47; 47, binary_operator:%; 47, 48; 47, 49; 48, string:'%.*f'; 49, tuple; 49, 50; 49, 57; 50, binary_operator:-; 50, 51; 50, 56; 51, binary_operator:-; 51, 52; 51, 55; 52, binary_operator:-; 52, 53; 52, 54; 53, identifier:max_width; 54, identifier:whole_width; 55, identifier:sign_width; 56, identifier:decimal_point_width; 57, identifier:x | def format_float(x, max_width):
'''format_float will ensure that a number's decimal part is truncated to
fit within some bounds, unless the whole part is wider than max_width,
which is a problem you need to sort out yourself.
'''
whole_width = int(math.log10(abs(x) + 1)) + 1
sign_width = 1 if x < 0 else 0
decimal_point_width = 1 if max_width >= whole_width else 0
return '%.*f' % (max_width - whole_width - sign_width - decimal_point_width, x) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:__cleanup; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 14; 5, 53; 5, 75; 5, 82; 5, 90; 5, 97; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 13; 8, attribute; 8, 9; 8, 12; 9, attribute; 9, 10; 9, 11; 10, identifier:self; 11, identifier:_run; 12, identifier:value; 13, False; 14, if_statement; 14, 15; 14, 38; 14, 46; 15, call; 15, 16; 15, 17; 16, identifier:check_process_termination; 17, argument_list; 17, 18; 17, 23; 17, 30; 17, 33; 18, keyword_argument; 18, 19; 18, 20; 19, identifier:proc; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_proc; 23, keyword_argument; 23, 24; 23, 25; 24, identifier:timeout; 25, binary_operator:*; 25, 26; 25, 27; 26, integer:2; 27, attribute; 27, 28; 27, 29; 28, identifier:self; 29, identifier:interval; 30, keyword_argument; 30, 31; 30, 32; 31, identifier:prefix; 32, string:''; 33, keyword_argument; 33, 34; 33, 35; 34, identifier:auto_kill_on_last_resort; 35, attribute; 35, 36; 35, 37; 36, identifier:self; 37, identifier:_auto_kill_on_last_resort; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:log; 43, identifier:debug; 44, argument_list; 44, 45; 45, string:"cleanup successful"; 46, else_clause; 46, 47; 47, block; 47, 48; 48, raise_statement; 48, 49; 49, call; 49, 50; 49, 51; 50, identifier:RuntimeError; 51, argument_list; 51, 52; 52, string:"cleanup FAILED!"; 53, try_statement; 53, 54; 53, 71; 54, block; 54, 55; 54, 63; 55, expression_statement; 55, 56; 56, call; 56, 57; 56, 62; 57, attribute; 57, 58; 57, 61; 58, attribute; 58, 59; 58, 60; 59, identifier:self; 60, identifier:conn_send; 61, identifier:close; 62, argument_list; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 70; 65, attribute; 65, 66; 65, 69; 66, attribute; 66, 67; 66, 68; 67, identifier:self; 68, identifier:_log_queue_listener; 69, identifier:stop; 70, argument_list; 71, except_clause; 71, 72; 71, 73; 72, identifier:OSError; 73, block; 73, 74; 74, pass_statement; 75, expression_statement; 75, 76; 76, call; 76, 77; 76, 80; 77, attribute; 77, 78; 77, 79; 78, identifier:log; 79, identifier:debug; 80, argument_list; 80, 81; 81, string:"wait for monitor thread to join"; 82, expression_statement; 82, 83; 83, call; 83, 84; 83, 89; 84, attribute; 84, 85; 84, 88; 85, attribute; 85, 86; 85, 87; 86, identifier:self; 87, identifier:_monitor_thread; 88, identifier:join; 89, argument_list; 90, expression_statement; 90, 91; 91, call; 91, 92; 91, 95; 92, attribute; 92, 93; 92, 94; 93, identifier:log; 94, identifier:debug; 95, argument_list; 95, 96; 96, string:"monitor thread to joined"; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 104; 99, attribute; 99, 100; 99, 103; 100, attribute; 100, 101; 100, 102; 101, identifier:self; 102, identifier:_func_running; 103, identifier:value; 104, False | def __cleanup(self):
self._run.value = False
if check_process_termination(proc = self._proc,
timeout = 2*self.interval,
prefix = '',
auto_kill_on_last_resort = self._auto_kill_on_last_resort):
log.debug("cleanup successful")
else:
raise RuntimeError("cleanup FAILED!")
try:
self.conn_send.close()
self._log_queue_listener.stop()
except OSError:
pass
log.debug("wait for monitor thread to join")
self._monitor_thread.join()
log.debug("monitor thread to joined")
self._func_running.value = False |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:regroup; 3, parameters; 3, 4; 3, 5; 4, identifier:target; 5, identifier:expression; 6, block; 6, 7; 6, 13; 7, if_statement; 7, 8; 7, 10; 8, not_operator; 8, 9; 9, identifier:target; 10, block; 10, 11; 11, return_statement; 11, 12; 12, string:''; 13, return_statement; 13, 14; 14, list_comprehension; 14, 15; 14, 25; 15, dictionary; 15, 16; 15, 19; 16, pair; 16, 17; 16, 18; 17, string:'grouper'; 18, identifier:key; 19, pair; 19, 20; 19, 21; 20, string:'list'; 21, call; 21, 22; 21, 23; 22, identifier:list; 23, argument_list; 23, 24; 24, identifier:val; 25, for_in_clause; 25, 26; 25, 29; 26, pattern_list; 26, 27; 26, 28; 27, identifier:key; 28, identifier:val; 29, call; 29, 30; 29, 31; 30, identifier:groupby; 31, argument_list; 31, 32; 31, 33; 32, identifier:obj_list; 33, lambda; 33, 34; 33, 41; 34, lambda_parameters; 34, 35; 34, 36; 35, identifier:v; 36, default_parameter; 36, 37; 36, 38; 37, identifier:f; 38, attribute; 38, 39; 38, 40; 39, identifier:expression; 40, identifier:resolve; 41, call; 41, 42; 41, 43; 42, identifier:f; 43, argument_list; 43, 44; 43, 45; 44, identifier:v; 45, True | def regroup(target, expression):
if not target: return ''
return [
{'grouper': key, 'list': list(val)}
for key, val in
groupby(obj_list, lambda v, f=expression.resolve: f(v, True))
] |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 23; 2, function_name:entityTriples; 3, parameters; 3, 4; 3, 5; 3, 6; 3, 9; 3, 12; 4, identifier:rdfGraph; 5, identifier:anEntity; 6, default_parameter; 6, 7; 6, 8; 7, identifier:excludeProps; 8, False; 9, default_parameter; 9, 10; 9, 11; 10, identifier:excludeBNodes; 11, False; 12, default_parameter; 12, 13; 12, 14; 13, identifier:orderProps; 14, list:[RDF, RDFS, OWL.OWLNS, DC.DCNS]; 14, 15; 14, 16; 14, 17; 14, 20; 15, identifier:RDF; 16, identifier:RDFS; 17, attribute; 17, 18; 17, 19; 18, identifier:OWL; 19, identifier:OWLNS; 20, attribute; 20, 21; 20, 22; 21, identifier:DC; 22, identifier:DCNS; 23, block; 23, 24; 23, 28; 23, 36; 23, 72; 23, 166; 24, expression_statement; 24, 25; 25, assignment; 25, 26; 25, 27; 26, identifier:temp; 27, list:[]; 28, if_statement; 28, 29; 28, 31; 29, not_operator; 29, 30; 30, identifier:excludeProps; 31, block; 31, 32; 32, expression_statement; 32, 33; 33, assignment; 33, 34; 33, 35; 34, identifier:excludeProps; 35, list:[]; 36, for_statement; 36, 37; 36, 41; 36, 50; 37, pattern_list; 37, 38; 37, 39; 37, 40; 38, identifier:x; 39, identifier:y; 40, identifier:z; 41, call; 41, 42; 41, 45; 42, attribute; 42, 43; 42, 44; 43, identifier:rdfGraph; 44, identifier:triples; 45, argument_list; 45, 46; 46, tuple; 46, 47; 46, 48; 46, 49; 47, identifier:anEntity; 48, None; 49, None; 50, block; 50, 51; 50, 60; 51, if_statement; 51, 52; 51, 58; 52, boolean_operator:and; 52, 53; 52, 54; 53, identifier:excludeBNodes; 54, call; 54, 55; 54, 56; 55, identifier:isBlankNode; 56, argument_list; 56, 57; 57, identifier:z; 58, block; 58, 59; 59, continue_statement; 60, if_statement; 60, 61; 60, 64; 61, comparison_operator:not; 61, 62; 61, 63; 62, identifier:y; 63, identifier:excludeProps; 64, block; 64, 65; 65, expression_statement; 65, 66; 66, augmented_assignment:+=; 66, 67; 66, 68; 67, identifier:temp; 68, list:[(y, z)]; 68, 69; 69, tuple; 69, 70; 69, 71; 70, identifier:y; 71, identifier:z; 72, if_statement; 72, 73; 72, 82; 72, 148; 73, comparison_operator:==; 73, 74; 73, 78; 74, call; 74, 75; 74, 76; 75, identifier:type; 76, argument_list; 76, 77; 77, identifier:orderProps; 78, call; 78, 79; 78, 80; 79, identifier:type; 80, argument_list; 80, 81; 81, list:[]; 82, block; 82, 83; 82, 97; 82, 114; 82, 128; 83, expression_statement; 83, 84; 84, assignment; 84, 85; 84, 86; 85, identifier:orderedUris; 86, call; 86, 87; 86, 88; 87, identifier:sortByNamespacePrefix; 88, argument_list; 88, 89; 88, 96; 89, list_comprehension; 89, 90; 89, 91; 90, identifier:y; 91, for_in_clause; 91, 92; 91, 95; 92, pattern_list; 92, 93; 92, 94; 93, identifier:y; 94, identifier:z; 95, identifier:temp; 96, identifier:orderProps; 97, expression_statement; 97, 98; 98, assignment; 98, 99; 98, 100; 99, identifier:orderedUris; 100, list_comprehension; 100, 101; 100, 106; 101, tuple; 101, 102; 101, 105; 102, binary_operator:+; 102, 103; 102, 104; 103, identifier:n; 104, integer:1; 105, identifier:x; 106, for_in_clause; 106, 107; 106, 110; 107, pattern_list; 107, 108; 107, 109; 108, identifier:n; 109, identifier:x; 110, call; 110, 111; 110, 112; 111, identifier:enumerate; 112, argument_list; 112, 113; 113, identifier:orderedUris; 114, expression_statement; 114, 115; 115, assignment; 115, 116; 115, 117; 116, identifier:rank; 117, call; 117, 118; 117, 119; 118, identifier:dict; 119, generator_expression; 119, 120; 119, 123; 120, tuple; 120, 121; 120, 122; 121, identifier:key; 122, identifier:rank; 123, for_in_clause; 123, 124; 123, 127; 124, tuple_pattern; 124, 125; 124, 126; 125, identifier:rank; 126, identifier:key; 127, identifier:orderedUris; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 131; 130, identifier:temp; 131, call; 131, 132; 131, 133; 132, identifier:sorted; 133, argument_list; 133, 134; 133, 135; 134, identifier:temp; 135, keyword_argument; 135, 136; 135, 137; 136, identifier:key; 137, lambda; 137, 138; 137, 140; 138, lambda_parameters; 138, 139; 139, identifier:tup; 140, call; 140, 141; 140, 144; 141, attribute; 141, 142; 141, 143; 142, identifier:rank; 143, identifier:get; 144, argument_list; 144, 145; 145, subscript; 145, 146; 145, 147; 146, identifier:tup; 147, integer:0; 148, elif_clause; 148, 149; 148, 150; 149, identifier:orderProps; 150, block; 150, 151; 151, expression_statement; 151, 152; 152, assignment; 152, 153; 152, 154; 153, identifier:temp; 154, call; 154, 155; 154, 156; 155, identifier:sorted; 156, argument_list; 156, 157; 156, 158; 157, identifier:temp; 158, keyword_argument; 158, 159; 158, 160; 159, identifier:key; 160, lambda; 160, 161; 160, 163; 161, lambda_parameters; 161, 162; 162, identifier:tup; 163, subscript; 163, 164; 163, 165; 164, identifier:tup; 165, integer:0; 166, return_statement; 166, 167; 167, identifier:temp | def entityTriples(rdfGraph, anEntity, excludeProps=False, excludeBNodes=False,
orderProps=[RDF, RDFS, OWL.OWLNS, DC.DCNS]):
temp = []
if not excludeProps:
excludeProps = []
for x, y, z in rdfGraph.triples((anEntity, None, None)):
if excludeBNodes and isBlankNode(z):
continue
if y not in excludeProps:
temp += [(y, z)]
if type(orderProps) == type([]):
orderedUris = sortByNamespacePrefix([y for y, z in temp], orderProps)
orderedUris = [(n + 1, x) for n, x in
enumerate(orderedUris)]
rank = dict((key, rank) for (rank, key) in orderedUris)
temp = sorted(temp, key=lambda tup: rank.get(tup[0]))
elif orderProps:
temp = sorted(temp, key=lambda tup: tup[0])
return temp |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:msvd; 3, parameters; 3, 4; 4, identifier:m; 5, block; 5, 6; 5, 20; 5, 28; 5, 34; 5, 42; 5, 48; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 12; 8, pattern_list; 8, 9; 8, 10; 8, 11; 9, identifier:u; 10, identifier:s; 11, identifier:vdgr; 12, call; 12, 13; 12, 18; 13, attribute; 13, 14; 13, 17; 14, attribute; 14, 15; 14, 16; 15, identifier:np; 16, identifier:linalg; 17, identifier:svd; 18, argument_list; 18, 19; 19, identifier:m; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:order; 23, call; 23, 24; 23, 27; 24, attribute; 24, 25; 24, 26; 25, identifier:s; 26, identifier:argsort; 27, argument_list; 28, expression_statement; 28, 29; 29, assignment; 29, 30; 29, 31; 30, identifier:s; 31, subscript; 31, 32; 31, 33; 32, identifier:s; 33, identifier:order; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:u; 37, subscript; 37, 38; 37, 39; 37, 41; 38, identifier:u; 39, slice; 39, 40; 40, colon; 41, identifier:order; 42, expression_statement; 42, 43; 43, assignment; 43, 44; 43, 45; 44, identifier:vdgr; 45, subscript; 45, 46; 45, 47; 46, identifier:vdgr; 47, identifier:order; 48, return_statement; 48, 49; 49, expression_list; 49, 50; 49, 51; 49, 52; 50, identifier:u; 51, identifier:s; 52, attribute; 52, 53; 52, 58; 53, call; 53, 54; 53, 57; 54, attribute; 54, 55; 54, 56; 55, identifier:vdgr; 56, identifier:conj; 57, argument_list; 58, identifier:T | def msvd(m):
u, s, vdgr = np.linalg.svd(m)
order = s.argsort()
s = s[order]
u= u[:,order]
vdgr = vdgr[order]
return u, s, vdgr.conj().T |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 6; 2, function_name:_rows_sort; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, identifier:rows; 6, block; 6, 7; 7, return_statement; 7, 8; 8, call; 8, 9; 8, 10; 9, identifier:sorted; 10, argument_list; 10, 11; 10, 12; 11, identifier:rows; 12, keyword_argument; 12, 13; 12, 14; 13, identifier:key; 14, lambda; 14, 15; 14, 17; 15, lambda_parameters; 15, 16; 16, identifier:row; 17, tuple; 17, 18; 17, 23; 18, subscript; 18, 19; 18, 20; 19, identifier:row; 20, attribute; 20, 21; 20, 22; 21, identifier:self; 22, identifier:_key_start_date; 23, subscript; 23, 24; 23, 25; 24, identifier:row; 25, attribute; 25, 26; 25, 27; 26, identifier:self; 27, identifier:_key_end_date | def _rows_sort(self, rows):
return sorted(rows, key=lambda row: (row[self._key_start_date], row[self._key_end_date])) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 8; 2, function_name:get_rows; 3, parameters; 3, 4; 3, 5; 4, identifier:self; 5, default_parameter; 5, 6; 5, 7; 6, identifier:sort; 7, False; 8, block; 8, 9; 8, 13; 8, 51; 9, expression_statement; 9, 10; 10, assignment; 10, 11; 10, 12; 11, identifier:ret; 12, list:[]; 13, for_statement; 13, 14; 13, 17; 13, 36; 14, pattern_list; 14, 15; 14, 16; 15, identifier:_; 16, identifier:rows; 17, conditional_expression:if; 17, 18; 17, 28; 17, 29; 18, call; 18, 19; 18, 20; 19, identifier:sorted; 20, argument_list; 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:_rows; 26, identifier:items; 27, argument_list; 28, identifier:sort; 29, call; 29, 30; 29, 35; 30, attribute; 30, 31; 30, 34; 31, attribute; 31, 32; 31, 33; 32, identifier:self; 33, identifier:_rows; 34, identifier:items; 35, argument_list; 36, block; 36, 37; 36, 44; 37, expression_statement; 37, 38; 38, call; 38, 39; 38, 42; 39, attribute; 39, 40; 39, 41; 40, identifier:self; 41, identifier:_rows_int2date; 42, argument_list; 42, 43; 43, identifier:rows; 44, expression_statement; 44, 45; 45, call; 45, 46; 45, 49; 46, attribute; 46, 47; 46, 48; 47, identifier:ret; 48, identifier:extend; 49, argument_list; 49, 50; 50, identifier:rows; 51, return_statement; 51, 52; 52, identifier:ret | def get_rows(self, sort=False):
ret = []
for _, rows in sorted(self._rows.items()) if sort else self._rows.items():
self._rows_int2date(rows)
ret.extend(rows)
return ret |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:get_entries; 3, parameters; 3, 4; 4, identifier:path; 5, block; 5, 6; 5, 14; 5, 57; 5, 63; 5, 69; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 11; 8, pattern_list; 8, 9; 8, 10; 9, identifier:dirs; 10, identifier:files; 11, expression_list; 11, 12; 11, 13; 12, list:[]; 13, list:[]; 14, for_statement; 14, 15; 14, 16; 14, 22; 15, identifier:entry; 16, call; 16, 17; 16, 20; 17, attribute; 17, 18; 17, 19; 18, identifier:os; 19, identifier:listdir; 20, argument_list; 20, 21; 21, identifier:path; 22, block; 22, 23; 23, if_statement; 23, 24; 23, 40; 23, 48; 24, call; 24, 25; 24, 30; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:os; 28, identifier:path; 29, identifier:isdir; 30, argument_list; 30, 31; 31, call; 31, 32; 31, 37; 32, attribute; 32, 33; 32, 36; 33, attribute; 33, 34; 33, 35; 34, identifier:os; 35, identifier:path; 36, identifier:join; 37, argument_list; 37, 38; 37, 39; 38, identifier:path; 39, identifier:entry; 40, block; 40, 41; 41, expression_statement; 41, 42; 42, call; 42, 43; 42, 46; 43, attribute; 43, 44; 43, 45; 44, identifier:dirs; 45, identifier:append; 46, argument_list; 46, 47; 47, identifier:entry; 48, else_clause; 48, 49; 49, block; 49, 50; 50, expression_statement; 50, 51; 51, call; 51, 52; 51, 55; 52, attribute; 52, 53; 52, 54; 53, identifier:files; 54, identifier:append; 55, argument_list; 55, 56; 56, identifier:entry; 57, expression_statement; 57, 58; 58, call; 58, 59; 58, 62; 59, attribute; 59, 60; 59, 61; 60, identifier:dirs; 61, identifier:sort; 62, argument_list; 63, expression_statement; 63, 64; 64, call; 64, 65; 64, 68; 65, attribute; 65, 66; 65, 67; 66, identifier:files; 67, identifier:sort; 68, argument_list; 69, return_statement; 69, 70; 70, expression_list; 70, 71; 70, 72; 71, identifier:dirs; 72, identifier:files | def get_entries(path):
dirs, files = [], []
for entry in os.listdir(path):
if os.path.isdir(os.path.join(path, entry)):
dirs.append(entry)
else:
files.append(entry)
dirs.sort()
files.sort()
return dirs, files |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort; 3, parameters; 3, 4; 4, identifier:ctx; 5, block; 5, 6; 5, 14; 5, 22; 5, 30; 5, 38; 5, 49; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:head; 9, attribute; 9, 10; 9, 13; 10, attribute; 10, 11; 10, 12; 11, identifier:ctx; 12, identifier:parent; 13, identifier:head; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:vcf_handle; 17, attribute; 17, 18; 17, 21; 18, attribute; 18, 19; 18, 20; 19, identifier:ctx; 20, identifier:parent; 21, identifier:handle; 22, expression_statement; 22, 23; 23, assignment; 23, 24; 23, 25; 24, identifier:outfile; 25, attribute; 25, 26; 25, 29; 26, attribute; 26, 27; 26, 28; 27, identifier:ctx; 28, identifier:parent; 29, identifier:outfile; 30, expression_statement; 30, 31; 31, assignment; 31, 32; 31, 33; 32, identifier:silent; 33, attribute; 33, 34; 33, 37; 34, attribute; 34, 35; 34, 36; 35, identifier:ctx; 36, identifier:parent; 37, identifier:silent; 38, expression_statement; 38, 39; 39, call; 39, 40; 39, 41; 40, identifier:print_headers; 41, argument_list; 41, 42; 41, 43; 41, 46; 42, identifier:head; 43, keyword_argument; 43, 44; 43, 45; 44, identifier:outfile; 45, identifier:outfile; 46, keyword_argument; 46, 47; 46, 48; 47, identifier:silent; 48, identifier:silent; 49, for_statement; 49, 50; 49, 51; 49, 55; 50, identifier:line; 51, call; 51, 52; 51, 53; 52, identifier:sort_variants; 53, argument_list; 53, 54; 54, identifier:vcf_handle; 55, block; 55, 56; 56, expression_statement; 56, 57; 57, call; 57, 58; 57, 59; 58, identifier:print_variant; 59, argument_list; 59, 60; 59, 63; 59, 66; 60, keyword_argument; 60, 61; 60, 62; 61, identifier:variant_line; 62, identifier:line; 63, keyword_argument; 63, 64; 63, 65; 64, identifier:outfile; 65, identifier:outfile; 66, keyword_argument; 66, 67; 66, 68; 67, identifier:silent; 68, identifier:silent | def sort(ctx):
head = ctx.parent.head
vcf_handle = ctx.parent.handle
outfile = ctx.parent.outfile
silent = ctx.parent.silent
print_headers(head, outfile=outfile, silent=silent)
for line in sort_variants(vcf_handle):
print_variant(variant_line=line, outfile=outfile, silent=silent) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_sort_to_str; 3, parameters; 3, 4; 4, identifier:self; 5, block; 5, 6; 5, 10; 5, 14; 5, 53; 5, 67; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:params_list; 9, list:[]; 10, expression_statement; 10, 11; 11, assignment; 11, 12; 11, 13; 12, identifier:timestamp; 13, string:""; 14, for_statement; 14, 15; 14, 18; 14, 27; 15, pattern_list; 15, 16; 15, 17; 16, identifier:k; 17, identifier:v; 18, call; 18, 19; 18, 26; 19, attribute; 19, 20; 19, 25; 20, subscript; 20, 21; 20, 24; 21, attribute; 21, 22; 21, 23; 22, identifier:self; 23, identifier:_solr_params; 24, string:'sort'; 25, identifier:items; 26, argument_list; 27, block; 27, 28; 28, if_statement; 28, 29; 28, 32; 28, 47; 29, comparison_operator:!=; 29, 30; 29, 31; 30, identifier:k; 31, string:"timestamp"; 32, block; 32, 33; 33, expression_statement; 33, 34; 34, call; 34, 35; 34, 38; 35, attribute; 35, 36; 35, 37; 36, identifier:params_list; 37, identifier:append; 38, argument_list; 38, 39; 39, call; 39, 40; 39, 43; 40, attribute; 40, 41; 40, 42; 41, string:" "; 42, identifier:join; 43, argument_list; 43, 44; 44, list:[k, v]; 44, 45; 44, 46; 45, identifier:k; 46, identifier:v; 47, else_clause; 47, 48; 48, block; 48, 49; 49, expression_statement; 49, 50; 50, assignment; 50, 51; 50, 52; 51, identifier:timestamp; 52, identifier:v; 53, expression_statement; 53, 54; 54, call; 54, 55; 54, 58; 55, attribute; 55, 56; 55, 57; 56, identifier:params_list; 57, identifier:append; 58, argument_list; 58, 59; 59, call; 59, 60; 59, 63; 60, attribute; 60, 61; 60, 62; 61, string:" "; 62, identifier:join; 63, argument_list; 63, 64; 64, list:['timestamp', timestamp]; 64, 65; 64, 66; 65, string:'timestamp'; 66, identifier:timestamp; 67, expression_statement; 67, 68; 68, assignment; 68, 69; 68, 74; 69, subscript; 69, 70; 69, 73; 70, attribute; 70, 71; 70, 72; 71, identifier:self; 72, identifier:_solr_params; 73, string:'sort'; 74, call; 74, 75; 74, 78; 75, attribute; 75, 76; 75, 77; 76, string:", "; 77, identifier:join; 78, argument_list; 78, 79; 79, identifier:params_list | def _sort_to_str(self):
params_list = []
timestamp = ""
for k, v in self._solr_params['sort'].items():
if k != "timestamp":
params_list.append(" ".join([k, v]))
else:
timestamp = v
params_list.append(" ".join(['timestamp', timestamp]))
self._solr_params['sort'] = ", ".join(params_list) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:_get_video_ts_file_paths; 3, parameters; 3, 4; 4, identifier:dvd_path; 5, block; 5, 6; 5, 14; 5, 18; 5, 46; 6, expression_statement; 6, 7; 7, assignment; 7, 8; 7, 9; 8, identifier:video_ts_folder_path; 9, call; 9, 10; 9, 11; 10, identifier:join; 11, argument_list; 11, 12; 11, 13; 12, identifier:dvd_path; 13, string:"VIDEO_TS"; 14, expression_statement; 14, 15; 15, assignment; 15, 16; 15, 17; 16, identifier:video_ts_file_paths; 17, list:[]; 18, for_statement; 18, 19; 18, 20; 18, 24; 19, identifier:video_ts_folder_content_name; 20, call; 20, 21; 20, 22; 21, identifier:listdir; 22, argument_list; 22, 23; 23, identifier:video_ts_folder_path; 24, block; 24, 25; 24, 33; 25, expression_statement; 25, 26; 26, assignment; 26, 27; 26, 28; 27, identifier:video_ts_folder_content_path; 28, call; 28, 29; 28, 30; 29, identifier:join; 30, argument_list; 30, 31; 30, 32; 31, identifier:video_ts_folder_path; 32, identifier:video_ts_folder_content_name; 33, if_statement; 33, 34; 33, 38; 34, call; 34, 35; 34, 36; 35, identifier:isfile; 36, argument_list; 36, 37; 37, identifier:video_ts_folder_content_path; 38, block; 38, 39; 39, expression_statement; 39, 40; 40, call; 40, 41; 40, 44; 41, attribute; 41, 42; 41, 43; 42, identifier:video_ts_file_paths; 43, identifier:append; 44, argument_list; 44, 45; 45, identifier:video_ts_folder_content_path; 46, return_statement; 46, 47; 47, call; 47, 48; 47, 49; 48, identifier:sorted; 49, argument_list; 49, 50; 50, identifier:video_ts_file_paths | def _get_video_ts_file_paths(dvd_path):
video_ts_folder_path = join(dvd_path, "VIDEO_TS")
video_ts_file_paths = []
for video_ts_folder_content_name in listdir(video_ts_folder_path):
video_ts_folder_content_path = join(video_ts_folder_path, video_ts_folder_content_name)
if isfile(video_ts_folder_content_path):
video_ts_file_paths.append(video_ts_folder_content_path)
return sorted(video_ts_file_paths) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 5; 2, function_name:sort_ranges; 3, parameters; 3, 4; 4, identifier:inranges; 5, block; 5, 6; 6, return_statement; 6, 7; 7, call; 7, 8; 7, 9; 8, identifier:sorted; 9, argument_list; 9, 10; 9, 11; 10, identifier:inranges; 11, keyword_argument; 11, 12; 11, 13; 12, identifier:key; 13, lambda; 13, 14; 13, 16; 14, lambda_parameters; 14, 15; 15, identifier:x; 16, tuple; 16, 17; 16, 20; 16, 23; 16, 26; 17, attribute; 17, 18; 17, 19; 18, identifier:x; 19, identifier:chr; 20, attribute; 20, 21; 20, 22; 21, identifier:x; 22, identifier:start; 23, attribute; 23, 24; 23, 25; 24, identifier:x; 25, identifier:end; 26, attribute; 26, 27; 26, 28; 27, identifier:x; 28, identifier:direction | def sort_ranges(inranges):
return sorted(inranges,key=lambda x: (x.chr,x.start,x.end,x.direction)) |
0, module; 0, 1; 1, function_definition; 1, 2; 1, 3; 1, 9; 2, function_name:subtract_ranges; 3, parameters; 3, 4; 3, 5; 3, 6; 4, identifier:r1s; 5, identifier:r2s; 6, default_parameter; 6, 7; 6, 8; 7, identifier:already_sorted; 8, False; 9, block; 9, 10; 9, 16; 9, 34; 9, 38; 9, 53; 9, 57; 9, 61; 9, 254; 10, import_from_statement; 10, 11; 10, 14; 11, dotted_name; 11, 12; 11, 13; 12, identifier:seqtools; 13, identifier:stream; 14, dotted_name; 14, 15; 15, identifier:MultiLocusStream; 16, if_statement; 16, 17; 16, 19; 17, not_operator; 17, 18; 18, identifier:already_sorted; 19, block; 19, 20; 19, 27; 20, expression_statement; 20, 21; 21, assignment; 21, 22; 21, 23; 22, identifier:r1s; 23, call; 23, 24; 23, 25; 24, identifier:merge_ranges; 25, argument_list; 25, 26; 26, identifier:r1s; 27, expression_statement; 27, 28; 28, assignment; 28, 29; 28, 30; 29, identifier:r2s; 30, call; 30, 31; 30, 32; 31, identifier:merge_ranges; 32, argument_list; 32, 33; 33, identifier:r2s; 34, expression_statement; 34, 35; 35, assignment; 35, 36; 35, 37; 36, identifier:outputs; 37, list:[]; 38, expression_statement; 38, 39; 39, assignment; 39, 40; 39, 41; 40, identifier:mls; 41, call; 41, 42; 41, 43; 42, identifier:MultiLocusStream; 43, argument_list; 43, 44; 44, list:[BedArrayStream(r1s),BedArrayStream(r2s)]; 44, 45; 44, 49; 45, call; 45, 46; 45, 47; 46, identifier:BedArrayStream; 47, argument_list; 47, 48; 48, identifier:r1s; 49, call; 49, 50; 49, 51; 50, identifier:BedArrayStream; 51, argument_list; 51, 52; 52, identifier:r2s; 53, expression_statement; 53, 54; 54, assignment; 54, 55; 54, 56; 55, identifier:tot1; 56, integer:0; 57, expression_statement; 57, 58; 58, assignment; 58, 59; 58, 60; 59, identifier:tot2; 60, integer:0; 61, for_statement; 61, 62; 61, 63; 61, 64; 62, identifier:loc; 63, identifier:mls; 64, block; 64, 65; 64, 71; 64, 77; 64, 84; 64, 91; 64, 100; 64, 113; 64, 117; 64, 134; 64, 138; 64, 145; 64, 206; 65, expression_statement; 65, 66; 66, assignment; 66, 67; 66, 68; 67, identifier:v; 68, attribute; 68, 69; 68, 70; 69, identifier:loc; 70, identifier:payload; 71, expression_statement; 71, 72; 72, assignment; 72, 73; 72, 76; 73, list_pattern; 73, 74; 73, 75; 74, identifier:beds1; 75, identifier:beds2; 76, identifier:v; 77, expression_statement; 77, 78; 78, assignment; 78, 79; 78, 80; 79, identifier:beds1; 80, subscript; 80, 81; 80, 82; 81, identifier:beds1; 82, slice; 82, 83; 83, colon; 84, expression_statement; 84, 85; 85, assignment; 85, 86; 85, 87; 86, identifier:beds2; 87, subscript; 87, 88; 87, 89; 88, identifier:beds2; 89, slice; 89, 90; 90, colon; 91, if_statement; 91, 92; 91, 98; 92, comparison_operator:==; 92, 93; 92, 97; 93, call; 93, 94; 93, 95; 94, identifier:len; 95, argument_list; 95, 96; 96, identifier:beds1; 97, integer:0; 98, block; 98, 99; 99, continue_statement; 100, if_statement; 100, 101; 100, 107; 101, comparison_operator:==; 101, 102; 101, 106; 102, call; 102, 103; 102, 104; 103, identifier:len; 104, argument_list; 104, 105; 105, identifier:beds2; 106, integer:0; 107, block; 107, 108; 107, 112; 108, expression_statement; 108, 109; 109, augmented_assignment:+=; 109, 110; 109, 111; 110, identifier:outputs; 111, identifier:beds1; 112, continue_statement; 113, expression_statement; 113, 114; 114, assignment; 114, 115; 114, 116; 115, identifier:mapping; 116, dictionary; 117, for_statement; 117, 118; 117, 119; 117, 127; 118, identifier:i; 119, call; 119, 120; 119, 121; 120, identifier:range; 121, argument_list; 121, 122; 121, 123; 122, integer:0; 123, call; 123, 124; 123, 125; 124, identifier:len; 125, argument_list; 125, 126; 126, identifier:beds1; 127, block; 127, 128; 128, expression_statement; 128, 129; 129, assignment; 129, 130; 129, 133; 130, subscript; 130, 131; 130, 132; 131, identifier:mapping; 132, identifier:i; 133, list:[]; 134, expression_statement; 134, 135; 135, assignment; 135, 136; 135, 137; 136, identifier:beds2min; 137, integer:0; 138, expression_statement; 138, 139; 139, assignment; 139, 140; 139, 141; 140, identifier:beds2max; 141, call; 141, 142; 141, 143; 142, identifier:len; 143, argument_list; 143, 144; 144, identifier:beds2; 145, for_statement; 145, 146; 145, 147; 145, 155; 146, identifier:i; 147, call; 147, 148; 147, 149; 148, identifier:range; 149, argument_list; 149, 150; 149, 151; 150, integer:0; 151, call; 151, 152; 151, 153; 152, identifier:len; 153, argument_list; 153, 154; 154, identifier:beds1; 155, block; 155, 156; 156, for_statement; 156, 157; 156, 158; 156, 163; 157, identifier:j; 158, call; 158, 159; 158, 160; 159, identifier:range; 160, argument_list; 160, 161; 160, 162; 161, identifier:beds2min; 162, identifier:beds2max; 163, block; 163, 164; 163, 177; 164, expression_statement; 164, 165; 165, assignment; 165, 166; 165, 167; 166, identifier:cmpval; 167, call; 167, 168; 167, 173; 168, attribute; 168, 169; 168, 172; 169, subscript; 169, 170; 169, 171; 170, identifier:beds1; 171, identifier:i; 172, identifier:cmp; 173, argument_list; 173, 174; 174, subscript; 174, 175; 174, 176; 175, identifier:beds2; 176, identifier:j; 177, if_statement; 177, 178; 177, 182; 177, 189; 177, 203; 178, comparison_operator:==; 178, 179; 178, 180; 179, identifier:cmpval; 180, unary_operator:-; 180, 181; 181, integer:1; 182, block; 182, 183; 183, expression_statement; 183, 184; 184, assignment; 184, 185; 184, 186; 185, identifier:beds2min; 186, binary_operator:+; 186, 187; 186, 188; 187, identifier:j; 188, integer:1; 189, elif_clause; 189, 190; 189, 193; 190, comparison_operator:==; 190, 191; 190, 192; 191, identifier:cmpval; 192, integer:0; 193, block; 193, 194; 194, expression_statement; 194, 195; 195, call; 195, 196; 195, 201; 196, attribute; 196, 197; 196, 200; 197, subscript; 197, 198; 197, 199; 198, identifier:mapping; 199, identifier:i; 200, identifier:append; 201, argument_list; 201, 202; 202, identifier:j; 203, else_clause; 203, 204; 204, block; 204, 205; 205, break_statement; 206, for_statement; 206, 207; 206, 208; 206, 216; 207, identifier:i; 208, call; 208, 209; 208, 210; 209, identifier:range; 210, argument_list; 210, 211; 210, 212; 211, integer:0; 212, call; 212, 213; 212, 214; 213, identifier:len; 214, argument_list; 214, 215; 215, identifier:beds1; 216, block; 216, 217; 217, if_statement; 217, 218; 217, 226; 217, 231; 218, comparison_operator:==; 218, 219; 218, 225; 219, call; 219, 220; 219, 221; 220, identifier:len; 221, argument_list; 221, 222; 222, subscript; 222, 223; 222, 224; 223, identifier:mapping; 224, identifier:i; 225, integer:0; 226, block; 226, 227; 227, expression_statement; 227, 228; 228, augmented_assignment:+=; 228, 229; 228, 230; 229, identifier:outputs; 230, identifier:beds1; 231, else_clause; 231, 232; 232, block; 232, 233; 233, expression_statement; 233, 234; 234, augmented_assignment:+=; 234, 235; 234, 236; 235, identifier:outputs; 236, call; 236, 237; 236, 238; 237, identifier:subtract_range_array; 238, argument_list; 238, 239; 238, 242; 238, 251; 239, subscript; 239, 240; 239, 241; 240, identifier:beds1; 241, identifier:i; 242, list_comprehension; 242, 243; 242, 246; 243, subscript; 243, 244; 243, 245; 244, identifier:beds2; 245, identifier:j; 246, for_in_clause; 246, 247; 246, 248; 247, identifier:j; 248, subscript; 248, 249; 248, 250; 249, identifier:mapping; 250, identifier:i; 251, keyword_argument; 251, 252; 251, 253; 252, identifier:is_sorted; 253, True; 254, return_statement; 254, 255; 255, call; 255, 256; 255, 257; 256, identifier:merge_ranges; 257, argument_list; 257, 258; 258, identifier:outputs | def subtract_ranges(r1s,r2s,already_sorted=False):
from seqtools.stream import MultiLocusStream
if not already_sorted:
r1s = merge_ranges(r1s)
r2s = merge_ranges(r2s)
outputs = []
mls = MultiLocusStream([BedArrayStream(r1s),BedArrayStream(r2s)])
tot1 = 0
tot2 = 0
for loc in mls:
v = loc.payload
[beds1,beds2] =v
beds1 = beds1[:]
beds2 = beds2[:]
if len(beds1)==0:
continue
if len(beds2)==0:
outputs += beds1
continue
mapping = {}
for i in range(0,len(beds1)):
mapping[i] = []
beds2min = 0
beds2max = len(beds2)
for i in range(0,len(beds1)):
for j in range(beds2min,beds2max):
cmpval = beds1[i].cmp(beds2[j])
if cmpval == -1:
beds2min = j+1
elif cmpval == 0:
mapping[i].append(j)
else:
break
for i in range(0,len(beds1)):
if len(mapping[i])==0: outputs += beds1
else:
outputs += subtract_range_array(beds1[i],[beds2[j] for j in mapping[i]],is_sorted=True)
return merge_ranges(outputs) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.